Instantiating inner class

As i can see there could be different possible ways to instantiate the Inner Classes

1. Static Inner Class : When Inner class is static, let say code looks like as describe.

   class OuterClass 
   {
       static int outer_x = 10;
       int outer_y = 20;
       // static nested class 
       static class StaticNestedClass {
           void display() {
   
           }
       }
   }
   
   OuterClass.StaticNestedClass nestedObject =
    new OuterClass.StaticNestedClass();
   

or Just this could be sufficient for static classes

 new StaticNestedClass();

2. Local inner Classes (Non Static) : Inner Classes which are not static, one good thing with local inner classes that they can access all private data members of enclosed class.

   OuterClass outerObject = new OuterClass(); 
   OuterClass.InnerClass innerObject = outerObject.new InnerClass();
   

3. Anonymous Inner Class (implementing Interface) : This type of classes generally hidden, One can't directly see the Class{...} block in code , That is why known as Anonymous Inner Class. Here describes how to instantiate it in case inner class implementing an interface Runnable Interface.

   Runnable r = new Runnable() 
   { 
     //This is Anonymous Class
     public void run() {
       System.out.println("Child Thread");
     }
   };
   

4. Anonymous Inner Class (Extending One Class):We can have an anonymous inner class that extends a class, Here i am taking example of Thread Class,

   Thread t = new Thread(new Runnable() 
   {
     //Anonymous Inner class
   public void run() {
       System.out.println("Child Thread");
   }
   });
   

5. Anonymous Inner class that defines inside method/constructor argument : Inner Classes could be define within methods as well, here giving example how can we define and instantiate it within argument

   public static void main(String[] args) 
   { 
   //Here we are using Anonymous Inner class 
   //that define inside argument, here constructor argument 
   Thread t = new Thread(new Runnable() 
   { 
       public void run() 
       { 
           System.out.println("Child Thread"); 
       } 
   });
   t.start();
   

You need to either make your inner class static, or refer to it through an instance of the outer class. Most likely you just want to make your inner class static.

Non-static members of a class (variables, methods, inner classes) are per instance of the class. Therefore, when accessing non-static members from a static context (such as a static method like testHashCodeOverride), you need to specify an instance of the enclosing class.

I think you want to declare the HashPerson class as static. Otherwise it can only be instantiated in the context of the containing class, either in a method of the containing class or using code like this:

ContainingClass container = new ContainingClass();
HashPerson william = container.new HashPerson("willy");

Actually, my rule-of-thumb is to make any nested class static, unless I have a special reason not to. This is also more efficient, because non-static nested classes (called inner classes) always contain an implicit reference to the containing object.