Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Why nested abstract class in java

I am wondering what does it mean to have a nested abstract class ? for example,

   abstract class A{

          abstract class B{

          }
   }

Are there any use cases or scenario that we might need such as design ? or is there something useful in such pattern ? and why Java allows us to do it ?

like image 266
peter Avatar asked Nov 18 '12 06:11

peter


2 Answers

In design, you want the base class class A to present only an interface for its derived classes. This means, you don’t want anyone to actually instantiate an object of the base class. You only want to upcast to it (implicit upcasting, which gives you polymorphic behavior), so that its interface can be used. This is accomplished by making that class abstract using the abstract keyword. In other hand you want to use only part of functionality of class A so you create class B (as child) to reduce the coupling or implementation dependencies between systems and prevent duplicates.

But bear in mind when you define an inner class, code without inner classes is more maintainable and readable. When you access private data members of the outer class, the JDK compiler creates package-access member functions in the outer class for the inner class to access the private members. This leaves a security hole. In general we should avoid using inner classes. Use inner class only when an inner class is only relevant in the context of the outer class and/or inner class can be made private so that only outer class can access it. Inner classes are used primarily to implement helper classes like Iterators, Comparators etc which are used in the context of an outer class. About abstract class, it should be abstract to helpers, suppose your helpers should be too complicated to write abstract form for them.

In your case, I don't remember extensive usage of nested abstract classes, maybe in Swing world.

like image 174
Maxim Shoustin Avatar answered Oct 05 '22 22:10

Maxim Shoustin


abstract classes are used to provide a partial implementation of a class for inheritance. it allows you to define the scheme of a class without providing the full definiton, so that it can be specified in a child class. it works somewhat like a Interface in that you can perform any operation specified in the abstract class upon an instance of any classes derived from it. Nested abstracted classes are designed to be inherited by other inner classes (even anonymous ones I think) but not by classes defined outside the outermost class.

public class HelloEveryone{
    abstract class Hello{
        void SayHello(){
            System.out.println("Hello!");
        }

        abstract void SayHelloAlt();
    }

    public class HelloWorld extends Hello{
        public void SayHelloAlt(){
            System.out.println("HelloWorld!");
        } 
    }

    public class HelloUniverse extends Hello{
        public void SayHelloAlt(){
            System.out.println("HelloUniverse!");
        } 
    }

    void Go(){
        ArrayList<Hello> hellos = new ArrayList<Hello>();
        hellos.add(new HelloWorld());
        hellos.add(new HelloUniverse());


        for (Hello h : hellos){
            h.SayHello();
            h.SayHelloAlt();
        }
    }   

}

static void main(){
    HelloEveryone hello = new HelloEveryone();
    hello.Go();
}
like image 28
Frank Thomas Avatar answered Oct 05 '22 23:10

Frank Thomas