Inner class instantiation

Compiling the following code gives me error
public class A
public A()
boolean a=true;
class B
{ // removed syntax error "Inner"
    B()
      a = false;
public static void main(String [] arg)
    A a = new A();
    A.B ab = a.new A.B();
    System.out.println(a);
}The error I get is
"A.java": Error #: 200 : '(' expected at line 30, column 21
could somebody advise me as what I am doing wrong??

this will compile
public class A
public A()
boolean a=true;
static class B
{ // removed syntax error "Inner"
boolean a;
B()
a = false;
public static void main(String [] arg)
A a = new A();
B ab = new A.B();
System.out.println(a);
I was talking about a member inner class. Thanx anyway. Yahya's solution worked. Interesting thing is that the way I was instantiating it is mentioned in Java Sun Certified Programmer Book in Inner classes chapter. by Syngress. But that definitely seems to be a mistake.

Similar Messages

Instantiation an inner class using reflection

I want to instantiate an inner class using the Class.newInstance() method called within the Outer class constructor:
public Outer
public Outer()
Inner.class.newInstance();
private Class Inner { }
When I try it, however, I get an InstantiationException.
Is there some way to do this?
Thanks for the help.
Scott

Here is a consolidation of what everyone posted and it does appear to work. In one of your post you used the getDeclaredConstructors() method and said it was less than ideal; I am not sure what you meant but I suspect it was the hard coded array reference. Anyhow I used the getDeclaredConstructor() method which appears to get non-public constructors also and is basically the same as using the getConstructor() method.
import java.lang.reflect.*;
public class Test35 {
    static public void main(String[] args) {
        Test35 t35 = new Test35();
        t35.testIt();
    private class Inner {
        public String toString() {
            return "Hear I am";
    public void testIt() {
        try {
            Constructor con = Inner.class.getDeclaredConstructor(new Class[] {Test35.class});
            Inner in = (Inner)con.newInstance(new Object[] {this});
            System.out.println(in);
        } catch (Exception e) {
            e.printStackTrace();

Help: Factory Class using Inner Class and Private Constructor?

The situation is as follows:
I want a GamesCollection class that instantiates Game objects by looking up the information needed from a database. I would like to use Game outside of GamesCollection, but only have it instantiated by GamesCollection to ensure the game actually exist. Each Game object is linked to a database record. If a Game object exist, it must also exist in the database. Game objects can never be removed from the database.
I thought about making the Game object an inner class of GamesCollection, but this means that Game class constructor is still visible outside. So what if I made Game constructor private? Well, now I can't create Game objects without a static method inside Game class (static Object factory).
Basically what I need is a constructor for the inner Game class accessible to GamesCollection, but not to the rest of the world (including packages). Is there a way to do this?

leesiulung wrote:
As a second look, I was initially confused about your first implementation, but it now makes more sense.
Let me make sure I understand this:
- the interface is needed to make the class accessible outside the outer classBetter: it is necessary to have a type that is accessible outside of GameCollection -- what else could be the return type of instance?
- the instance() method is the object factory
- the private modifier for the inner class is to prevent outside classes to instantiate this objectRight.
However, is a private inner class accessible in the outer class? Try it and see.
How does this affect private/public modifiers on inner classes?Take about five minutes and write a few tests. That should answer any questions you may have.
How do instantiate a GameImpl object? This basically goes back to the first question.Filling out the initial solution:
public interface Game {
    String method();
public class GameCollection {
    private static class GameImpl implements Game {
        public String method() {
            return "GameImpl";
    public Game instance() {
        return new GameImpl();
    public static void main(String[] args) {
        GameCollection app = new GameCollection();
        Game game = app.instance();
        System.out.println(game.method());
}Even if you were not interested in controlling game creation, defining interfaces for key concepts like Game is always going to be a good idea. Consider how you will write testing code, for example. How will you mock Game?

How to override a method in an inner class of the super class

I have a rather horribly written class, which I need to adapt. I could simply do this if I could override a method in one of it's inner classes. My plan then was to extend the original class, and override the method in question. But here I am struggling.
The code below is representative of my situation.
public class ClassA
   ValueChecks vc = null;
   /** Creates a new instance of Main */
   public ClassA()
      System.out.println("ClassA Constructor");
      vc = new ValueChecks();
      vc.checkMaximum();
     // I want this to call the overridden method, but it does not, it seems to call
     // the method in this class. probably because vc belongs to this class
      this.vc.checkMinimum();
      this.myMethod();
   protected void myMethod()
      System.out.println("myMethod(SUPER)");
   protected class ValueChecks
      protected boolean checkMinimum()
         System.out.println("ValueChecks.checkMinimum (SUPER)");
         return true;
      protected boolean checkMaximum()
         return false;
}I have extended ClassA, call it ClassASub, and it is this Class which I instantiate. The constructor in ClassASub obviously calls the constructor in ClassA. I want to override the checkMinimum() method in ValueChecks, but the above code always calls the method in ClassA. The ClassASub code looks like this
public class ClassASub extends ClassA
   public ClassAInner cias;
   /** Creates a new instance of Main */
   public ClassASub()
      System.out.println("ClassASub Constructor");
   protected void myMethod()
      System.out.println("myMethod(SUB)");
   protected class ValueChecks extends ClassA.ValueChecks
      protected boolean checkMinimum()
         System.out.println("ValueChecks.checkMinimum (SUB)");
         return true;
}The method myMethod seems to be suitably overridden, but I cannot override the checkMinimum() method.
I think this is a stupid problem to do with how the ValueChecks class is instantiated. I think I need to create an instance of ValueChecks in ClassASub, and pass a reference to it into ClassA. But this will upset the way ClassA works. Could somebody enlighten me please.

vc = new ValueChecks();vc is a ValueChecks object. No matter whether you subclass ValueChecks or not, vc is always of this type, per this line of code.
// I want this to call the overridden method, but it does not, it seems to > call
// the method in this class. probably because vc belongs to this class
this.vc.checkMinimum();No, it's because again vc references a ValueChecks object, because it was created as such.
And when I say ValueChecks, I mean the original class, not the one you tried to create by the same name, attempting to override the original.

General class and setting properties vs specific inner class

This is a general question for discussion. I am curious to know how people differentiate between instantiating a standard class and making property adjustments within a method versus defining a new inner class with the property adjustments defined within.
For example, when laying out a screen do you:
- instantiate all the objects, set properties, and define the layout all within a method
- create an inner class that defines the details of the layout (may reference other inner classes if complex) that is then just instantiated within a method
- use some combination of the two depending on size and complexity.
- use some other strategy
Obviously, by breaking the work up into smaller classes you are simplifying the structure since each class is taking on less responsibility, as well as hiding the details of the implementaion from higher level classes. On the other hand, if you are just instantiating an object and making some SET calls is creating an inner class overkill.
Is there a general consensus for an approach? I am curious to hear the approach of others.

it's depends on your design..
usually, if the application is simple and is not expected to be maintain (update..etc..) than I just have all the building of the gui within the same class (usually..the main class that extends JFrame).
if the application follows the MVC pattern, than I would have a seperate class that build the GUI for a particular View. I would create another class to handle the ActionEvent, and other event (Controller)
I rarely use inner class...and only use them to implements the Listerner interface (but only for simple application)..

Inner Class Question

My question pertains to the code at the bottom of this post.
I don't understand why the compiler doesn't give an error for the line below. Why would it let you refer to something inside the class (in this case I'm referring to ClassWithInnerClass.MyInnerClass) unless it were static?
ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();To illustrate why I'm asking, I created 2 ints ("regularInt" and "staticInt") inside class "ClassWithInnerClass". The compiler let me set the value of "staticInt" from within main whereas it wouldn't let me do so w/ "regularInt" (which is why I commented that line out). Don't get me wrong though - I understand the reasons why the compiler behaves as it does for "regularInt" and "staticInt". I understand that a static variable can be accessed without instantiating a class (and that there's only 1 created no matter how many classes are instantiated). I also understand that, to access a non-static variable, you need to instantiate a class. My question arises only because of trying to extend that logic to MyInnerClass.
I can already take a guess that the answer is going to be something like, "the reason it works this way is because class 'MyInnerClass' is just a declaration NOT a definiton". I guess I just want confirmation of this and, if possible, some reasoning behind this logic.
HERE'S THE CODE...
class CreateInnerClasses {
     public static void main (String args[]) {
          ClassWithInnerClass cwic = new ClassWithInnerClass();
          ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();
          //ClassWithInnerClass.regularInt = 5;
          ClassWithInnerClass.staticInt = 10;
          mic.printIt();
class ClassWithInnerClass {
     public int regularInt ;
     static public int staticInt;
     class MyInnerClass {
          void printIt() {
               System.out.println("Inside ClassWithInnerClass.myInnerClass");
     MyInnerClass retMyInnerClass () {
          return new MyInnerClass();

The line    ClassWithInnerClass.MyInnerClass mic = cwic.retMyInnerClass();is accepted because the name of the inner class is ClassWithInnerClass.MyInnerClass. This has nothing to do with accessing fields even though the syntax is similar.
On the other hand, the line    SomeClassWithAnInnerClass.InnerClass ic = new SomeClassWithAnInnerClass.InnerClass();is not accepted because the nested class SomeClassWithAnInnerClass.InnerClass is not static: you must have an instance of the outer class available. The correct syntax for calling the constructor of the inner class would be    Outer.Inner instance = outerInstance.new Inner();In this case you could write:    ClassWithInnerClass.MyInnerClass mic = new SomeClassWithAnInnerClass() . new InnerClass();
    // OR:
    ClassWithInnerClass.MyInnerClass mic = cwic . new InnerClass();The Java tutorial has a pretty good explanation on nested classes:
http://java.sun.com/docs/books/tutorial/java/javaOO/nested.html
http://java.sun.com/docs/books/tutorial/java/javaOO/innerclasses.html

Inner Class extending the outer class

Could anyone explain this code to me? It can compile and run. Could anyone tell me what the class Main.Inner.Inner is? What members does it consists of? How the compiler manage to build such a class?
public class Main {
    public static class Inner extends Main {
    public static void main(String[] args) {
        System.out.println("Hello, world.");
}

By the way, it's not really an inner class, because it's static. It's just a nested class.
You might want to have a nested class extend its enclosing class if, maybe, you wanted to delegate to subclasses and didn't want to create a lot of extra source code files, which might make sense if the nested subclasses were really small.
public abstract class Animal {
public abstract void makeSound();
private Animal() {} // can't be directly instantiated
private static class Dog extends Animal {
    public void makeSound() { System.out.println("woof"); }
private static class Cat extends Animal {
    public void makeSound() { System.out.println("meow"); }
private static class Zebra extends Animal {
    public void makeSound() { System.out.println("i am a zebra"); }
public static Animal get(String desc) {
    if ("fetches sticks".equals(desc)) {
      return new Dog();
    if ("hunts mice".equals(desc)) {
      return new Cat();
    if ("stripey horse".equals(desc)) {
      return new Zebra();
    return null;
public class AnimalTest {
public static void main(String... argv) {
    Animal a = Animal.get("fetches sticks");
    a.makeSound();
}

Which one is better static inner classes or inheritance ?

Hi,
Consider following scenario,
Class A does some database related work and Class B,C,D has more specific tasks for specific databases. For now B,C,D has more static information like driver name etc.
1. I can either make class B,C,D as static inner classes OR
2. classes B,C,D can extend class A.
Case 1. makes it more flexible, if in future, B,C,D needs more than static methods.
Case 2. can avoid complexity and cost of instantiating differnt objects based on differnt scenarios.
Which approache is better in both ?
Thanks

Yes, I have seen abstract factory pattern , rather I have implemeted it at one place and in case 1. using abstract factory pattern is the way to initialize all classes.But my question is if I make all subclasses as a static inner classes, will it be better or efficient approach as compare to abstract factory pattern.Because Abstract factory patter adds more complications in code in turn it provides more flexibility.

Inner classes question

Hi guys,
I have a question to ask - when i'm writing an inner class and i want to create a new instance from it, the Eclipse forces me to use an instance of the containing class to call new.
Is it how it's done or am i doing something wrong?
public class A
    // Some code here
    public class B
         //Some code here
}Trying to create an instance:
A a = new A();
A.B b = a.new B();

What you have defined is "non-static" inner class.A "non-static" can only be instantiated only if we create an object of outer class.True.
>
There are two ways to create "inner" class object,
1)The way you have written the codeTrue.
2)
    public class A
{    // Some code here
public void createInner()
classB b=new ClassB();
public classB
//Some code here
That code won't compile. Even if you corrected it so that it did compile, it doesn't really help in the OP's situation. Did you read the advice of Saish and Jos about why class 'B' probably shouldn't be public, anyway?

Inner Classes doubts

Hi All,
I am trying to learn Inner classes in Java. I am referring to the book Core Java by Horstmann and Cornell.
I know that there are various types of inner classes namely:
- Nested Inner classes
- Local Inner classes
- Annonymous Inner classes
- static inner classes
First I am on with Nested Inner classes :
Following is the code which I am executing :
package com.example.innerclass;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.JOptionPane;
import javax.swing.Timer;
public class InnerClassTest {
      * @param args
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          TalkingClock clock = new TalkingClock(1000,true);
          clock.start();
//          JOptionPane.showMessageDialog(null,"Quit Program");
//          System.exit(0);
class TalkingClock
     private int interval;
     private boolean beep;
     public TalkingClock(int interval, boolean beep){
          this.interval = interval;
          this.beep = beep;
     public void start(){
          ActionListener listener = new TimePrinter();
          Timer t = new Timer(interval,listener);
          t.start();
     private class TimePrinter implements ActionListener{
          public void actionPerformed(ActionEvent event){
               Date now = new Date();
               System.out.println("At the tone time is : "+now);
               if(beep)
                    Toolkit.getDefaultToolkit().beep();
}Following are my doubts :
1. Why do we need to give the line
JOptionPane.showMessageDialog(null,"Quit Program");
System.exit(0);without this line the program doesn't show any output.
2. I didn't understand this syntax.
You can write inner object constructor more explicitly using the syntax. :
outerObject.new InnerClass(construction parameters)
For e.g.
ActionListener listener = this.new TimePrinter();
Here the outer class reference of the newly constructed TimePrinter object is set to this reference of the method that creates the inner class object. the this. qualifier is redundant. However, it is also possible to set the outer class reference to another object by explicilty naming it. For e.g if TimePrinter were a public inner class, you could construct a TimePrinter for any talking clock.
TalkingClock jabberer = new TalkingClock(1000,true);
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
Please do help me understand this concept.
Thanks
Siddharth

I have understood that this explanation :
i) assuming that TimePrinter is an inner class of TalkingClock, that you'd need an instance of the later in order to create an instance of the former.Yes.
Being a non-static inner class, it can not be instantiated out of context ... which context is the outer class.No. See my reply 11. The "context" is an instance of the outer class - it bears repeating.
ii) jabberer is the outer instance that you are providing.Yes (more accurately it's a reference to an instance of the outer class, but that would be nit-picking).
The left side is identifying the class, the right side is identifying the instanceNo.
I'm not sure what you're calling left side and right side.
If you're talking about both sides of the equals sign, then no, it's completely wrong.
If you're talking about both sides of the "point" sign, then it's wrong too, just a bit less wrong.
Let's revise this step by step (good thought process).
1. in first line we are getting an outer class reference with this code
TalkingClock jabberer = new TalkingClock(1000,true);
this line is very natural and easily understood. Yes. The correct wording would be merely "we are getting a reference to an instance of the outer class". Sorry to insist densely.
2. Now when we come to the second line, i.e. where we try to instantiate an inner class with this line of code
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
- I do understand the concept that we need an instance of outer class in order to create an instance of inner class as inner class is visible only to outer class.No. We need an instance of the outer class as the inner class is non-static, and by definition needs an instance of the outer class. That has nothing to do with visibility (public vs private vs...). Again, some words have special meanings in the Java world.
- I also do understand that it cant be instantiated out of context. I see you like this expression, but it is too vague and misleads you. Please forget about it for a moment (no offense to otherwise helpful and knowledgeable abillconsl).
- I also do understand that left side is identifying the class and right side is identifying the instance. ANDAgain I'm afraid of which "sides" you're talking about.
- that in this line TalkingClock.TimePrinter listener = new TalkingClock().new TimePrinter();
the outer class is anonymous (new TalkingClock()) as we don't require its name here Poor choice of words again. Anonymous classes do exist in Java, but are a totally different concept, that is not related to this line.
- Also in this line TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
I understood the left side part i.e. TalkingClock.TimePrinter listener =
We are attaching the outer class reference with the inner class that's absolutely understandable. Not at all!
This just declares a variable listener, whose type is TalkingClock.TimePrinter (or more accurately com.example.innerclass.TalkingClock.TimePrinter).
Then follows an assignment:
WHAT I don't understand is the right hand side, i.e., the statement jabberer.new TimePrinter();
1. I am unable to digest the fact that we can do something like anobject.new
new is an operator that is used to instantiate an instance of an object. I am unable to digest that we can do x.new?See my previous reply. This is short-hand syntax Sun chose to pass a reference to an instance of the outer class (here, jabberer) to the constructor of the inner class. They could have chosen something else. Again, bear with it.
I only know that we can do is new SomeClass(); AND NOT instance.new SomeClass();
Now you know better:
The second form is valid - only if SomeClass is a non-static inner class defined in a class of which instance is an instance.
2. Is there something to this conceptually OR this is only a syntax and that I should learn it.
I want to understand and grasp if there is some concept behind it rather than just learn and mug up. See my previous reply. Each instance of a non-static inner class stores a reference to an instance of the outer class. There must be a way (a syntax) to specify which instance (of the outer class) should be stored in the instance (of the inner class).
This particular syntax is just a syntax, the "concept" is that the instance of the inner class stores a (unmodifiable) reference to the instance of the outer class that was specified when the instance of the inner class was created.
I don't know if that deserves to be called a concept, but that's an interesting thing to keep in mind (there are some not-so-obvious implications in terms of, e.g. garbage collection).
Best regards.
J.

Why do we go for inner classes in java?

why cant we inherit the classes instead of having inner classes.
what is the exact difference between the inner class and subclass.
can anyone please explain me with some examples

An inner class doesn't have any relationship with the outer class per se,
except for one thing: an instantiation of the inner class can refer to the
members of the instantiation of the outer class. One instantiation of the
outer class can have many instantiations of the inner class 'circling
around' it. Try to implement the following example using inheritance:public class Star {
     private String name;
     public Star(String name) { this.name= name; }
     public Planet addPlanet(String name) { return new Planet(name); }
     public class Planet {
          private String name;
          private Planet(String name) { this.name= name; }
          public Moon addMoon(String name) { return new Moon(name); }
          public class Moon {
               private String name;
               private Moon(String name) { this.name= name; }
               public String toString() { return name+" (circling around "+Planet.this+")"; }
          public String toString() { return name+" (circling around "+Star.this+")"; }
     public String toString() { return name; }
     public static void main(String[] args) {
          System.out.println(new Star("sun").addPlanet("earth").addMoon("moon"));
}kind regards,
Jos

Mapping inner class in mapping workbench

A project needs to work with inner classes and map these inner classes using TopLink Mapping Workbench. Is this supported? Thanks.
Haiwie

Karen,
Thanks for your response.
I tried with 9.0.4.4, and it worked. I had to use 'Use Factory' option for Instantiation; the mapping workbench complains about the default instantiation setting, i.e. 'Use Default Constructor'.
Haiwei

Subclassing inner class

I have a class with some private fields that I want to access from several other classes, all of which will inherit from one class.
I could provide public accessor methods but I don't feel it is appropriate in this situation so I thought of creating an inner class with protected accessor methods to the private fields.
I would like to subclass this inner class from outside the enclosing class, thus giving access to the private fields without altering the public interface of the enclosing class.
I have written a small sample program to test this idea.
public class A{
private String hello = "Hello";
public A(){}
public class B{
    public B(){}
    protected String getString(){
      return hello;
public class C extends A.B{
public static void main(String[] args){
    A a = new A();
    A.B c = new C();
public C(){
    System.out.println(getString());
}However, compiling this gives the error "No enclosing instance of A is in scope" at the constrctor for C.
Am I trying to do something impossible or stupid, or is there a simple solution?
Thanks,
Tristan.

You need a reference to an instance of class A inside B or C. When you declare an inner class as you did, you can access this reference by A.this, but in this case B cannot be instantiated outside an instance of A.
You want to refer a class A.B without an instance to A. You can do that by declaring B as static. But in this case you don't have access to non-static members of A. So, you still need a reference to A.
Here is a possible solution :
class A {
    private String hello = "Hello";
    public A() {}
    static public class B {
     protected A a;
     public B(A a){ this.a = a;}
     protected String getString() {
         return a.hello;
public class C extends A.B {
    public static void main(String[] args){
     A a = new A();
     A.B c = new C(a);
    public C(A a) {
     super(a);
     System.out.println(getString());
}It is working.
Anyway the entire story seems too complicated for me :-) Redesigning is not allways a bad idea ...
Regards,
Iulian

I don't understand the design of inner class private member

This is a question about the java language specification of inner classes.
In the java langage specification document, we read
If the member or constructor is declared private,
then access is permitted if and only if it occurs
within the body of the top level class (�7.6)
that encloses the declaration of the member.
This allows following code :
public class PrivateTest {
    public PrivateTest()
      Hello hello = new Hello();
      System.out.println(hello.secret);
    class Hello
       private String secret = "This is a secret";
} wherein accessing the private secret field is allowed
from into the PrivateTest enclosing class.
My questions are :
a) It seems that private methods or constructors of
inner classes have no meaning, we could also declare
them as public. True or false ?
b) Is there any reason that Java bypass this private
mechanism ?
c) Why is the above definition not written with
"first enclosing" instead of "top level" ?
Thanks in advance

Private methods and constructors of an inner class can only be accessed within the outer class. Other classes can't instantiate it or use the private methods.
You can also make your inner class private, so it is not possible to refer to the class from outside (and thereby another way of preventing it from being instantiated).
So it does matter which access modifiers you use.
I think top level is more precise than first enclosing, because you can have inner classes in inner classes, which are still available for the top level class (haven't tested this).

From sunś Inner Class Exampel

Hi Have a questions about the exampel
[http://java.sun.com/docs/books/tutorial/java/javaOO/innerclasses.html]
public void printEven() {
        //print out values of even indices of the array
        InnerEvenIterator iterator = this.new InnerEvenIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.getNext() + " ");
    }The keword "this" is still a problem for me. I start to belive im stupid or something.
Can you please explain what it does here? why not just write
InnerEvenIterator iterator = new InnerEvenIterator();Regards / Magnus

In the context of the example, this. is optional, but the authors were trying to emphasize that it's not simply a matter of creating an instance of any old class, so they explicitly used the this reference. The class reference is not always optional. If the printEven() method were defined as static, there would already have to be an instance of DataStructure such as ds created before the inner class could be instantiated:DataStructure ds = new DataStructure();
InnerEvenIterator iterator = ds.new InnerEvenIterator();

Inner class instantiation

Similar Messages

Maybe you are looking for