Question

我正在阅读有效的Java 2 - 第22项，它在标题中说：

“赞成非静态的静态成员类”

但在本章的最后

集合接口的实现，例如Set和List，通常使用非静态成员类来实现它们的迭代器：

// Typical use of a nonstatic member class
public class MySet<E> extends AbstractSet<E> {
    ... // Bulk of the class omitted

    public Iterator<E> iterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<E> {
        ...
    }
}

我制作了一个测试程序，看看它们之间是否存在差异，并且在这里。

public class JavaApplication7 {


    public static void main(String[] args) {
        // TODO code application logic here
        JavaApplication7 t = new JavaApplication7();

        Inner nonStaticObject = t.getAClass();
        Sinner staticObject = new JavaApplication7.Sinner();

        nonStaticObject.testIt();
        staticObject.testIt();         
    }

    public Inner getAClass(){
        return new Inner();
    }

    static class Sinner{
        public void testIt(){
            System.out.println("I am inner");
        }
    }

    class Inner{
        public void testIt(){
            System.out.println("I am inner");
        }
    }
}

输出

我内心深处我内心

所以，他们做了同样的工作。

我想知道为什么在这个例子中使用了非静态类？

Answer 1

迭代器通常需要首先引用用于创建它的集合。您可以使用静态嵌套类来实现这一点，该类显式提供了对集合的引用 - 或者您可以使用内部类，它隐式具有该引用。

基本上，如果嵌套类的每个实例都需要一个封闭类的实例来操作（并且该实例不会改变），那么你也可以将它作为一个内部类。否则，将其设为静态嵌套类。

Answer 2

不同之处在于，非静态内部类具有对包含类的隐式引用。

public class JavaApplication7 {

  //You can access this attribute in non-static inner class
  private String anyAttribute;

  public Inner getAClass(){
    return new Inner();
  }

  static class Sinner{
    public void testIt(){
      //Here, you cannot access JavaApplication7.this
    }
  }

  class Inner{
    public void testIt(){
        //Here, you can access JavaApplication7.this
        //You can also access *anyAttribute* or call non-static method getAClass()
    }
  }
}

Answer 3

static和非静态嵌套类之间的区别在于，非静态类与外部类的实例隐式关联，它们可以称为OuterClassName.this。在实现迭代器时，此引用是有用的，因为它们需要访问与它们相关的集合的成员。您可以通过使用static嵌套类来实现相同的功能，该类显式地提交了对外部类的引用。

Answer 4

没有静态内部类这样的东西，它是静态嵌套类。 “非静态[嵌套]类的每个实例都与其包含类的封闭实例隐式关联......可以在封闭实例上调用方法。”

静态嵌套类无权访问封闭实例。

参考：this so thread

Answer 5

In the case of creating instance, the instance of non s
static inner class is created with the reference of
object of outer class in which it is defined……this
means it have inclosing instance …….
But the instance of static inner class
is created with the reference of Outer class, not with
the reference of object of outer class…..this means it
have not inclosing instance…
For example……
class A
{
class B
{
// static int x; not allowed here…..

}
static class C
{
static int x; // allowed here
}
}

class Test
{
public static void main(String… str)
{
A o=new A();
A.B obj1 =o.new B();//need of inclosing instance

A.C obj2 =new A.C();

// not need of reference of object of outer class….
}
}

静态和非静态内部类的区别？

5 个答案: