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.

Similar Messages

Private inner class and static private inner

Hi,
I understand the concept and usage of inner classes in general.
When should we go for a private inner class and when for a static private inner class? I tried searching but it wasn't of much help.
Basically I need to design a caching solution in which I need to timestamp the data object. After timestamping, data will be stored in a HashMap or some other collection. I'm planning to use a wrapper class (which is inner and private) which holds the data object and timestamp. I can make the program work by using either normal inner class or static inner class, however would like to know which is better in such case. Also If I can get some general guidelines as to when to use a staic inner class and when to use a normal inner class, it would help me.
Thanks in advance.

user1995721 wrote:
When should we go for a private inner class and when for a static private inner class?
I can make the program work by using either normal inner class or static inner class, however would like to know which is better
If I can get some general guidelines as to when to use a static inner class and when to use a normal inner class, it would help me.Making the inner class static is helpful in that it limits visibility.
If the inner class needs to access non-static fields or methods from the containing class instance
the inner class has to be non-static.

Factory class and static members

I don't understand very well why sometimes you can find a factory class (for example for the xml parsers). What's its aim?
And why sometuimes, instead of a constructor, some classes have only static methods that returns a reference to that object?
Anyone can tell me?
Thanks

Static memebers can be used in places where instances of its enclosing class is not neccesary.Only a method is required to be executed. Let me tell you with an example,
class ConnectionPool {
public static giveConnection(int index) {
In the above example, our objective is to use only the method public static giveConnection(int index) {} , and not any of the other attributes of this class. You have 2 ways to use this method : One is, you can instantiate ConnectionPool p = new ConnectionPool(); . Second is , just use ConnectionPool.giveConnection(2);
The first solution may create instance and obstruct your performance. Seond one does not do that. All invokers of this method do not instantiate and occupy space.
Usually, factory classes have static members. Because these classes are used as a supporting processing factory. Theses members can be considered as utility methods. Hence static property will better suit for them. This answer will also tell you that the use of constructors here is not neccessary.
Hope this has helped you.
Rajesh

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?

Assign value in a inner class

Suppose, we have the following two classes.
public class test{
final trythis t;
t = null;
doMethod(t); // because of this, t has to be assigned a null value
(new Thread(){public void run(){
t = new trythis(); // t is assigned twice
}}).start();
class trythis{
trythis(){
t seems to have to be defined as final, but final instance cannot be set in the inner class.
Does anyone know how to solve this problem?
Thanks

As the local variable has a lifetime of the executing method's
duration, you must ensure the innerclass (which has a longer lifetime)
has access to it by declaring it final.This is not quite exact. All this is due to the way inner classes are implemented. An inner class maintains the contents of the outer local variables used in two ways:
- If it is primitive, use the value verbatim (so the class has no relationship to the outer variable, it just uses the same number, so the local var needs to be final or else there could be surprises for a programmer who would think that changing the local var would also change the value used in the inner class)
- If it is a reference, copy it as a class member, and use that one wherever needed. For similar reasons as above, the two references have to be in sync, so the local var has to be final (the inner var can't change anyway)
This apply only to local variables because class members are accessible through a secret reference of the enclosing object passed in the constructor of the inner class. Static members are anyway accessible.
<teacher's mode off/>
<sorry for that, but someone might find the explanation useful :-)/>
By the way, the OP can get the value "t" out of the inner class by providing a special Thread subclass, ie
class MyThread extends Thread {
public void run() {
t = something;
trythis t;
MyThread thread = new MyThread();
thread.start();
thread.join();
thread.t; //This is accessibleI'm not sure if this would be preferable to the array approach (which is ), but it is useful to know your alternatives

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..

HELP: Inner Class vs. Private Member

I use "javadoc -private" to create documents with inner classes. As a result, all private fields and methods, which I don't need, show up in the same document. Is there any way I can have inner classes without private members?

how do you declare your inner class?
Is it (public)
public static class MyInnerClassor (private)
private static class MyInnerClassor (package)
static class MyInnerClassor (protected)
protected static class MyInnerClassTry to change the way you declare the inner class. Use protected or package or public instead.

Extending a member inner class

I have a class
public class A{
class InnerClassB{
Now the question is how to extend the inner class would it be
class ExtendingInnerClassB extends A.B{
or else?
I am not sure anybody knows?

Regarding inheritance from inner classes you must define your constructor:
public ExtendedInnerClass(EnclosingClass EC) { EC.super(); }
why?????
well
1. Where is the handle? The handle is an internal thing which is designed to accept the enclosing class. It is something which is not in the programmer's control. when there is an inner class, it is natural that the inner class cannot exist without its outer class. And that is the reason why the instantiation of an inner class is done using new OuterClass().new Innerclass(). U can see that the innerClass object is created based on the outer class object (assuming that the inner Class is not static). I hope that this is clear. Now .. the whole point is how does the compiler know that the Outerclass is the enclosing class? When the above line is compiled, the tricky handle in the inner class is assigned to the Outer class. So any reference henceforth is made based on this handle.
2. In the Inherited Inner class, there is no way to assoicate the handle in the above manner. Hence we are forcing by calling the super().
3 Otherwise why not simply create with: new InheritedInnerClass(EnclosingClass)? This is not possible. What if the inherited inner class needs a constructor in the above manner. That is assume that there is a class A. Then if the Inner Class needs the constructor to be InnerClass(A a, EnclosingClass b) for some other purpose, then what judgement can the compiler take? So that answers the question <b>Can't the compiler compile the inherited inner class assuming a handle to the enclosing class and then force an instance to be created using the EnclosingClass.new syntax?</b> Becuase in this case it cant go by any assumption.
4. Maybe the compiler designers can make some change such that the inherited inner class should have all its constructors beginning with the enclosing object and there should be atleast one constructor. But somehow I feel that it is too much of asking.

Trying to use super class's methods from an anonymous inner class

Hi all,
I have one class with some methods, and a second class which inherits from the first. The second class contains a method which starts up a thread, which is an anonymous inner class. Inside this inner class, I want to call a method from my first class. How can I do this?
If I just call the method, it will use the second class's version of the method. However, if I use "super," it will try to find that method in the Thread class (it's own super class) and complain.
Any suggestions?
Code:
public class TopClass
     public void doSomething(){
          // do something
=============================
public class LowerClass extends TopClass
     // overrides TopClass's doSomething.
     public void doSomething(){
          // do something
     public void testThread(){
          Thread t = new Thread(){
               public void run(){
                    doSomething();               //fine
                    super.doSomething();          //WRONG: searches class Thread for doSomething...
          t.start();
}

Classes frequently call the un-overridden versions of methods from their superclasses. That's that the super keyword is for, if I'm not mistaken.You're not mistaken about the keyword, but you're not calling the superclass method from a subclass. Your anonymous inner class is not a subtype of TopLevel. It's a subtype of Thread.
Here it is no different, except that I happen to be in a thread at the time.It's vastly different, since you're attempting to call the method from an unrelated class; i.e., Thread.
I could also be in a button's action listener, for example. It seems natural to me that if I can do it in a method, I should be able to do it within an anonymous inner class which is inside a method.If you were in an button's action listener and needed to call a superclass' implementation of a method overridden in the button, I'd have the same questions about your design. It seems smelly to me.
~

Don't understand Inner Classes and how to use it

Hi
As you guess i 'am a newbie!
I don't understand Inner Classes, particulary members(methods & fields) that an Inner method is able to manipulate.
So I know that the methods of an Inner class (respectively Outer Class) instance can access members (private or public) of an instance of the Outer Class (respectively Inner Class).
I tried to answer to a quizz : http://java.sun.com/developer/onlineTraining/new2java/supplements/quizzes/January03.html
In the following class definition, which variables are inaccessible within the method of the inner class?
class Test1 {
   public static int a = 1;
   private static int b = 2;
   public int c = 3;
   private int d = 4;
   public static class Inner {
     int e = 5;
     public void aMethod(int f) {
       int g = 6;
       // What can't be accessed here?
}A.      b, c, d
B.      c, d
C.      b, c, d, f
D.      None of them
In my opinion members (public or private) of the Outer Class can be accessed by methods of the Inner Class; e.g: a, b, c,d thus for me the answer is D.
Obviously i'm wrong, but why?

Hi
As you guess i 'am a newbie!
I don't understand Inner Classes, particulary
members(methods & fields) that an Inner method is
able to manipulate.
So I know that the methods of an Inner class
(respectively Outer Class) instance can access
members (private or public) of an instance of the
Outer Class (respectively Inner Class).
I tried to answer to a quizz :
http://java.sun.com/developer/onlineTraining/new2java/
supplements/quizzes/January03.html
In the following class definition, which variables
are inaccessible within the method of the inner
class?
class Test1 {
public static int a = 1;
private static int b = 2;
public int c = 3;
private int d = 4;
public static class Inner {
int e = 5;
public void aMethod(int f) {
int g = 6;
// What can't be accessed here?
}A.      b, c, d
B.      c, d
C.      b, c, d, f
D.      None of them
In my opinion members (public or private) of the
Outer Class can be accessed by methods of the Inner
Class; e.g: a, b, c,d thus for me the answer is
D.
Obviously i'm wrong, but why?Inner class method can access all the private members of the class. But the inner class is static. So the non-static members cannot be accessed directly (i.e. c and d).
***Annie***

Final in inner class

I am trying to manually make a drawing program similar to this one
http://javafx.com/samples/Draw/
However I am running into issues involving inner classes and finals.
"local variable size is accessed from within inner class; needs to be declared final"
It wants me to make either SIZE or size a final. However once final, I can't change the variable.
I have often used the variable in a for loop to assign a value(though maybe it was a bad practice?) however I am not sure the best way to handle this.
Any suggestions?
Thanks!
int SIZE = 1; //somewhere else
        for( int size = 0 ; size < 5 ; size++){
              Circle circle = new Circle(D/Padding);
              circle.setOnMousePressed(new EventHandler<MouseEvent>(){
                  public void handle(MouseEvent me){
                      SIZE = size;
         );edit:
I am well aware this isnt neccesarily a javafx specific thing, but more of a general java poor programming knowledge.
I also know that the mouseadapter is an anonymous class and can only access final.
I am just looking for any suggestions on how to best handle this.
Edited by: namrog on Jul 5, 2011 10:51 AM
Edited by: namrog on Jul 5, 2011 10:59 AM

namrog wrote:
I am trying to manually make a drawing program similar to this one
http://javafx.com/samples/Draw/
However I am running into issues involving inner classes and finals.
"local variable size is accessed from within inner class; needs to be declared final"
It wants me to make either SIZE or size a final. However once final, I can't change the variable.Yes, that's the point. If a local variable is to be used by an instance of a nested class, that nested instance can live on long after the local variable goes out of scope. So it needs its own, separate copy of the variable. However, since, as far as we are concerned, there is only one variable, that variable needs to be final, so that there will not be issues with keeping the two copies' values coherent.
I have often used the variable in a for loop to assign a value(though maybe it was a bad practice?) however I am not sure the best way to handle this.
Any suggestions?Create a final variable and copy the value of your non-final variable to it.
int nonFinal =...;
final int theFinalCopy = nonFinal;
new Whatever() {
    void doStuff() {
      doSomething(theFinalCopy);
}

SerialVersionUID and inner classes

Hello All
A quick question about serialVersionUID in inner classes.
If an inner class can't have any static members, how come it's legal to define
static final long serialVersionUID = 123L;
in an inner class ? Is there something special about serialization that allows this ?

there is nothing special about the serialVersionUID defintion -
you can define static datamember of inner class as long as it is final or the inner class is static :
public class Out {
public Out() {
private class In {
static final int i1 = 1; //legal
static int i2 = 2; //** illegal
private static class InStatic{
static final int i1 = 1; //legal
static int i2 = 2; //legal
}

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 ???

Using Reflection can we find out details of inner classes in a class

Hello All,
Thanx in advance.
I intend to figure out the name of the inner class and methods declared inside it. How can this be done using reflection API's.
I need the above information to make an automated java doc creation tool for the project I am working in.
Thanx again...
VIkas

Thanx silkm,
Actually suggestion # 1 I have already tried. I used
getClasses() method which returned me a Class[] of
length = 0. i dunno Why?Because you are not using the reflection API correctly. If you read the javadocs you would know that it is structured so that all getXXX() methods return all XXX things that are public and are either declared by the target class or possibly inherited from superclasses.
As contrasted to that, getDeclaredXXX() methods can return all XXX things (including private) but only declared by the target class (not inherited).
You got an empty result back in your case most likely because all your nested/inner classes were non-public. Use getDeclaredClasses() instead.
As to suggestion # 2, the exercise I am doing is a
step before using the java doc tool. One has to insert
a javadoc comment before the method begins in order to
create a java doc. So thats it.This is independent of the reflection API but you might consider using the doclet API for this.

Singleton with static members only

If I have a singleton class with static members only and I'd like to ensure that nobody accidentally instantiates the class, would it make sense to declare the class abstract? Or instead should I leave it non-abstract but make the no-argument constructor private? Or both?
Which of these approaches would you recommend?
Thanks.

pros of using classical singletons (per Head First
Design Patterns):
1) It ensures that one and only one object is
instantiated for a given class.This is effectively the same as using a non-instantiable class with all static members. You don't have an instance, but you have exactly one of it.
2) It gives a global point of access like a global
variableAgain, same thing with a non-instantiable class with all static members.
3) It is only created when you need it (unlike a
global variable) and thus wastes no resources if it
is not needed.Again, same thing.
Also, Java does not have global variables.
Also, no variable in Java requires more than 8 bytes, and most are 4 or 2.
4) Using a static self-contained class in place of a
singleton can be a source of subtle, hard-to-find
bugs often involving order of initialization of
static code.Eh? Example please?
5) Global variables encourage developers to pollute
the namespace with lots of global references to small
objects.What global variable? Java doesn't have global variables? How is a class full of statics any more a global than a "real" singleton?

Your Opinions: Inner Classes Need static Members

Similar Messages

Maybe you are looking for