suresh mulagala

Ducking is passing exceptions up the stack and not handling them. This should give you a clear idea...

public class Test { public static void main(String args[]) throws Exception { Test t = new Test(); // this will throw exception // but we ducked it up the stack t.someMethod(); } public void someMethod() throws Exception{ // throwing some exception for testing // we declared that this method throws "Exception" throw new Exception(); } }

what if m2 is setting q1 to null ? by the time it gets to the sytem.out, all of them would have been de-referenced and eligible to GC so in that case will not be holding on to any...

Another case: if there were static fields in the class and m2 is setting them to static fields none of them will be eligible to GC as they all have living references.....am i right?

If you are referencing to a new object the old object will be eligible for GC.

Unless the old object is static i guess ....?

what does m2 do? im m2 if q1 reference is passed on and not de-referenced anywhere, they all wont be eligible for GC isint it? any other thoughts?

Originally posted by Adam Schaible:
De-compile your code, the compiler adds the throws clause.

I was trying to test this...
class test { public static void main (String[] args){ go(); // wont compile here } private static void go() throws Exception { throw new Exception(); } }

Leave alone de-compiling..the above code doesnt comile in the first place..so whats this thing adding to the main method meant???

protected variable x can be access in the same package or subclasses of the class in which they are declared isint it? Since Amir and Anand are in the same package....

New1 has access to x and all instantiations of New1 will provide this value i guess....correct me if im wrong...
[ October 04, 2007: Message edited by: suresh mulagala ]

Originally posted by Adam Schaible:
Essentially the JVM catches your uncaught exceptions, and terminates. Exceptions will "bubble" up the call stack until it's either caught by calling code, or is caught by the jvm.

When you compile:

public static void main(String[] args...){
}

The compiler changes it to:

public static void main(String[] args...) throws Exception {
}

Your calling code then throws the exception to the JVM, it's caught by the JVM, flushed to the error stream, and exits.

How do you know what the compiler appends? checking in a de-compiler? Just curious...

IllegalStateException is subclass of RuntimeException and are usually bugs of improper us of the API. Such as tying to call a method on a null object such as :

List getSomeList(){
return null;
}
int lst = getSomeList().size(); // will throw a null pointer exception

These are not meant to be caught but fixed. But having said that it can still be caught and handled programatically.

sorry overlooked !

Swathi try this...

class B1{ public static void main(String args[]){ A[] a1=new A[1]; A[][] a2=new A[2][1]; A[][][] a3=new A[3][3][3]; System.out.println(a3[2][2][2]); a1[0]=new B1().new A(); a2[0]=a2[1]=a1; a3[0]=a3[1]=a3[2]=a2; System.out.println(a3[2][2][2]);//1}} } class A {} }

why have you got brackets after inner class declaration?

public class MyInner() <--
[ October 03, 2007: Message edited by: suresh mulagala ]

Because a3 is being converted to a max of A[3][2][1] when you are doing

a3[0]=a3[1]=a3[2]=a2;

so the utmost you can do is a3[2][1][0]

You are accessing E2 in a static way and instantiating a static inner class...

i guess foo[1] is initialized and an instance but foo[] may not be one...

a1 is the superclass and you are overriding m1, so d1.m1(a1) is valid and prints "a" and so on and so forth...

here it is evaluating to A's method because you are passing in an instance of A().