Static abstract inner classes

Sorry to sound stupid, but why would a class be static? I've encountered an example of an abstract static inner class and I'm not sure why it's static. Static methods I understand -- they are methods of the class and not the instance. So then, can someone explain to me a static class?
Thanks,
Erik

You have encountered a static nested class (not a static inner class - an inner class is a nested class that is not static).
A static nested class is a nested class that does not require an instance of its enclosing class to exist in order that it can be instantiated. - It is mainly used for code organisation, and can be treated just like a top-level class.
In practice, most nested classes (except perhaps event handlers), tend to be static.
For an example of a static nested class from the core APIs, have a look at HasMap.Entry

Similar Messages

Using static interface inner class.. how?

Can anyone tell me how I'm able to use an inner class that is a static interface?
Specifically I'm getting DocumentEvents through a DocumentListener..
Then within DocumentEvents there is an inner class which is a static interface called:
DocumentEvent.ElementChange, I'm trying to use the methods contained within the interface ElementChange.
Can anyone throw a helping hand as to how I go about this?
Thanks :)

public class A ... {
public static interface B {
}Just creates a public interface called A.B
How are you supposed to use this with your DocumentEvent? I can't say

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.

Why inner classes cannot have static declarations ?

Hi Friends,
When i tried to make static declarations on a inner class which is non static, i am getting compilation error saying "inner classes cannot have static declarations". I want to know reason behind this implementation.
Code which i have tried:
public class TestOuter
class TestInner{
static int i =10;
public static boolean validate(int a){
if(a==0)
System.out.println("Invalid data");
return false;
return true;
public static void main(String a[]){
boolean result = new TestOuter.TestInner.validate(0);
System.out.println("Result="+result);
Thanks,
Shiju V.

so I think if the
outer class is not static , then Inner class can't be
static as well. This is incorrect. An enclosed class can be indeed static while the outer is not, and vice versa.
The difference between static/non static in regards to enclosed classes is that the static ones are 'top-level' and cannot access the members of the enclosing class.
The effect of making an enclosed class static means there is only one instance of any variables, no matter how many instances of the outer class are created. In this situation how could the static inner class know which variables to access of its non static outer class. Of course the answer is that it could not know, and thus an static inner class cannot access instance variables of its enclosing class.
Now, regarding non-static inner classes, and trying to give a valid answer to the original post:
As with instance methods and variables, a non-static inner class is associated with an instance of its enclosing class and has direct access to that object's instance variables and methods.
TestOuter outer = new TestOuter();
TestOuter.TestInner inner = outer.new TestInner();Because an inner class is associated with an instance (inner class implicitly keeps a reference to the object of the enclosing class that created it), it cannot define any static members itself. Static members cannot access the this pointer.
So, in an ordinary (non-static) inner class, the link to the outer class object is achieved with a special this reference. A static inner class does not have that special this reference, nor would a static method/variable of an ordinary (non-static) inner class.

Static abstract methods - how can I avoid them?

Hi everybody,
just found out that java doesn't allow static abstract methods nor static methods in interfaces. Although I understand the reasons, I can't think of how to change my design to gain the required behavior without the need of static abstract methods.
Here's what I want to do and how my thoughts lead to static abstract methods:
ClassA provides access to native code (c-dll, using jna). The path to the dll can be set programmatically. Here's a draft of the class:
public ClassA {
   private static String path;
   public static void setRealtivePath(String path) {
      //check if path exists and is not null -> get absolute path
      setPath(path);
   public static void setPath(String absolutePath) {
      this.path = path;
//code to provide access to native lib
}There is some more classes which provide access to different dlls (therefore the code for accessing the dlls differs from ClassA). Although this works, the setRelativePath method has to be implemented in each class. I thought it would be nice to put this method into a abstract super class that looks like this:
public abstract class superClass {
   public static void setRelativePath(String path) {
      //check if path exists and is not null -> get absolute path
      setPath(path);
   //force inherting class to implement a static method
   public static abstract void setPath(String absolutePath);
}thus simplifying ClassA and it's look-a-likes:
public ClassA {
   private static String path;
   @Override
   public static void setPath(String absolutePath) {
      this.path = path;
//code to provide access to native lib
}Since static abstract methods (and overriding static methods) is not allowed, this doesn't work.
I hope someone can catch my idea ;). Any suggestions how to do this in a nice clean way?
Thanks in advance,
Martin
Edited by: morty2 on Jul 22, 2009 2:57 AM

First of all, thanks a lot for your answer.
YoungWinston wrote:
Actually, you can "override" static methods (in that you can write the same method for both a subclass and a superclass, providing the superclass method isn't final); it's just that it doesn't work polymorphically. The "overriding" method masks the overridden one and the determination of what gets called is entirely down to the declared type.Yes, I know that. There's one problem: Your suggestion means that I simply have to drop the abstract modifier in the super classes setPath method. However, since the super class calls the setPath method (and not the inherting classes!) it will always be the super classes' method being called.
YoungWinston wrote:
Why are you so concerned with making everything static? Seems to me that the simplest solution would be to make all the contents instance-based.I want ClassA and it's look-a-likes to be set up properly at application start up, be accessible quite anytime and easily, they don't do anything themselves except for setting the path and calling into the native library which does the math. (Compareable to how you call e.g. Math.cos()). Therefore I don't think that an instance-based solution would be a better approach.
YoungWinston wrote:
Furthermore, you could make the class immutable; which might be a good thing - I'm not sure I'd want someone being able to change the pathname after I've >set up a class like this.Thanks for that!
PS: As mentioned in my first post, I do have a working solution. However, I'm really corious about finding a nicer and cleaner way to do it!
Martin

New to Inner classes

I was wondering the use of Inner classes in real world example with some good example.
Thanks in Advance.

I use Inner Classes to keep the API for my packages
less cluttered, and when there's no current
expectation that the class should ever be instantiated
outside the outter class. Imagine creating JavaDocs
to present to management, and them asking about each
class wondering what it does, and you have to reply to
each one, well that's a helper class that developers
don't need to worry about. Instead, put the classes
where they belong.
Now, like another poster said, if the class has a
chance to be re-used, there isn't really that much
harm in making it outter.Every corpreate class I've taken, or heard of has said exactly what I posted. The easier it is to read the better. Now, using them for arbitrary tasks is one thing, but there is usually a way to get around it. I seen no problem in using that window closing abstract inner class, or abstract inner classes to handle buttons being pressed, but a lot of times there is an easier way to do things to make them more readable. From my experience management likes readability so they can have anyone look at the code to edit if they need to.

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 class of abstract class

Hi All,
Sorry for my English...
Say I have an abstract Class A and and inner class within A named B.
When I extend class A (i.e. making a subclass of A) does it mean the class B also inheritaned?
Thank u in advance
Eyal

Eyal2007 wrote:
Does inner class of an outer abstract class can be static?Yes, why not?
is there any logic in this?Yes, if follows the normal meanings of access types and the difference between static and instance entities.
A protected inner class is accessible in the same places a protected field would be.

Static inner class causes deployment on OC4J 10.1.2 to fail

Hi,
this issue has already been raised on OC4J 9.0.4 with J2SDK 1.4.2 (see EJB fails to compile - static inner class problem
Recap: When referencing static inner classes in an EJB, the deployment fails. During the generation of the wrapper classes, a signature <package>.<outer class>.<inner class> gets converted to <package>.<outer class>$<inner class>, which is syntactically wrong. While the Java 1.4.1 compiler kindly ignores this syntax error, its 1.4.2 counterpart complains - and fails.
@Oracle: When will this bug be fixed for OC4J 10.1.2?
Best regards,
Holger

Holger,
Don't static inner classes contradict the EJB specification?
In any case, in answer to Andy's question: If you wish to file this as a bug, you can do so via the MetaLink Web site.
[In fact, [i]MetaLink is your only option for submitting bugs for Oracle products -- as far as I know.]
Good Luck,
Avi.

How to use a static inner class?

what's the implication of identifier "static" before an inner class.Thank you.

not sure what implication is, due to my poor vocabulary. But here's an uuh... "example" of a static inner class:
public class Example {
static class AnotherClass {
}There you have class "Example" with the static inner class "AnotherClass." If you wanted to use "AnotherClass" you would do something like:
public class Whatever {
Example.AnotherClass ac = new Example.AnotherClass();
}I don't think I'm mistaken there, but if I am someone please correct me.

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?

Why Inner class cannot access static variables

Why is it that inner class can use only static final variables of the outerclass, and not ordinary static variables of the outer class. "Yes the JLS sepcifies that only final static variables can be used inside an inner class, esp a non blank final variable". But why this restriction.
Thanks.

so what are final static variables treated as if they
are not variables. So if the final static value is
not loaded when the class is loaded how will the
class know about the value.??The actual value wil be substituted for the name of a static final value at compile time. That's why you can use them in switch statements where you can't use any variable variable.
This is something to watch out for, by the way, because if you use a public static final value from one class in another the actual value will be compiled into the using class, so if you change the value where it's defined the class using it will have the old value until it's recompiled.

Why can an inner.inner class not be static?

First, look at these 2 classes:
public class A1 {
public A1() {
new B1.C1();
public class B1 {
public static class C1 {
public class A2 {
public A2() {
new B2.C2();
class B2 {
public static class C2 {
Class A2 will compile just fine, but A1 will not saying that I can't define class C1 as static.
Why not?
Class C1 is not associated with an instance of B1 (because it's static), and we already have an instance of A1 (since we're in the constructor).
Why is this so radically different that A2 (which works)?

In class A1 the inner class B1 is just like a mehtod of class A1.
So how we cant create static variable inside a method , similarly the class A1
didnt accepting its inner class b! to create static class.
(This is my assumption/view only, may be wrong)

EJB fails to compile - static inner class problem

I am using OC4J 9.0.4 and Sun JDK1.4.2 and EJBs fail to compile if they reference objects that contain static inner classes. However, they successfully compile under JDK1.4.1.
For example, I have a class like below:
public class ValueObject
public static class Key
private Key key;
private String value;
Any references to ValueObject.Key inside the EJB cause the EJB compiler to generate "ValueObject$Key" which is incorrect. JDK1.4.1 is more lenient than 1.4.2, and allows this error through.
Is there a way around this problem other than reverting to JDK1.4.1?
Regards,
Andy

The reason I don't want to move to JDK 1.4.1 is because of the memory leak in the StringBuffer.toString() method.
Is there anywhere I can submit this as a bug?
Regards,
Andy

How to dynamically load static (inner) class

I have an urgnent question, any comments would be appricated.
I have a static inner class definition.
Class myObject
public static class innerObject
I want to dynamically load the static innerObject class such as
Class c = Class.forName ( "myObject.innerObject" );
innerObject t = ( innerObject ) c.newInstance();
I can't do this as it give me ClassNotFound Exception, Do I need to load myObject first? any comments?
The other alternative is that to define my myObject as having a static variable referencing the static class.
Class myObject
staic innerObject m_inner = new innerObject();
public static class innerObject
Is there any option in java allowing me to load a static variable?
Many thanks
Jay

I can't do this as it give me ClassNotFound Exception,Use "myObject$innerObject" instead of "myObject.innerObject".
Is there any option in java allowing me to load a
static variable?What do you mean by that?

Static abstract inner classes

Similar Messages

Maybe you are looking for