abstact private

[rhett howard]

Hey guys,
I was wondering why is abstract private allowed for inner class.Is it useful in any way?

Its not even allowed for the methods,correct?

Why is it allowed for inner classes???
Thanks........

[Henry Wong]

Why is it allowed for inner classes???

Why not?

Abstract methods don't make sense because polymorphism don't apply to private methods -- so having an abstract method that can't be overridden (ie. implemented) doesn't make sense.

There is no such issue for private abstract classes.

Henry

[Ruben Soto]

The reason why it's allowed for inner classes to be both abstract and private is because you could define a concrete subclass inside the enclosing class. In contrast, instance methods can't be both abstract and private, because the point of an abstract method is to be overridden in a subclass (but private methods can't be overridden.)

[rhett howard]

Thanks guys!!
That makes sense!! I wasn't really thinkin' about polymorphism inside a class.


Btw, If an inner class is abstract, does it make the enclosing class abstract too like with the instance methods?

[Ruben Soto]

rhett howard wrote:Thanks guys!!
That makes sense!! I wasn't really thinkin' about polymorphism inside a class.


Btw, If an inner class is abstract, does it make the enclosing class abstract too like with the instance methods?

Rhett, I don't think so. When a class has any abstract methods that makes the class abstract, because instantiating an object of such a class would make no sense (as it would have instance methods attached to it which would be undefined.) But when a class has an abstract inner class inside it, that doesn't make the class abstract. Take a look at this example code:

public class AbstractInner {
    private abstract class AI {
        public abstract String method1();
    }

    public static void main(String[] args) {
        AbstractInner ai = new AbstractInner(); // AbstractInner is not abstract
        AI a = ai.new AI() {
                              public String method1() {
                                                          return "In method1()";
                                                      }
                           };
        System.out.println(a.method1());
    }
}

[rhett howard]

Thanks Ruben!!

[Ruben Soto]

No problem Rhett. If you are interested in inner classes you can do a search in the forums. There are quite a few posts that are very interesting.

[NagarajGoud uppala]

Ruben Soto wrote:

rhett howard wrote:

public class AbstractInner {
    private abstract class AI {
        public abstract String method1();
    }

    public static void main(String[] args) {
        AbstractInner ai = new AbstractInner(); // AbstractInner is not abstract
        AI a = ai.new AI() {
                              public String method1() {
                                                          return "In method1()";
                                                      }
                           };
        System.out.println(a.method1());
    }
}

Hi Ruben,
your instantiating the abstract inner class by using the outer class object. In that your implementing the abstract method.here my question is all inner class abstract methods must be implemented like that only???
i mean with in the braces used while instantiating abstract inner class.

Thanks®ards,
Nagaraju.

[Tom Kowalski]

No, you can just implement new class directly, for example like this:

    
public class AbstractInner {  
    private abstract class AI {  
        public abstract String method1();  
    }  
  
    public class Inner2 extends AI {
    	public String method1(){return "HELLO";};  
    }
    
    public static void main(String[] args) {  
        AbstractInner ai = new AbstractInner(); 
        AbstractInner.Inner2 a = ai.new Inner2();  // or AbstractInner.AI a = ai.new Inner2();
        System.out.println(a.method1());  
    }  
}  

[NagarajGoud uppala]

Hi Tomas
Thanks..

[Ruben Soto]

Thanks for answering the question. Any class that you can extend via an anonymous inner class you can extend via a regular member class. I just thought I would have to type less code that way (I'm lazy.)

[rhett howard]

Yeah , I was reading this article
http://mindprod.com/jgloss/anonymousclasses.html

and it says :
If you want to baffle those maintaining your code, wags have discovered javac.exe will permit anonymous classes inside static init code and static methods, even though the language spec says than anonymous classes are never static. These anonymous classes, of course, have no access to the instance fields of the object. I don’t recommend doing this. The feature could be pulled at any time.


I don't know when this article is written, but is this feature already pulled? ...........

[rhett howard]

Now I am wondering watz wrong with anonymous classes inside a static method?..

Ruben, you just used one inside the static main method , rite?.......

It didn't baffle me at all!!!


Thanks.......

[Ruben Soto]

I didn't read the whole article, but based on the quote that you provide I think that the person that wrote that is a little confused. It's true that anonymous inner classes are never static classes (because static classes are technically not inner classes.) But just because you instantiate an anonymous inner class inside a static method, it doesn't make the class static. The same way that instantiating Integer inside a static method doesn't make Integer a static class. You can also define a regular local inner class inside a static method, and that doesn't make it a static class. It's true that it won't be able to access any instance members of the enclosing class unless it is via an reference to an instance of the enclosing class (because inside a static method there is no implied instance.) But you can only define static classes at the top level of the enclosing class (not inside any blocks.)

[rhett howard]

I thought he was confused too....

thanks......

[Ruben Soto]

No problem, Rhett. For the record, here is the classification of classes:

1. Top level classes.

2. Nested classes:
   2.1. Inner classes:
       2.1.1. Member inner classes
       2.1.2. Local inner classes
       2.1.3. Anonymous inner classes
   2.2. Member static classes