Static member-class varaiable instanciation

Hello,
I have an inner class which I'm trying instanciate as a static variable. here is the code:
public class A {
protected static B b;
private A (){} //private constructor because B is singleton
class B {
//some code
=========================================================
I cannot say
protected static B b = new B();
because new operator returns this.new_instance_of_B, and "this" cannot be referenced from the static constant...
How can I instanciate this variable (b)?? Thank you,
Elana

You could make the class static but depending on how the class is written you might be better off just instatiating b in your constuctor. I question declaring b protected. You can not subclass a singleton (no public constructor), therefore there is no reason to declare b protected. If you want other classes to access b from inside the package just use package level (default) access. Having a static member of a singleton that isn't private seems to violoate the purpose of the Singleton pattern though. I don't know what you are trying ot do but I would declare your class like this.
public class A {
    private static B b;
    private A (){
        b = new B();
    private class B {
        //some code
}

Similar Messages

  • Why a non static member class can be defined in an interface

    Non-static member classes are defined as instance members of other classes, just like fields and instance methods are defined in a class. An instance of a non-static member class always has an enclosing instance associated with it.
    An interface can't be instantiated then how a non static member class will have an enclosing instance associated with it.
    interface outer
            public  class inner{
            public void p()
                System.out.println("inside interface's non static member class");
        public  static class inner1{
                public void p(){System.out.println("inside interface's  static member class");
    public class Client {                                           // (11)
        public static void main(String[] args) {                    // (12)
        outer.inner nonStatic = new outer.inner();
            nonStatic.p();
        outer.inner1 stat = new outer.inner1();
          stat.p();
    }inner is a non static member class even then " outer.inner nonStatic = new outer.inner();" working fine ?????????????

    class outer
            public  class inner{
            public void p()
                System.out.println("inside interface's non static member class");
    public class Client {                                           // (11)
        public static void main(String[] args) {                    // (12)
        outer.inner nonStatic = new outer.inner();
        nonStatic.p();
    }on compiling the above code the error message i got is
    "not an enclosing class: outer"
    the reason of this compilation error is "outer.inner nonStatic = new outer.inner();
    it should be "outer.inner nonStatic = new outer(). new inner();"
    now my question is
    interface outer
            public  class inner{
            public void p()
                System.out.println("inside interface's non static member class");
    public class Client {                                           // (11)
        public static void main(String[] args) {                    // (12)
        outer.inner nonStatic = new outer.inner();
        nonStatic.p();
    }on compiling the above code why compilation error is not coming??????????
    i think now it is more clear what i am asking

  • About static member class?

    I can unstand the technical detail about static member class. But i still have a question about it.The questionis when shall we use it when we design a poject. In another word, in which situation, static member class will show its advantage? Thanks a lot.

    http://search.java.sun.com/search/java/index.jsp?qp=&nh=10&qt=static+nested+class&col=javaforums

  • Does a member class have to be within the same source file?

    Hi there,
    I have this application that extensively uses two classes. The main class setsup the GUI, and the second main class is responsible for handling all of the actions that arise from the GUI.
    I could have done this by making all of my handler methods be of the first main class, but this class really is just for the GUI setup, the logic doesn't fit into this class' behaviour.
    The class that handles the GUI actions is required to use the fields of the main class e.g. to get values of a text field. The problem is that since the class that handles the actions is getting very big, I would kind of like to move this class into a different source file - because currently it is a member class of the first one, so that it can access all of its fields.
    Is there some way that I can move this handler class into another source file, and still have it access all of the fields of the main GUI class - without making the fields public, or using millions of get/set methods? Also, I can't use inheritance because the both the GUI class creates an instance of the handler class in its constructor, and so leads to an infinite loop when trying to instantiate the GUI class.
    Can I ask.. would a static class or something be of use here? Do they exist? I'm confused as to how to do this without getting the mother of all source files (in size that is - nothing to do with cooking or baking).
    - Anyway, thanks in advance for any help that you could give me -
    BYEE, Edd.

    You can't have an inner class that is not in the same source file. However, you could use package-protected (default) access to give another class in the same package access to things without making them public. Actually, that's how inner classes are actually compiled. Package-protected access is underused IMHO. It's a great tool that most people (including myself) are suspicious of at first.

  • Creating a new instance of a member class?

    I'm writting a serialization library for a college project and I have a problem with deserializing an object which class contains a member class. A rough example:
    class Outer{
         class Member{
              double d =0;
         public Member member =new Member();     
    }Most basically I tried to get a new instance of the Member class in order to get the double field, change it's value, then use that new instance as a field of an object of the Outer class.
    Field f = Outer.class.getDeclaredField("member");
    f.setAccessible(true);
    f.getClass().newInstance(); Both this and the Constructor method throw an exception:
    Exception in thread "main" java.lang.InstantiationException: java.lang.reflect.Fieldpointing at the line with newInstance().
    Is there anything I can do to create an object of a member class? And if not then taking into account that I have to deserialize the Outer object from an XML file what could be the alternative?

    The error message already gives you a hint that it's not class Outer.Member you're instantiating there (review the API docs)...
    import java.lang.reflect.*;
    public class Outer{
      public static void main(final String[] args) {
        final Field f = Outer.class.getDeclaredField("member");
        f.setAccessible(true);
        final Constructor ctor =
                f.getType().getDeclaredConstructor(new Class[] { Outer.class });
        final Object outer = new Outer();
        final Object member = ctor.newInstance(new Object[] { outer });
        // set member.d
        f.set(outer, member);
      class Member{
        double d =0;
      public Member member =new Member();     
    }

  • Instantiating member classes using reflection

    I have checked through this forum but if the answer to this question is here I missed it.
    I am trying to find out how to invoke the appropriate instantiation / constructor call to create an instance of a member class.
    The following works finepublic class Succeeds {
      public abstract static class AbstractMember {
      Succeeds(final AbstractMember am) {
      public static void main(final String[] args) {
        Succeeds a = new Succeeds (new Succeeds.AbstractMember () {
    }However I want to make the AbstractMember a real member class not a nested inner class and I want to instantiate the concrete subclass of AbstractMember in the constructor of Succeeds rather than outside the class. I tried the following:public class Fails {
      public abstract class AbstractMember {
        public class ConcreteMember extends AbstractMember {
      Fails(final Class<? extends AbstractMember> c)
        throws InstantiationException, IllegalAccessException {
        AbstractMember am = c.newInstance() ;
      public static void main(final String[] args)
        throws InstantiationException, IllegalAccessException {
        Fails a = new Fails (Fails.AbstractMember.ConcreteMember.class) ;
    }(Please forgive the appling treatment of exceptions, I wanted to make a small example). This compiles fine but fails at runtime with an InstantiationException I assume because the nullary constructor doesn't exist for a member class because of the need to make the connection to the containing object.
    So the question is is there a bit of reflection that allows me to achieve what I want?
    I cannot be the first person to try doing this. I am hoping it is doable otherwise I am going to have to make the design a bit yukky.
    Thanks.

    import java.lang.reflect.*;
    public class Fixed
        public abstract class AbstractMember
        public class ConcreteMember extends AbstractMember
        <T extends AbstractMember> Fixed(final Class<T> c) throws Exception
            Constructor<T> ctor = c.getConstructor(new Class[]{getClass()});
            AbstractMember am = ctor.newInstance(new Object[]{this});
        public static void main(final String[] args) throws Exception
            new Fixed(ConcreteMember.class);
    }My exception handling is even more lax than yours. Why isn't there a class ReflectionException? I moved ConcreteMember out of AbstractMember to keep things simple. It's not entirely necessary, but I didn't want to construct an AbstractMember first.

  • Are static nested classes thread-safe?

    There doesn't seem to be any definitive answer to this. Given the following code, is it thread-safe?
    public class SomeMultiThreadedWebController {
    public HttpServletResponse someMethodToExecuteViaWebRequest(HttpServletRequest request) {
        simpleQueryBuilder("SELECT...").addParameter("asdf","asdf").createQuery(EMF.getEntityManager()).executeUpdate();
    protected static class SimpleQueryBuilder {
             private String queryString;
             private Map<String, Object> params = new HashMap<String, Object>();
             public SimpleQueryBuilder(String queryString) {
                  this.queryString = queryString;
             public SimpleQueryBuilder addParameter(String name, Object value) {
                  params.put(name, value);
                  return this;
             public Query createQuery(EntityManager em) {
                  Query query = em.createQuery(queryString);
                  for (Entry<String, Object> entry : params.entrySet()) {
                       query.setParameter(entry.getKey(), entry.getValue());
                  return query;
        public static SimpleQueryBuilder simpleQueryBuilder(String queryString) {
             return new SimpleQueryBuilder(queryString);
    }Forget whether or not someone would do this, as this is just an example. I'm really trying to get at whether or not the instance variables inside the static nested class are thread-safe. Thanks for any responses.

    Hello,
    I believe you understand what you're talking about, but you state it in a way that is very confusing for others.
    Let me correct this (essentially, incorrect uses of the terminology):
    I agree that thread-safe or not is for an operation, for a member, it has some sort of contextual confusion.
    Member has a much broader meaning in the [Java Language Specification|http://java.sun.com/docs/books/jls/third_edition/html/names.html#6.4] . Even "class member" applies to both an attribute, a method, or an inner class or interface.
    I think you mean "member variable" of a class (aka "attribute" or "field"). By the way, static or not is irrelevant to the rest of the discussion.
    For an operation or a member, if there's only one thread could access it atomically in one moment, we could call it thread-safe.Mmm. I was tempted to say yes (I'm reluctant to commit myself). With an emphasis on "_The encapsulating class_ makes this member's usage thread-safe".
    Still, just synchronizing each operation on a member is not enough to make all usages "thread-safe":
    Consider a java.util.Vector: each add/get is synchronized, so it is atomic, fine.
    However if one thread adds several values, let's say 3, one by one, to a vector that initially contains 0 values, and another thread reads the vector's size() (another properly synchronized method), the reader thread may witness a size anywhere among 0, 1, 2, 3, which, depending on the business logic, may be a severely inconsistent state.
    The client code would have to make extra work (e.g. synchronizing on the vector's reference before the 3 adds) to guarantee that the usage is thread-safe.
    Thus any synchronized method(With the limit stated above)
    or immutable member (like primitive type) are thread-safe.
    Additionally for a member, if it's immutable, then it's thread-safe. You mean, immutable primitive type, or immutable object. As stated previously, an immutable reference to a mutable object isn't thread-safe.
    a static final HashMap still have thread-safe issue in practice because it's not a primitive.The underlined part is incorrect. A primitive may have thread-safety issues (unless it's immutable), and an object may not have such issues, depending on a number of factors.
    The put, get methods, which will be invoked probably, are not thread-safe although the reference to map is.Yes. And even if the put/get methods were synchronized, the client code could see consistency issues in a concurrent scenario, as demonstrated above.
    Additional considerations:
    1) read/write of primitive types are not necessarily atomic: section [ §17.7 of the JLS|http://java.sun.com/docs/books/jls/third_edition/html/memory.html#17.7] explicitly states that writing a long or double value (2 32-bits words) may not be atomic, and may be subject to consistency issues in a concurrent scenario.
    2) The Java Memory Model explicitly allows non-synchronized operations on non-volatile fields to be implemented in a "thread-unsafe" way by the JVM. Leading way to a lot of unintuitive problems such as the "Double-Checked Locking idiom is broken". Don't make clever guess on code execution path unless you properly synchronize access to variables across threads.
    Edited by: jduprez on Mar 4, 2010 9:53 AM

  • [SOLVED] Passing a non-static member function as a function pointer

    I need to pass a function pointer to a public method to a system call, nftw() to be precise.
    I know that member functions don't match the required signature because of the hidden 'this' pointer, but
    the only way to work around that is by using a small wrapper function that makes use of a global variable (the object of which I want to call the method).
    Speaking in code, this is the way I've solved the problem currently:
    // create a global variable here
    static MyObject obj;
    static int myObject_method_wrapper(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) {
    return obj.handleDirEntry(fpath, sb, tflag, ftwbuf);
    // somewhere in main()
    nftw(walkroot, myObject_method_wrapper, 20, FTW_PHYS);
    Now, my question: Can't this be done without a global instance of MyObject? It is pointed out here that other ways are existent, but sadly they are not mentioned.
    Glad if someone could help me out!
    Last edited by n0stradamus (2012-04-24 22:59:47)

    I think you are stuck:
    1. You are not in control of the interface (of nftw), and furthermore,
    2. You are not in control of any of the parameters sent to the callback.
    nftw has no idea which one of your objects it is supposed to reference, and
    there's no apparent way to tell it.
    But given this situation, are you sure it makes sense to use a non-static
    member?  It seems kind of strange to me-- any instance-specific data is
    necessarily going to be independent of the function calls!  So even if you
    engineer something to avoid using a global, whatever you engineer is still
    going to involve some *arbitrary* instance of your class (e.g. peterb's
    solution, which uses the most recently created instance).  The arbitrary-ness
    doesn't feel right, since it sort of implicitly says that none of the instance
    data is important.  No important instance-specific data sounds like static...

  • Static nested class

    Hi there.
    Im playing around with static nested classes:
    class OuterC {
         int x = 10;
         static class Nest {
              void doStuff() {
                   System.out.println("Going");
                   //System.out.println("Should be allowed print: " + x);
                   doOtherStuff();
              public void doOtherStuff() {
                   System.out.println("Doing Stuff!");
    public class Test {
         static class OtherNest {
              void arbitraryMethod() {
                   System.out.println("Going to do arbitrary stuff...");
         public static void main(String[] args) {
              OuterC.Nest n = new OuterC.Nest();
              n.doStuff();
              OtherNest on = new OtherNest();
              on.arbitraryMethod();
    }//close TestWhen I uncomment the statement to print out the instance variable x of class OuterC
    I get a "cannot access non-static..." error, which is fine. I expect that.
    But why can I run the doOtherStuff() method from the static nested class Nest?
    doOtherStuff() is after all an instance method...
    Many Thanks & regards!
    Edited by: Boeing-737 on May 29, 2008 10:27 AM
    Dont bother replying, I see the error now. The method is defined as a member within the nested
    class. Apologies, I didn't spot that. My mistake.
    Thanks.
    Edited by: Boeing-737 on May 29, 2008 10:28 AM

    From the JLS, chapter 8:
    A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested class.
    This chapter discusses the common semantics of all classes-top level (?7.6) and nested (including member classes (?8.5, ?9.5), local classes (?14.3) and anonymous classes (?15.9.5)).
    So "nested" iff "not top level".From the JLS, chapter 8:
    An inner class is a nested class that is not explicitly or implicitly declared static.
    So a "static" nested class is a bit redundant, since a "non-static" nested class -- a nested class is either static or it isn't -- is more specifically referred to as an "inner class". That's my story and I'm sticking to it. :o)
    ~

  • Static nested class VS non-static nested class ??

    we know static method can be called without creating an object and static variables are shared among objects.
    what is the difference between static nested class and non-static nested class ? When do we use them? what is the advantages of static nested class over non-static nested class in term of performance?

    From the JLS, chapter 8:
    A nested class is any class whose declaration occurs within the body of another class or interface. A top level class is a class that is not a nested class.
    This chapter discusses the common semantics of all classes-top level (?7.6) and nested (including member classes (?8.5, ?9.5), local classes (?14.3) and anonymous classes (?15.9.5)).
    So "nested" iff "not top level".From the JLS, chapter 8:
    An inner class is a nested class that is not explicitly or implicitly declared static.
    So a "static" nested class is a bit redundant, since a "non-static" nested class -- a nested class is either static or it isn't -- is more specifically referred to as an "inner class". That's my story and I'm sticking to it. :o)
    ~

  • Enclosing class calling private constructor of private member class

    Hi all,
    I have this question concerning member classes and privtae constructors.
    public class MyTest {
        private class Inner {
            private Inner() {
                System.out.println("Why Am I here!??");
        public MyTest() {
            Inner a = new Inner();
        public static void main(String[] s) {
            MyTest z = new MyTest();
    }It doesn't work for my JDK SE 1.3.3, build 1.3.1-b24.
    It works for many other versions.
    Can somebody kindly enlighten me, should this code work?
    I really didn't think that it should, but it did!

    I am sorry. It was actually my jikes 1.15 that was causing the problem.
    After some research, I found out that my problem arose out of my understanding of OO concepts, or rather, the meaning of access modifiers in Java.
    I had thought that nobody can access a private variable/method of class except the class itself. Apparently, this is not so. The access modifiers apply to the class themselves and not the object. Thus explaining why an object can access the private variables/methods of another object of the same class.
    Actually, it's not really the case here. The Java language specs states that the inner class has total access to the enclosing class, but I could not find any word on enclosing class access to inner classes in the specs.
    As for Jikes, I really hope they will fix it soon. I like it a lot as it is significantly faster than javac for everything I have done so far.
    cheers!

  • Static member reference

    Hi:
    I have a question regarding how static members are referenced. Here is a simple example.
    public abstract class A {
    public static int a = 1;
    public void printA()
    System.out.println(a);
    public class B extends A {
    public static int a = 2;
    public class C extends B {
    public static int a = 3;
    Now when I do this:
    A x = new A();
    B y = new B();
    x.printA();
    y.printB();
    they all print 1, but I was expecting x.printA() to print 2 as x's a is 2 and y.printA() to print 3 as y's a is 3.
    I have a class structure where each class has some static members, now i am writing methods in each class to access these static members
    repeatedly. They are the same code, just in different classes. I would like to just put these code into a super class so I would not need to
    rewrite the same thing over and over again. Somehow I have not found a way.
    To me, rewriting the same piece of code usually indicates bad programming. But I am not smart enough to figure out a way.
    Is there a way?
    Thanks a lot in advance.
    FTC

    freetochoose wrote:
    my problem is quite practical.
    I have many classes that all have the same kind of static members. For example, each class has a filename and database table name where i save the data.
    so if i have a super class that has a method like
    savetofile() or savetodatabase()
    each subclass will supply the filename and table name.
    but as my example shows
    in the super class method public void savetofile(), filename will only refer to the super class's static member, and will not
    refer to the sub class's static member, filename, which is what i want.Then don't use static members, use instance-variables, or make the superclass abstract and add abstract methods to get the filename / table name, so every subclass needs to implement that method to return the correct name.
    so i have written code and tested out that in a super class, a reference to a static member is only to that class's static member.
    it will not refer to a subclass's static member even when the object is an instance of a subclass.
    in the end, i concocted the method using java reflection, getClass().getField(this, staticMemberName).toString()
    and it works the way i want it. but somehow, it does not seem too elegant in the sense that reflection should be
    used rarely and i am wondering if there is a better way of doing the same thing without reflection.Never use reflection unless you really have to, and you don't.

  • Static member variable conundrum

    I'm using an abstract base class so that subclasses can share common functionality.
    Each subclass needs a static member variable (a String) that needs to be accessed from the abstract base class in some of it's methods.
    This is where the problem is; I would like to declare an abstract variable in the base class so that the base class methods can use the variable, but you can't make an abstract variable static.
    Is there a way around this or am I approaching this problem from the wrong direction?

    I can't remember if you can override static methodsTested this and determined that you can't. The superclass static gets called. Makes sense.
    I also tested my suggested code, and made a few improvements ... maybe it isn't quite so ugly after all (can you tell that I'm slogging through some boring stuff?):
    public class Tester1
        protected static HashMap _stringTable = new HashMap();
        static
            _stringTable.put(Tester1.class, "Tester 1");
        protected String getString()
            return (String)_stringTable.get(this.getClass());
        public static void main(String[] argv)
            Tester1 t1 = new Tester1();
            Tester2 t2 = new Tester2();
            Tester1 t3 = new Tester2();
            System.out.println("t1.getString() = " + t1.getString());
            System.out.println("t2.getString() = " + t2.getString());
            System.out.println("t3.getString() = " + t3.getString());
    public class Tester2 extends Tester1
        static
            _stringTable.put(Tester2.class, "Tester 2");

  • Static member varaibles

    Hi,
    What is the advantage in having static member varaibles in a Singleton class?
    Since, the class itself is Singleton, is there any advantage in having static member varaibles in the class?
    Thanks in advance,

    If the class is a Singleton that means that onlyone
    reference to the class exists. As such, you can
    freely make all member variables instancevariables.
    Most, but not all. Think of the Singleton reference
    itself. :) Very true!
    Or a reference counter in case you later
    need it to be a "multipleton". And it might also have
    some utility methods...
    Then I would humbly assert it is no longer a Singleton.
    for some reason, JBuilder's code check advises to
    declare all methods that aren't accessing non-static
    members as static. I don't know whether to follow
    that or not. I prefer work to be done by objects.I've had that confusion as well. Why not simply declare a static private variable and provide static public accessors and mutators? The alternative is a single, Singleton instance which has its own local variables, IMO. But both seem valid to me.
    - Saish

  • Static inner class

    class A{
    static class B{
    public void instanceMethod()
    System.out.println("instance method");
    class C{}How do I access the instanceMethod() of class B from class C ?

    But what does new A.B() mean.Static means that
    doesent run inside any instance of the class, rather it runs with class
    itself. So shouldnt it have been just A.new B()
    No, a static nested class is just a static member of the outer class.
    All other static members are accessible as Outer.innerMember and
    just so with that static nested class. Your proposal:A.new B()doesn't make sense because 'new' is not a static
    member of outer class A.
    kind regards,
    Jos

Maybe you are looking for