实例化内部类

Question

我正在处理覆盖 hashCode 和 equals 方法的示例问题，但出现错误：“没有可访问类型 CustomHashCodeExample 的封闭实例。必须使用 CustomHashCodeExample 类型的封闭实例来限定分配（egxnew A () 其中 x 是 CustomHashCodeExample 的一个实例）。" 我编写了一个内部类 HashPerson，当我尝试在另一个名为 testHashCodeOverride() 的方法中实例化这个内部类时出现此错误。

public static void testHashCodeOverride(){   
    System.out.println("\nTest HashCode Override Method");
    System.out.println("==================================\n");

    HashPerson william = new HashPerson("willy");
    HashPerson bill = new HashPerson("willy");          
}

这段代码工作正常，即使我没有看到静态内部类或外部类的实例，很困惑:(

public class HashCodeExample {

    public static void testHashCodeOverride() {

        HashPerson william = new HashPerson("Willy");
        HashPerson bill = new HashPerson("Willy");
        System.out.println("Hash code for william  = " + william.hashCode());
        System.out.println("Hash code for bill     = " + bill.hashCode());

        HashMap table = new HashMap();
        table.put(william, "Silly");

        if (table.containsKey(william)) {
            System.out.println(table.get(william));
        } else {
            System.out.println("Key " + william + " not found");
        }

        if (table.containsKey(bill)) {
            System.out.println(table.get(bill));
        } else {
            System.out.println("Key " + bill + " not found");
        }


    }

    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;

    }
}

Answer 1

您需要将内部类设为静态，或者通过外部类的实例引用它。很可能你只是想让你的内部类静态。

类的非静态成员（变量、方法、内部类）是类的每个实例。因此，当从静态上下文（如testHashCodeOverride之类的静态方法）访问非静态成员时，需要指定封闭类的实例。

Answer 2

我想你想将HashPerson 类声明为static。否则它只能在包含类的上下文中实例化，要么在包含类的方法中，要么使用如下代码：

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

实际上，我的经验法则是将任何嵌套类设为静态，除非我有特殊理由不这样做。这也更有效，因为非静态嵌套类（称为内部类）总是包含对包含对象的隐式引用。

Answer 3

正如我所见，实例化内部类可能有不同的方法

1. 静态内部类：当内部类是静态时，假设代码看起来像描述的那样。

   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();
   

或者这对于静态类来说就足够了

 new StaticNestedClass();

1. 本地内部类（非静态）：非静态的内部类，本地内部类的一件好事是它们可以访问封闭类的所有私有数据成员。

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

2. Anonymous Inner Class (implementing Interface) ：这类类一般是隐藏的，在代码中无法直接看到 Class{...} 块，所以称为Anonymous Inner Class .这里描述了如何在内部类实现接口Runnable Interface的情况下实例化它。

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

3. 匿名内部类（扩展一个类）：我们可以有一个匿名内部类扩展一个类，这里​​我以线程类为例，

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

4. 在方法/构造函数参数中定义的匿名内部类：内部类也可以在方法中定义，这里举例说明如何在参数中定义和实例化它

   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();