Usage of inner class

Question

I can understand what inner class is and how to write program. My question is in what situation do programmers really need inner class?

Answer 1

Sometimes there is some functionality which is best represented as an object, but which is only meaningful within the context of another object, which does not necessarily need to be exposed to the outside world, and which can benefit from having access to the parent classes data (so as to not violate encapsulation).

The best example that I can think of is putting a Node class inside of a LinkedList. Nodes are only meaningful to the LinkedList, so they only exist within one. No one outside of the LinkedList cares about nodes or should have access to them.

Answer 2

1. When you want to specify a class that has sence only in context with the bounded one.

   For example you write a MathOperations class that can execute four operations. So the operations can be represented as inner enum MathOps.

2. When the inner class is not used anywhere except the inbounded one.

3. You use anonymous inner classes to specify only the operation, for exmple if you want to sort a collection, you specify a Comparable class just for one method compare.

     Collections.sort(employments, new Comparator<Employment>() {
   
   
       @Override
       public int compare(Employment o1, Employment o2) {
           return o1.getStartDate().before(o2.getStartDate()) ? 1 : -1 ;
       }
   });
   
   
   

Answer 3

An inner class allows us to remove that logic and place it into its own class. So from an object-oriented point of view, we've taken functionality out of where it doesn't belong and have put it into its own class.

Please go through this link....

http://www.javaworld.com/javaworld/javaqa/2000-03/02-qa-innerclass.html

Answer 4

Also as you know in Java exists nested classes, which is static inner clasess.

From previous posts becomes clear when we need to use an inner class but I think you also interested in the question "Why we need nested classes (static inner class)".

The answer is simply, there is the same purpose as for the inner class except few things.

1) The nested class (static inner) is required when we whant to exclude some logic that concerns another object but this logic might be used in outworld.

The simpliest examples is a builders or editors of some object. For example we have class Foo which may have a lot of optional fields, to construct such object we may decide to introduce a builder class which will do this work.

    public class Foo {
    private int param1;
    private int param2;
    private int param3;

    private Foo(FooBuilder builder) {
        this.param1 = builder.param1;
        this.param2 = builder.param2;
        this.param3 = builder.param3;
    }

    public int getParam1() {
        return param1;
    }

    public void setParam1(int param1) {
        this.param1 = param1;
    }

    public int getParam2() {
        return param2;
    }

    public void setParam2(int param2) {
        this.param2 = param2;
    }

    public int getParam3() {
        return param3;
    }

    public void setParam3(int param3) {
        this.param3 = param3;
    }

    public static class FooBuilder {
        private int param1;
        private int param2;
        private int param3;

        public FooBuilder() {
        }

        public FooBuilder withParameter1(int param1) {
            this.param1 = param1;
            return this;
        }

        public FooBuilder withParameter2(int param2) {
            this.param2 = param2;
            return this;
        }

        public FooBuilder withParameter3(int param3) {
            this.param3 = param3;
            return this;
        }

        public Foo build() {
            return new Foo(this);
        }
    }
}

This example illustrates at leas one reason why we need such classes

2) The second difference between inner and static inner classes is that the first one always has pointer to the parent class. Actully compiler creates synthetic field member for the non static inner class of the type of it's parent, exectly of this reason we can access private members of the parent class. The static inner clasess doesn't has such generated field member. For instance we has just simple parent class with declared non static inner class:

public class Foo {
    public class FooBuilder {
    }
}

but in fact if take into account the byte code it looks like:

public class Foo {
    public class FooBuilder {
        private Foo generatedNameHere;
    }
}

if you want you can figure out this throught generated byte code.