Can enclosing instance for an inner class be null?

I have a class Solution, which defines an inner class, SolutionStep.
In a third class I construct several SolutionStep objects, and later use them to construct a Solution.
In this third class I have statements like this:
Solution solution = null;
aCollection.add(solution.new SolutionStep(arg1, arg2);
This has been working fine, but recently a customer reported an error,which seems to be a NullPointerException at the line above.
Now that I look at this code, I'm not very happy about it and I'll clean it up, but I am left with the basic question of whether what I'm doing is legal. Can the enclosing instance used to construct an inner class be null? I have not been able to find a definitive answer.
Any help appreciated.

Yes, you're right, I dropped a parenthesis. Sorry.
The offending statement is actually
aCollection.add(solution.new SolutionStep(arg1,
arg2));
And that is certainly legal. The inner class does not
need to be qualified when it's constructed in the
context of an enclosing instance.Very interesting.
The following code demonstrates this....
    class Solution
        class SolutionStep
            public SolutionStep()
    public class ThirdClass
        static public void main(String[] args)
        Solution solution = null;
        //Solution solution = new Solution(); // This produces no null exception.
        Solution.SolutionStep s = solution.new SolutionStep();
Using jikes and javac doesn't change the behavior so that means it is VM rather than compiler specific.
I am using 1.4.2_04 on windows and I get the null pointer exception.
Looking at the javap output suggests that invokespecial has to be checking this (although I could have overlooked something when I checked.)
This probably comes from the following in the VM spec under invokespecial...
Otherwise, if objectref is null, the invokespecial instruction throws a NullPointerException.

Similar Messages

Enclosing Instances When Subclassing Inner Classes

Hi,
I need to subclass an inner class but when I write code for its constructor I get the error "an enclosing instance that contains at.MainHandler.innerClass is required".
at.MainHandler is my outer class and my new class looks something like this:
public class newClass extends at.MainHandler.innerClass {
     //Constructor
     public newClass (int a, int b) {
         super( a );
    }//Constructor
}//ClassI understand that the inner class to which 'super' refers must somehow be bound to its outer class(at.MainHandler) if I want newClass to access the outer class methods, but what is the correct syntax needed to achieve this?
I've looked at other posts on similar topics but am still unable to grasp precisely what is needed.
Sid

These are some working examples:
class A {
     class InA {}
class B extends A {
     class InB extends InA {}
class A {
     static class InA {}
class InB extends A.InA {}
class A {
     class InA {}
class InB extends A.InA {
     InB(A a) {
          a.super();
}

Why only final variables can be accessed in an inner class ?

Variables declared in a method need to declared as final if they are to be accessed in an inner class which resides in that method. My question is...
1. Why should i declare them as final ? What's the reason?
2. If i declare them as final, could they be modified in inner class ? since final variables should not modify their value.

(Got an error posting this, so I hope we don't end up with two...)
But what if i want to change the final local variable within that method instead of within anonymous class.You can't. You can't change the value of a final variable.
Should i use same thing like having another local variable as part of method and initializing it with the final local variable?You could do. But as in the first example I posted you are changing the value of the nonfinal variable not the final one. Because final variables can't be changed.
If so, don't you think it is redundant to have so many local variables for so many final local variables just to change them within that method?If you are worried that a variable might be redundant, don't create it. If you must create it to meet some need then it's not redundant.
Or is there any alternate way?Any alternate way to do what?

Local variable can't be accessed from inner class ???????? Why ??????

Plesae help, help, help. I have no idea what to do with this bug.........
<code>
for ( int i = 0; i <= 2; i++ ) {
for ( int j = 0; j <= 2; j++ ) {
grids[i][j] = new MyButton ();
grids[i][j].setBorder(but);
getContentPane().add(grids[i][j]);
MyButton sub = grids[i][j];
sub.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if ( sub.getState() == 0 ) {
     sub = new MyButton( (Icon) new ImageIcon(imageFile));
     if ( imageFile.equals("cross.jpg") ) {
          sub.changeState(1);
     else {
          sub.changeState(2);
</code>
The compiler complains that "sub" is in the inner class, which is the ActionListener class, must be declared final. Please tell me what to do with it. I want to add an ActionListener to each MyButton Object in the array. Thanks ......

OK, now I changed my code to this :
for ( int i = 0; i <= 2; i++ ) {
for ( int j = 0; j <= 2; j++ ) {
    grids[i][j] = new MyButton ();
    grids[i][j].setBorder(but);
    getContentPane().add(grids[i][j]);
    grids[i][j].addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
        if ( grids[i][j].getState() == 0 ) {
           grids[i][j] = new MyButton( (Icon) new ImageIcon(imageFile));
          if ( imageFile.equals("cross.jpg") ) {
           grids[i][j].changeState(1);
          else {
          grids[i][j].changeState(2);
[/cpde]
Thanks for your advice !!!!!!
Now the compiler says that i and j are local variables accessed from inner classes, needs to be declared final. How can I solve this then ???

Exception handling for eventlistener inner classes in swing application

Hi,
This is probably sooo easy I will kick myself when I find out, but anyway here goes...
I have an inner class thus...
          cmbOffence.addFocusListener(new FocusAdapter() {
                    public void focusGained(FocusEvent e) {
                         cmbOffence_focusGained(e);
                    public void focusLost(FocusEvent e) {
                    try {
                         cmbOffence_focusLost(e);
                    } catch (XMLConfigurationException xce) {
               });where cmbOffence.focusLost(e) is looking up to a class that throws an exception which should be fatal i.e. the swing app should close. I want to handle this exception gracefully so therefore want to throw the XMLConfiguratinException to the main application class. How do I do this?? I guess this is more of an inner classes question than a swing one per se, but any help would be appreciated.
Thanks
Conrad

I think you're maybe confusing classes and threads. In the typical Swing application the "main" thread finishes after openning the initial window and there really is no main thread to report back to. In fact the dispatcher thread is about as "main" as they come.
To exit such a program gracefully is usually a matter of cleaning up resources and calling dispose on the main window, which you can perfectly well do from the dispatcher thread.
I usually wind up with some centralised method to deal with unexpected exceptions, for example as part of my desk top window in an MDI, but it's called from the dispatcher thread as often as from anywhere.

JButton in inner class cuasing Null Pointer Excp

Ok so i have this class called "square" and in it there is a JButton. There is a method called createButton() and getButton().
In create button it takes the classes JButton called button and instantiates:
public void createButton() {
button = new JButton("");
and
public JButton getButton() {
return button;
Now I make a frame and a panel in a upper class called "program" and i make a multidimensional array of squares. Then i make call createButton() for each square.
Then later on I call
panel.add(square[z][q].getButton());
Now all of this compiles fine but when i run it i get a null pointer exception on the line above. Why????
Thanks,
PS: 5 duke dollars for person who helps me.

What I think is happening is you are doing something like this (Where 'Square' is the name of the class that creates the button):
Square square[8][8] = new Square[8][8];
The problem is that this does not create the actual square objects. It simply creates an array that can hold the square objects but all the objects in the array are null. You should just initialized the objects by using two for loops:
Square square[8][8] = new Square[8][8];
for(int x = 0; x = square.length; x++)
for(int y = 0; y = square[x].length; y++)
square[x][y] = new Square(---);
That will put things into the array and they won't be null.

Reason for not allowing static declarations inside an inner class

Is the reason for not allowing static declarations inside an inner class is due to the fact that it can never be accessed at a class level as the outer class has to create an instance of the inner class and any attributes/methods of the inner class has to be accessed through that.
Typically, an instance (non-static) variable can never be accessed in a statement or expression inside a static context but the class variable can be accessed inside a non-static context. Given this, shouldnt the static declarations be allowed inside an inner class?
Correct me if my understanding is wrong.
Thanks

I still couldnt get it clearly. Why i cant i have a static value ( variable ) for all the instances of the inner class irrespective of its enclosing instances of it ( i.e outer class instances). Say in this example below,
class Outer
static int i = 0;
public Inner inner = new Inner();
class Inner // inner class ( non-static nested class )
int j = 0;
static final int k = 2; // compile time constants are allowed
// ininner class
public void m1()
j++;
System.out.println("j is " + j);
i++
System.out.println("i is " + i);
public static void main(String[] arg)
Outer outer1 = new Outer();
outer1.inner.m1(); // j will be 1 & i will be 1
Outer outer2 = new Outer();
outer2.inner.m1() // j will be 1 again & i will be 2. But I would
// want j to be 2. Why is this not allowed?
Looks like something missing..

Why can't inner classes have static methods?

I just tried to add a static method to an inner class, which would have been useful for extracting constants about said inner class, and it turns out that is not allowed.
Of course I have other ways to code what I wanted, but I'm curious as to why this restriction was set in place. Anybody know?

Probably because an inner class is tied to an instance of the enclosing class. I think that, conceptually at least, the inner class' definition itself only exists in the context of an instance of the enclosing class. While I'm sure it would have been technically possible to allow it, it would be confusing and not make a whole lot of sense--what is the static context for the inner class, since the class only exists in a non-static context?

Java Decompiler for Inner classes

Hi,
I am looking for a Java Decompiler that can handle the decompiling of inner classes fairly well. Any help will be appreciated. Thanks.

dj decomplier is probably the best one. u can look for it on google.

Your Opinions: Inner Classes Need static Members

Hi All,
I want to solicit opinions for a minor change to the way inner classes work. I submitted this as an RFE to Sun and they rejected it, really without giving a reason. I'd like to know your opinions. If there is strong support I will repost the RFE.
As you probably know, inner classes cannot have static members. The following generates a compiler error:import java.util.*;
public class MyClass {
   class MyInnerClass {
      // Next line causes compiler error...
      static Map m = new HashMap();
}In order to get around this you have to make the Map variable a static member of the containing class:import java.util.*;
public class MyClass {
   static Map m = new HashMap(); // so much for encapsulation...
   class MyInnerClass {
}I am suggesting that inner class be allowed to contain static members. Here's my reasoning...please comment:
There are times when members (i.e., fields and methods) rightfully belong to the class as a whole, not to any particular instance of a class. I'm sure we've all found times when it was necessary to have static members in our classes. The same issues that necessitated using static members in top-level classes make them desirable for inner classes as well.
Designing a class as an inner class is a step toward encapsulation. By forcing static members that logically belong in an inner class to be declared in the containing class is to crack the encapsulation, IMHO.
Even though a containing class has access to all of an inner class' members (including private members) and vice versa, I think the notion of inner static members still is more OO-ish.
What are your opinions? Would allowing inner classes to contain static members make Java more object oriented? I think it would.
Technically, I don't think there's any reason this cannot work since the JVM has no notion of inner classes, per se.
What do you think?

an inner class is effectively a non static instance
variable of its enclosing class. Instance member, but not a variable. it's a class, a type, not a variable.
>
I think the problem here is that making a field static
means more than just that that field and its value are
common to every instance of the class. It means that
the value is valid without an instantiation of that
class.
Since the class itself must be instantiated (it is
not static), What do you mean, excatly, by "_must_ be instantiated"? You are not ever "required" to instantiate anything unless you want to use it.
you can't have static member data inside it. I don't see how this follows from the previous part of the statement.
How would you reference the static member data of
the inner class? You would have to specify an
instance of the inner class, and since this breaks
the meaning of static, you can't have static members
in an inner class.How about outerObj.InnerClass.staticMember The syntax is well defined. The question at hand is, do we really want to allow this? The syntax to do this should only be an issue after that question has been answered in the affirmative. The people at Sun have decided not to allow it, so for now, syntax is a non-issue.
>
if you wanted a static member in an inner class you
could put it in a super class of the inner class...Or in the enclosing class, as suggested in the orginal post.

Enclosing instance references....

Ok, I turned to the holy scripture (JLS), and have turned away baffled.....
Im confused on an Inner class issue.
If inner classes are to reference fields of their inclosing instance, they have to be able to reference it some way.
Im assuming that this is implemented as a field of the inner class (is that a correct assumption?) synthesised at compile time.
Now, what I want to know is when does this reference (if it exists) become 'valid' when the inner class is a derived class?
Intuition tells me that it would be null until after the base class constructor had completed. However, in practise this is not always the case....
Heres an example:
We have some class:
class Something {
public Something() {
    // NOTE: Call non-final method from constructor!!!
    createSomething();
public Object createSomething() {
    return new Whatever();
}We then have a class which creates an annonymous inner class which overides the 'createSomething' method:
class UserClass {
public void example() {
    final Object toReturn = new Object();
    Something mySomething = new Something() {
      public Object createSomething() {
        // THE ALL IMPORTANT LINE:
        System.out.println("Ref: " + UserClass.this);
        return toReturn;
}Now, when the mySomething is constructed, the 'createSomething' method is called from the base constructor. At this point, I would expect (incorrectly?) that the enclosing reference (UserClass.this) would be null.
However, on two compilers, I get two different results. Null on one, non-null on the other.
Can anyone please explain to me the way this should work - or is it undefined?

What Im confused about is this:
The instance of the annonymous inner class has to be able to reference its enclosing instance somehow (I.e, UserClass.this).
So, Im guessing (perhaps incorrectly...) that the instance of the annonymous inner class will have a field that is a reference to the enclosing class.
Im fully aware that the enclosing class can never really be null... However, constructors are called bottom up, and a non-final method is called from the base class constructor.
This is then overidden in the inner class to print out the reference to the enclosing class (UserClass.this).
My confusion is about when it becomes 'valid' for the inner class to reference its enclosing class (using UserClass.this) - and my intuition says not before the base constructors have been called (I.e, I would expect it to be null in my example).
Why do I think that?
Well, if we have this:
class MyBaseClass {
public MyBaseClass() {
    dodgyMethod();
public void dodgyMethod() {
    System.out.println("HELLO");
class MyDerivedClass extends MyBaseClass {
Integer someInteger = new Integer(4);
public void dodgyMethod() {
    // Will be NULL when called from base constructor
    System.out.println("val: " + someInteger);
}We see that if a new 'MyDerivedClass' is created, then someInteger is null (because someInteger hasn't been initialised yet, coz we are still in the base class constructor).
My question is just an extension of the above.....
If the enclosing instance reference is implemented as a normal ref in the anonymous inner class, I would not expect it to get initialised until the base class constructor had completed (in the same way that I wouldn't expect someInteger to be initialise until its base constructor had completed).
So its all about calling non-final methods from a base class, where the derrived class is an inner class, and whether or not the enclosing reference should be non-null at that point in time.

Enclosing instance

I've never seen this error before. I was trying to create a instance of an inner-class. The code is declared like this:
static ShuttleController shuttleControl;Then it is created in the main Method like this:
shuttleControl = new ShuttleController();I'm using eclipse to program this code and it gave me this error:
No enclosing instance of type SpacePanel is accessible. Must qualify the allocation with an enclosing instance of type SpacePanel (e.g. x.new A() where x is an instance of SpacePanel).This is the code for the class ShuttleControlle:
class ShuttleController implements Runnable
          public ShuttleController()
          public void run()
               shuttle.update(WIDTH/2, HEIGHT/2, rotation);
               xPos += xMom;
               yPos += yMom;
     }This class is an inner-class in the class SpacePanel

Objects of an "inner class" can access the instance of the enclosing class and its fields; therefore, they must have an implicit reference to the enclosing object, and cannot be instantiated in static context.
Maybe you are looking for a "nested class" instead, which does not have a reference to the enclosing object. To do that, you add the "static" keyword:
static class ShuttleController implements RunnableEdited by: spoon_ on Dec 15, 2007 10:21 PM

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?

Threaded inner classes & heap memory exhaustion

(_) how can i maximize my threading without running out of
heap memory?
push it to the limit, but throttle back before an
java.lang.OutOfMemoryError.
(_) within 1 threaded class ThreadClass, i have two threaded inner classes. for each instance of ThreadClass i only
start one instance of each inner class.
and, i start hundreds of ThreadClass, but not until the previously running ThreadClass object exits, so only one should be running at any given time.
so, what about threaded inner classes?
are they good? bad? cause "OutOfMemoryErrors"?
are those inner threads not dying?
what are common causes of:
java.lang.OutOfMemoryError: java heap space?
my program runs for about 5-minutes, then
bails with the memory error.
how can i drill down and see what
is eating-up all my memory?
thanks.

A Thread class is not the same as a thread of
execution. Those inner class based threads of
execution are not dying.maybe. but this is the way i test a thread's life:
public void run() {
System.out.println("thread start");
System.out.println("thread dies and release memory");
}for each inner thread, and the outer thread, this approach for
testing thread life reveals that they die.
Why don't you use a thread pool?ok. i will think about how to do this.
>
If not, you need to ensure those inner threads have
exited and completed.what is a 100% sure check to guarantee a thread exits other than
the one i use above?
note:
the outer thread is running on a remote host, and the inner threads
are running locally. here are the details:
public class BB implements Runnable, FinInterface {
public void run() {
    // do some work on the remote machine
private void startResultsHandler(OisXoos oisX) {
     ResultHandler rh = new ResultHandler(oisX);
     rh.start();
public void startDataProxy(OisXoos oisX, String query) {
     DataProxy dp = new DataProxy(oisX, query);
     dp.start();
        public class ResultsHandler extends Thread {
           // runs locally; waits for results from servers
           public void run() {
               ObjectInputStream ois = new ObjectInputStream(oisX.input);
                Set result = (Set) ois.readObject();
        } // ____ class :: _ ResultsHandler _ :: class ____
       public class DataProxy extends Thread {
           // runs locally; performs db queries on behalf of servers
           public void run() {
               ObjectOutputStream oos = new ObjectOutputStream(oisX.output);
                while(moreData) {
                    .... // sql queries
                    oos.writeObject(data);
             StartResultsHandler(oisX);
        } // _____ class :: _ DataProxy _ :: class _____
}now, the BB class is not started locally.
the inner threads are started locally to both service data requests
by the BB thread as well as wait for its results.
(_) so, maybe the inner threads cannot exit (but they sure look
like they exit) until their parent BB thread exits.
(_) yet, those inner threads have no knowledge that the BB
thread is running.
externalizing those inner thread classes will put 2-weeks of work
in the dust bin. i want to keep them internal.
thanks.
here this piece of code that controls everything:
while(moreData) {
FinObjects finObj = new BB();
String symb = (String) data_ois.readObject();
OisXoos oisX = RSAdmin.getServer();
oisX.xoos.writeObject(finObj);
finObj.startDataProxy(finObj, oisX, symb);
}

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.

Can enclosing instance for an inner class be null?

Similar Messages

Maybe you are looking for