How does one who is using IntelliJ or Android Studio extract a public static inner class to create a new top level class?

Thank you.

Intellij Extract Inner Class

I working on a sample problem of over-ridding hashCode and equals method but getting an error: &quot;**No enclosing instance of type CustomHashCodeExample is accessible. Must qualify the allocation with an enclosing instance of type CustomHashCodeExample (e.g. x.new A() where x is an instance of CustomHashCodeExample).**&quot;
I wrote an inner class HashPerson and I am getting this error when I am trying to instantiate this inner class in another method called testHashCodeOverride().

    public static void testHashCodeOverride(){	 
        System.out.println(&quot;\nTest HashCode Override Method&quot;);
    	System.out.println(&quot;==================================\n&quot;);
	    
    	HashPerson william = new HashPerson(&quot;willy&quot;);
    	HashPerson bill = new HashPerson(&quot;willy&quot;);	    	
    }

This code works fine, even though I dont see static inner class or instantiation of outer class, confused :(
 

    public class HashCodeExample {

        public static void testHashCodeOverride() {

            HashPerson william = new HashPerson(&quot;Willy&quot;);
            HashPerson bill = new HashPerson(&quot;Willy&quot;);
            System.out.println(&quot;Hash code for william  = &quot; + william.hashCode());
            System.out.println(&quot;Hash code for bill     = &quot; + bill.hashCode());

            HashMap table = new HashMap();
            table.put(william, &quot;Silly&quot;);

            if (table.containsKey(william)) {
                System.out.println(table.get(william));
            } else {
                System.out.println(&quot;Key &quot; + william + &quot; not found&quot;);
            }

            if (table.containsKey(bill)) {
                System.out.println(table.get(bill));
            } else {
                System.out.println(&quot;Key &quot; + bill + &quot; not found&quot;);
            }


        }

        class HashPerson {
            private static final int HASH_PRIME = 1000003;

            public HashPerson(String name) {
                this.name = name;
            }

            public String toString() {
                return name;
            }

            public boolean equals(Object rhs) {
                if (this == rhs)
                    return true;

                // make sure they are the same class
                if (rhs == null || rhs.getClass() != getClass())
                    return false;

                // ok, they are the same class. Cast rhs to HashPerson
                HashPerson other = (HashPerson) rhs;

                // our test for equality simply checks the name field
                if (!name.equals(other.name)) {
                    return false;
                }

                // if we get this far, they are equal
                return true;
            }
            public int hashCode() {
                int result = 0;
                result = HASH_PRIME * result + name.hashCode();
                return result;
            }
            private String name;

        }
    }

Instantiating inner class

Probably similar to the question, https://stackoverflow.com/questions/1801718/why-can-outer-java-classes-access-inner-class-private-members or https://stackoverflow.com/questions/31478718/access-to-superclass-private-fields-using-the-super-keyword-in-a-subclass .

But there are some differences: the children class can access the private members of their parent (and **only the nearest parent**) class.

Given the sample code below:
        
	public class T {

		private int t;

		class T1 {
			private int t1;

			public void test() {
				System.out.println(t);
			}
		}

		class T2 extends T1 {

			private int t2;

			public void test() {
				System.out.println(t);
				System.out.println(super.t1);
				System.out.println(this.t2);
			}
		}

		class T3 extends T2 {

			public void test() {
				System.out.println(t);
				System.out.println(super.t1); // NG: t1 Compile error! Why?
				System.out.println(super.t2); // OK: t2 OK
			}
		}
	}


Why can nested child classes access private members of their parent class, but grandchildren cannot?

I have the following code. I want to get hold of the outer class object using which I created the inner class object `inner`. How can I do it?

    public class OuterClass {
    
    	public class InnerClass {
    		private String name = &quot;Peakit&quot;;
    	}
    
    	public static void main(String[] args) {
    		OuterClass outer = new OuterClass();
    		InnerClass inner = outer.new InnerClass();
           // How to get the same outer object which created the inner object back?
    		OuterClass anotherOuter = ?? ;
                
            if(anotherOuter == outer) {
                 System.out.println(&quot;Was able to reach out to the outer object via inner !!&quot;);
            } else {
                 System.out.println(&quot;No luck :-( &quot;);
            }
    	}
    }


**EDIT:** Well, some of you guys suggested of modifying the inner class by adding a method:

    public OuterClass outer() {
       return OuterClass.this;
    }

But what if I don&#39;t have control to modify the inner class, then (just to confirm) do we have some other way of getting the corresponding outer class object from the inner class object?

Getting hold of the outer class object from the inner class object

I&#39;m trying to understand about nested classes in C#.  I understand that a nested class is a class that is defined within another class, what I don&#39;t get is why I would ever need to do this.

Why Would I Ever Need to Use C# Nested Classes

Can someone please point me towards some nice resources for understanding and using nested classes? I have some material like Programming Principles and things like this [*IBM Knowledge Center - Nested Classes*](https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.1.0/com.ibm.zos.v2r1.cbclx01/cplr061.htm)

But I&#39;m still having trouble understanding their purpose. Could someone please help me?

Why would one use nested classes in C++?

I observed that Outer classes can access inner classes private instance variables. How is this possible? Here is a sample code demonstrating the same:


    class ABC{
        class XYZ{
            private int x=10;
        }
        
        public static void main(String... args){
            ABC.XYZ xx = new ABC().new XYZ();
            System.out.println(&quot;Hello :: &quot;+xx.x); ///Why is this allowed??
        }
    }

Why is this behavior allowed?


Why can outer Java classes access inner class private members?

I have a situation like so...

    class Outer(object):
        
        def some_method(self):
            # do something
        
        class Inner(object):
            def __init__(self):
                self.Outer.some_method()    # &lt;-- this is the line in question

How can I access the `Outer` class&#39;s method from the `Inner` class?

How to access outer class from an inner class?

Why can&#39;t we have static method in a non-static inner class?

    public class Foo {
        class Bar {
            static void method() {} // Compiler error
        }
    }

If I make the inner class static it works. Why?

    public class Foo {
        static class Bar { // now static
            static void method() {}
        }
    }

In Java 16+, both of these are valid.

Why can&#39;t we have static method in a (non-static) inner class (pre-Java 16)?

    class Outer {
    
        class Inner {
        public:
            Inner() {}
            void func() ;
        };
    
    private:
        static const char* const MYCONST;
        int var;
    };
    
    void Outer::Inner::func() {
        var = 1;
    }
    
    const char* const Outer::MYCONST = &quot;myconst&quot;;

This errors out when I compile with class Outer::Inner&#39; has no member named `var&#39;

Can inner classes access private variables?

I have the following piece of code:

    public class MyClass {

       class Inner {
         int s, e, p;
       }

       public static void main(String args[]) {
         Inner in;
       }
    }
Up to this part the code is fine, but I am not able to instantiate &#39;in&#39; within the main method like `in = new Inner()` as it is showing `non static field cannot be referenced in static context`.

What is the way I can do it? I do not want to make my `Inner` class *static*.

How to instantiate non static inner class within a static method?

I&#39;m building a **User Class** for my new website, however this time I was thinking to build it little bit differently...

**C++**, **Java** and even **Ruby** (and probably other programming languages) are allowing the use of nested/inner classes inside the main class, which allows us to make the code more object-oriented and organized.

In PHP, I would like to do something like so:

    &lt;?php
      public class User {
        public $userid;
        public $username;
        private $password;
    
        public class UserProfile {
          // some code here
        }
    
        private class UserHistory {
          // some code here
        }
      }
    ?&gt;

Is that possible in PHP? How can I achieve it?
&lt;hr&gt;

**UPDATE**

If it&#39;s impossible, will future PHP versions might support nested classes?

Nested or Inner Class in PHP

In Java, nested classes can be either `static` or not. If they are `static`, they do not contain a reference to the pointer of the containing instance (they are also not called inner classes anymore, they are called nested classes).

Forgetting to make an nested class `static` when it does not need that reference can lead to problems with garbage collection or escape analysis.

Is it possible to make an anonymous inner class `static` as well? Or does the compiler figure this out automatically (which it could, because there cannot be any subclasses)?

For example, if I make an anonymous comparator, I almost never need the reference to the outside:

      Collections.sort(list, new Comparator&lt;String&gt;(){
           int compare(String a, String b){
              return a.toUpperCase().compareTo(b.toUpperCase());
           }
      }



Is it possible to make anonymous inner classes in Java static?

I&#39;m trying to understand scope in nested classes in Python. Here is my example code:

    class OuterClass:
        outer_var = 1
        class InnerClass:
            inner_var = outer_var

The creation of class does not complete and I get the error:

&lt;!-- language: lang-none --&gt;

    &lt;type &#39;exceptions.NameError&#39;&gt;: name &#39;outer_var&#39; is not defined

Trying `inner_var = Outerclass.outer_var` doesn&#39;t work.
I get:

&lt;!-- language: lang-none --&gt;

    &lt;type &#39;exceptions.NameError&#39;&gt;: name &#39;OuterClass&#39; is not defined

I am trying to access the static `outer_var` from `InnerClass`.

Is there a way to do this?


Nested classes&#39; scope?

I am trying to include raw JSON inside a Java object when the object is (de)serialized using Jackson. In order to test this functionality, I wrote the following test:

	public static class Pojo {
		public String foo;
		
		@JsonRawValue
		public String bar;
	}
	
	@Test
	public void test() throws JsonGenerationException, JsonMappingException, IOException {
		
		String foo = &quot;one&quot;;
		String bar = &quot;{\&quot;A\&quot;:false}&quot;;
	
		Pojo pojo = new Pojo();
		pojo.foo = foo;
		pojo.bar = bar;
	
		String json = &quot;{\&quot;foo\&quot;:\&quot;&quot; + foo + &quot;\&quot;,\&quot;bar\&quot;:&quot; + bar + &quot;}&quot;;
		
		ObjectMapper objectMapper = new ObjectMapper();
		String output = objectMapper.writeValueAsString(pojo);
		System.out.println(output);
		assertEquals(json, output);
		
		Pojo deserialized = objectMapper.readValue(output, Pojo.class);
		assertEquals(foo, deserialized.foo);
		assertEquals(bar, deserialized.bar);
	}

The code outputs the following line:

    {&quot;foo&quot;:&quot;one&quot;,&quot;bar&quot;:{&quot;A&quot;:false}}

The JSON is exactly how I want things to look. Unfortunately, the code fails with an exception when attempting to read the JSON back in to the object. Here is the exception:

&gt;    org.codehaus.jackson.map.JsonMappingException: Can not deserialize instance of java.lang.String out of START_OBJECT token
     at [Source: java.io.StringReader@d70d7a; line: 1, column: 13] (through reference chain: com.tnal.prism.cobalt.gather.testing.Pojo[&quot;bar&quot;])

Why does Jackson function just fine in one direction but fail when going the other direction? It seems like it should be able to take its own output as input again. I know what I&#39;m trying to do is unorthodox (the general advice is to create an inner object for `bar` that has a property named `A`), but I don&#39;t want to interact with this JSON at all. My code is acting as a pass-through for this code -- I want to take in this JSON and send it back out again without touching a thing, because when the JSON changes I don&#39;t want my code to need modifications.

Thanks for the advice.

EDIT: Made Pojo a static class, which was causing a different error.

How can I include raw JSON in an object using Jackson?

Is it possible to create an *inner class* within an interface?  
If it is possible why would we want to create an *inner class* like that since
we are not going to create any interface objects?

Do these *inner classes* help in any development process?


Inner class within Interface

What is the main difference between an inner class and a static nested class in Java? Does design / implementation play a role in choosing one of these?

Java inner class and static nested class

    class OuterClass {
     class InnerClass {
      static int i = 100; // compile error
      static void f() { } // compile error
     }
    } 

Although it&#39;s not possible to access the static field with `OuterClass.InnerClass.i`, if I want to record something that should be static, e.g. the number of InnerClass objects created, it would be helpful to make that field static. So *why* does Java prohibit static fields/methods in inner classes?

EDIT: I know how to make the compiler happy with static nested class (or static inner class), but what I want to know is why java forbids static fields/methods inside inner classes (or ordinary inner class) from both the language design and implementation aspects, if someone knows more about it.

Why does Java prohibit static fields in inner classes?

Is it possible to create an instance of an interface in Java?

Somewhere I have read that using inner anonymous class we can do it as shown below:
```java
interface Test {
    public void wish();
}

class Main {
    public static void main(String[] args) {
        Test t = new Test() {
            public void wish() {
                System.out.println(&quot;output: hello how r u&quot;);
            }
        };
        t.wish();
    }
}
```
```none
cmd&gt; javac Main.java
cmd&gt; java Main
output: hello how r u
```

Is it correct here?


Can we create an instance of an interface in Java?

I am relatively new to C# and each time I begin to work on a C# project (I only worked on nearly mature projects in C#) I wonder why there are no inner classes?

Maybe I don&#39;t understand their goal. To me, inner classes -- at least private inner classes -- look a lot like &quot;inner procedures&quot; in Pascal / Modula-2 / Ada : they allow to break down a main class in smaller parts in order to ease the understanding.

Example : here is what is see most of the time :

    public class ClassA
    {
       public MethodA()
       {
          &lt;some code&gt;
          myObjectClassB.DoSomething(); // ClassB is only used by ClassA
          &lt;some code&gt;
       }
    }
    
    public class ClassB
    {
       public DoSomething()
       {
       }
    }

Since ClassB will be used (at least for a while) only by ClassA, my guess is that this code would be better expressed as follow :

       public class ClassA
       {
          public MethodA()
          {
             &lt;some code&gt;
             myObjectClassB.DoSomething(); // Class B is only usable by ClassA
             &lt;some code&gt;
          }
    
          private class ClassB
          {
             public DoSomething()
             {
             }
          }
       }

I would be glad to hear from you on this subject - Am I right?

Private inner classes in C# - why aren&#39;t they used more often?

I read about [Structuring Unit Tests][1] with having a test class per class and an inner class per method. Figured that seemed like a handy way to organize the tests, so I tried it in our Java project. However, the tests in the inner classes doesn&#39;t seem to be picked up at all.

I did it roughly like this:

    public class DogTests
    {
        public class BarkTests
        {
            @Test
            public void quietBark_IsAtLeastAudible() { }
            
            @Test
            public void loudBark_ScaresAveragePerson() { }
        }
    
        public class EatTests
        {
            @Test
            public void normalFood_IsEaten() { }
    
            @Test
            public void badFood_ThrowsFit() { }
        }
    }

Does JUnit not support this, or am I just doing it wrong?


  [1]: http://haacked.com/archive/2012/01/02/structuring-unit-tests.aspx

Test cases in inner classes with JUnit

I&#39;m trying to make a Tetris game and I&#39;m getting the compiler error 
&gt;`Shape is not an enclosing class`

 when I try to create an object

    public class Test {
        public static void main(String[] args) {
            Shape s = new Shapes.ZShape();
        }
    }

I&#39;m using inner classes for each shape. Here&#39;s part of my code

    public class Shapes {
        class AShape {
        }
        class ZShape {
        }
    }


What am I doing wrong ?

Is not an enclosing class Java

Is it possible to get a reference to `this` from within a Java inner class?

i.e.

    class Outer {

      void aMethod() {

        NewClass newClass = new NewClass() {
          void bMethod() {
            // How to I get access to &quot;this&quot; (pointing to outer) from here?
          }
        };
      }
    }

How can &quot;this&quot; of the outer class be accessed from an inner class?

If I have for example a class along with a helper class to do some of its functionality, does it make sense to make it as an inner class. 

        public class Foo {
           private FooHelper helper;

           // constructor &amp; any other logic

           public void doSomeThing() {
             helper.do();
           }
        }

        public class FooHelper {
            public void do() {
             // code
            }
        }


In the above case does it make sense to make the `FooHelper` as an inner class ? Apology if this sound stupid but I am little confused about the use cases.

When to use inner classes in Java for helper classes

What I try to do is this:

    public class History {
    	public class State {
    		public enum StateType {

Eclipse gives me this compile error on `StateType`: `The member enum StateType must be defined inside a static member type`.

The error disappears when I make the `State` class static. I could make `State` static, but I don&#39;t understand why I cannot declare an `enum` in an inner class.

Why can&#39;t I create an enum in an inner class in Java?

I&#39;m playing with lambdas in Java 8 and I came across warning `local variables referenced from a lambda expression must be final or effectively final`. I know that when I use variables inside anonymous class they must be final in outer class, but still - what is the difference between *final* and *effectively final*?

Difference between final and effectively final

What is the difference between static and non-static nested class?

Java: Static vs inner class

Say if I have a dropdown in a form and I have another nested class inside of this class .
Now what&#39;s the best way to access this dropdown from the nested class? 

What&#39;s the best way of accessing field in the enclosing class from the nested class?

I came across this code today whilst reading [Accelerated GWT (Gupta) - page 151][1].

    public static void getListOfBooks(String category, BookStore bookStore) {
        serviceInstance.getBooks(category, bookStore.new BookListUpdaterCallback());
    }
    public static void storeOrder(List books, String userName, BookStore bookStore) {
        serviceInstance.storeOrder(books, userName,    bookStore.new StoreOrderCallback());
    }

What are those new operators doing there?  I&#39;ve never seen such syntax, can anyone explain?

Does anyone know where to find this in the java spec?


  [1]: http://books.google.com.au/books?id=KXBdajKMJGEC&amp;lpg=PR2&amp;ots=w5NJtxR7nS&amp;dq=accelerated%20gwt&amp;pg=PA151#v=onepage&amp;q&amp;f=false

How does &quot;object.new&quot; work? (Does Java have a .new operator?)

I wondered if it makes sense to declare a private method as final as well, and I thought it doesn&#39;t make sense. But I imagined there&#39;s an exclusive situation and wrote the code to figure it out:

    public class Boom {

        private void touchMe() {
    	    System.out.println(&quot;super::I am not overridable!&quot;);
        }
    
        private class Inner extends Boom {

    	    private void touchMe() {
    	        super.touchMe();
    	        System.out.println(&quot;sub::You suck! I overrided you!&quot;);
    	    }
        }
    
        public static void main(String... args) {
    	    Boom boom = new Boom();
    	    Boom.Inner inner = boom.new Inner();
    	    inner.touchMe();
        }
    }

It compiled and worked. &quot;I should make touchMe() final&quot; I thought and did it: 

    public class Boom {

        private final void touchMe() {
    	    System.out.println(&quot;super::I am not overridable!&quot;);
        }
    
        private class Inner extends Boom {

    	    private void touchMe() {
    	        super.touchMe();
    	        System.out.println(&quot;sub::You suck! I overrided you!&quot;);
    	    }
        }
    
        public static void main(String... args) {
    	    Boom boom = new Boom();
    	    Boom.Inner inner = boom.new Inner();
    	    inner.touchMe();
        }
    }

and it also works and tells me

    chicout@chicout-linlap:~$ java Boom
    super::I am not overridable!
    sub::You suck! I overrided you!

why?

Why inner class can override private final method?

I have the following code:


    class Hello {
        class Thing {
            public int size;
          
            Thing() {
                size = 0;
            }
        }
     
        public static void main(String[] args) {
            Thing thing1 = new Thing();
            System.out.println(&quot;Hello, World!&quot;);
        }
    }

I know `Thing` does nothing, but my Hello, World program compiles just fine without it. It&#39;s only my defined classes that are failing on me.

And it refuses to compile. I get `No enclosing instance of type Hello is accessible.&quot;` at the line that creates a new Thing. I&#39;m guessing either:

 1. I have system level problems (either in DrJava or my Java install) or
 2. I have some basic misunderstanding of how to construct a working program in java.

Any ideas?

What causes error &quot;No enclosing instance of type Foo is accessible&quot; and how do I fix it?

I have been reading some articles on memory leaks in Android and watched this interesting video from Google I/O [on the subject][1].

Still, I don&#39;t fully understand the concept, and especially when it is safe or dangerous to user **inner classes inside an Activity**.

This is what I understood:

A memory leak will occur if an instance of an inner class survives longer than its outer class (an Activity).
-&gt; **In which situations can this happen?** 

In this example, I suppose there is no risk of leak, because there is no way the anonymous class extending `OnClickListener` will live longer than the activity, right?

        final Dialog dialog = new Dialog(this);
        dialog.setContentView(R.layout.dialog_generic);
        Button okButton = (Button) dialog.findViewById(R.id.dialog_button_ok);
        TextView titleTv = (TextView) dialog.findViewById(R.id.dialog_generic_title);

        // *** Handle button click
        okButton.setOnClickListener(new OnClickListener() {
            public void onClick(View v) {
                dialog.dismiss();
            }
        });

        titleTv.setText(&quot;dialog title&quot;);
        dialog.show();

Now, is this example dangerous, and why?

                
    // We are still inside an Activity
    _handlerToDelayDroidMove = new Handler();
    _handlerToDelayDroidMove.postDelayed(_droidPlayRunnable, 10000);

    private Runnable _droidPlayRunnable = new Runnable() { 
        public void run() {
            _someFieldOfTheActivity.performLongCalculation();
        }
    };

I have a doubt regarding the fact that understanding this topic has to do with understanding in detail what is kept when an activity is destroyed and re-created.

Is it?

Let say I just changed the orientation of the device (which is the most common cause of leaks). When `super.onCreate(savedInstanceState)` will be called in my `onCreate()`, will this restore the values of the fields (as they were before orientation change)? Will this also restore the states of inner classes?

I realize my question is not very precise, but I&#39;d really appreciate any explanation that could make things clearer.

  [1]: http://www.youtube.com/watch?v=_CruQY55HOk

When exactly is it leak safe to use (anonymous) inner classes?

	final JTextField jtfContent = new JTextField();
	btnOK.addActionListener(new java.awt.event.ActionListener(){
		public void actionPerformed(java.awt.event.ActionEvent event){
			jtfContent.setText(&quot;I am OK&quot;);
		}
	} );

If I omit `final`, I see the error &quot;*Cannot refer to a non-final variable jtfContent inside an inner class defined in a different method*&quot;.

Why must an anonymous inner class require the outer classes instance variable to be final in order to access it?



Why Java inner classes require &quot;final&quot; outer instance variables?

I am reviewing the concept of inner classes in java. so far from what I&#39;ve understood and applied java inner classes has a link or access to the methods and fields of its outer/ enclosing class.

My Question: 
&lt;ol&gt;
&lt;li&gt;When should create or define an inner class? &lt;/li&gt;
&lt;li&gt;are inner classes considered to be called as &quot;Helper classes&quot; ?&lt;/li&gt;
&lt;li&gt;What are the indicators for you to make an inner class and what&#39;s their other purpose?&lt;/li&gt;&lt;/ol&gt;

All Inner Classes Solutions on Gang of Coders

Total of 34 Inner Classes Solutions