Java内部类和静态嵌套类

我不认为上述答案中真正的区别变得清晰.

首先要使条款正确:

嵌套类是一个类,它包含在源代码级别的另一个类中.

如果使用static修饰符声明它,它是静态的.

非静态嵌套类称为内部类.(我留在非静态嵌套类.)

到目前为止,马丁的回答是正确的.但是,实际的问题是:声明嵌套类静态的目的是什么？

如果您只想将类保持在一起,或者如果嵌套类专门用于封闭类,则可以使用静态嵌套类.静态嵌套类与每个其他类之间没有语义差异.

非静态嵌套类是一种不同的野兽.与匿名内部类相似,这种嵌套类实际上是闭包.这意味着他们捕获周围的范围及其封闭的实例并使其可访问.也许一个例子将澄清这一点.查看Container的这个存根:

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

在这种情况下,您希望从子项目到父容器的引用.使用非静态嵌套类,这没有一些工作.您可以使用语法访问Container的封闭实例Container.this.

更多核心解释如下:

如果查看编译器为(非静态)嵌套类生成的Java字节码,它可能会变得更加清晰:

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public (Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

如您所见,编译器会创建一个隐藏字段Container this$0.这是在构造函数中设置的,该构造函数具有Container类型的附加参数以指定封闭实例.您无法在源中看到此参数,但编译器会为嵌套类隐式生成它.

马丁的例子

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

会被编译成类似(在字节码中)的调用

new InnerClass(outerObject)

为了完整起见:

匿名类是刚刚没有与之关联的名称,并且不能在以后引用非静态嵌套类的一个很好的例子.

我认为上述答案都没有向您解释嵌套类和静态嵌套类在应用程序设计方面的真正区别:

概观

嵌套类可以是非静态的,也可以是静态的,并且在每种情况下都是在另一个类中定义的类.嵌套类应该只存在于封闭类中,如果嵌套类对其他类(不仅是封闭的)有用,则应该声明为顶级类.

区别

非静态嵌套类:与包含类的封闭实例隐式关联,这意味着可以调用封闭实例的方法和访问变量.非静态嵌套类的一个常见用途是定义Adapter类.

静态嵌套类:无法访问封闭的类实例并在其上调用方法,因此在嵌套类不需要访问封闭类的实例时应该使用它.静态嵌套类的一个常见用途是实现外部对象的组件.

结论

因此,从设计的角度来看,两者之间的主要区别是:非静态嵌套类可以访问容器类的实例,而静态则不能.

简单来说,我们需要嵌套类主要是因为Java不提供闭包.

嵌套类是在另一个封闭类的主体内定义的类.它们有两种类型 - 静态和非静态.

它们被视为封闭类的成员,因此您可以指定四个访问说明符中的任何一个 - private, package, protected, public.我们没有顶级类的奢侈品,只能声明public或包私有.

内部类也称为非堆栈类可以访问顶级类的其他成员,即使它们被声明为私有,而静态嵌套类也无法访问顶级类的其他成员.

public class OuterClass {
    public static class Inner1 {
    }
    public class Inner2 {
    }
}

Inner1是我们的静态内部类,Inner2是我们的内部类,它不是静态的.它们之间的关键区别是,您无法创建Inner2没有外部的实例,因为您可以Inner1独立创建对象.

你什么时候使用内心课？

考虑一种情况,其中Class A和Class B相关,Class B需要访问Class A成员,并且Class B仅与之相关Class A.内部课程进入了画面.

要创建内部类的实例,需要创建外部类的实例.

OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();

要么

OuterClass.Inner2 inner = new OuterClass().new Inner2();

你什么时候使用静态内部类？

当您知道它与封闭类/顶级类的实例没有任何关系时,您将定义一个静态内部类.如果你的内部类不使用外部类的方法或字段,那只是浪费空间,所以将它静态化.

例如,要为静态嵌套类创建对象,请使用以下语法:

OuterClass.Inner1 nestedObject = new OuterClass.Inner1();

静态嵌套类的优点是它不需要包含类/顶级类的对象.这可以帮助您减少应用程序在运行时创建的对象数量.

以下是Java内部类和静态嵌套类之间的主要区别和相似之处.

希望能帮助到你!

内心阶级

可以访问外部类实例和静态方法和字段

与封闭类的实例关联以便首先实例化它需要一个外部类的实例(注意新关键字的地方):

Outerclass.InnerClass innerObject = outerObject.new Innerclass();

无法定义任何静态成员本身

不能有Class或Interface声明

静态嵌套类

无法访问外部类实例方法或字段

与封闭类的任何实例都没有关联,以便实例化它:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

相似

这两个内部类可以访问甚至是私有字段和方法的外部类

另外,外部类访问私有字段和方法的内部类

这两个类都可以具有私有,受保护或公共访问修饰符

为什么使用嵌套类？

根据Oracle文档,有几个原因(完整文档):

它是一种逻辑分组仅在一个地方使用的类的方法:如果一个类只对另一个类有用,那么将它嵌入该类并将两者保持在一起是合乎逻辑的.嵌套这样的"帮助类"使得它们的包更加简化.

它增加了封装:考虑两个顶级类A和B,其中B需要访问A的成员,否则这些成员将被声明为私有.通过将类B隐藏在类A中,可以将A的成员声明为私有,并且B可以访问它们.另外,B本身可以隐藏在外面.

它可以带来更易读和可维护的代码:在顶级类中嵌套小类会使代码更接近于使用它的位置.

我认为,通常遵循的惯例是:

顶级类中的静态类是嵌套类

顶级类中的非静态类是一个内部类,它还有两个形式:

本地类 - 在块内部声明的类,如方法或构造函数体

匿名类 - 未命名的类,其实例在表达式和语句中创建

但是,要记住的其他几点是:

顶级类和静态嵌套类在语义上是相同的,除了在静态嵌套类的情况下,它可以对其外部[父]类的私有静态字段/方法进行静态引用,反之亦然.

内部类可以访问Outer [parent]类的封闭实例的实例变量.但是,并非所有内部类都包含实例,例如静态上下文中的内部类,如静态初始化程序块中使用的匿名类,则不会.

默认情况下,匿名类扩展父类或实现父接口,并且没有其他子句可以扩展任何其他类或实现更多接口.所以,

new YourClass(){}; 手段 class [Anonymous] extends YourClass {}

new YourInterface(){}; 手段 class [Anonymous] implements YourInterface {}

我觉得更大的问题仍然是开放哪一个使用什么时候？那么这主要取决于你正在处理的场景,但阅读@jrudolph给出的答案可能会帮助你做出一些决定.

嵌套类:类内部的类

类型:

静态嵌套类

非静态嵌套类[Inner class]

区别:

非静态嵌套类[Inner class]

在非静态嵌套类内部类的对象存在于外部类的对象中.因此外部类的数据成员可以被内部类访问.因此要创建内部类的对象,我们必须首先创建外部类的对象.

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass(); 

静态嵌套类

在内部类的静态嵌套类对象中不需要外部类的对象,因为单词"static"表示不需要创建对象.

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

如果要访问x,请编写以下内部方法

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

在创建外部类的实例时,将创建内部类的实例.因此,内部类的成员和方法可以访问外部类的实例(对象)的成员和方法.当外部类的实例超出范围时,内部类实例也不再存在.

静态嵌套类没有具体实例.它刚刚在第一次使用时加载(就像静态方法一样).它是一个完全独立的实体,其方法和变量无法访问外部类的实例.

静态嵌套类不与外部对象耦合,它们更快,并且它们不占用堆/堆栈内存,因为它不需要创建此类的实例.因此经验法则是尝试定义静态嵌套类,尽可能限制范围(private> = class> = protected> = public),然后将其转换为内部类(通过删除"静态"标识符)并放松范围,如果真的有必要的话.

关于嵌套静态类的使用有一些微妙之处,这些静态类在某些情况下可能很有用.

静态属性在通过构造函数实例化类之前得到实例化,嵌套静态类中的静态属性似乎直到调用类的构造函数之后才被实例化,或者至少直到首次引用属性之后才被实例化,即使它们被标记为"最终".

考虑这个例子:

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

即使'nested'和'innerItem'都被声明为'static final'.在实例化类之后(或者至少直到首次引用嵌套静态项之后)才会发生nested.innerItem的设置,因为您可以通过注释和取消注释我引用的行来自行查看,以上.同样不适用于'outerItem'.

至少这是我在Java 6.0中看到的.

在创建实例的情况下,非静态内部类的实例是使用外部类的对象的引用创建的,在该对象中定义它.这意味着它有实例.但是静态内部类的实例是使用外部类的引用创建的,而不是使用外部类的对象的引用.这意味着它没有包含实例.

例如:

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….
  }
}

我不认为这里有很多内容,大多数答案完美地解释了静态嵌套类和内部类之间的区别.但是,在使用嵌套类与内部类时请考虑以下问题.作为一对夫妇的答案提到的内部类不能没有和他们的外围类的实例,它意味着他们被实例化HOLD一个指针,以他们的包围类的实例,它可能会导致内存溢出或堆栈溢出异常由于在GC即使它们不再使用,也无法对封闭类进行垃圾收集.为清楚起见,请检查以下代码:

public class Outer {


    public  class Inner {

    }


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

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

如果你删除评论// inner = null;该程序将把" 我被摧毁! ",但保持这个评论它不会.
原因是仍然引用了白色内部实例GC无法收集它,并且因为它引用(有一个指针)外部实例它也没有被收集.在项目中有足够的这些对象,并且可能会耗尽内存.
与不与内部类实例有关的静态内部类相比,因为它与实例无关但与类相关.如果你使Inner类静态并实例化,上面的程序可以打印" 我被销毁! "Outer.Inner i = new Outer.Inner();

这些术语可互换使用.如果你想对它真的很迂腐,那么你可以定义"嵌套类"来引用一个静态内部类,一个没有封闭实例.在代码中,您可能会遇到以下情况:

public class Outer {
    public class Inner {}

    public static class Nested {}
}

但这并不是一个广泛接受的定义.

嵌套类是一个非常通用的术语:每个不是顶级的类都是嵌套类.内部类是非静态嵌套类.Joseph Darcy写了一篇关于嵌套,内部,成员和顶级类的非常好的解释.

嗯......内部类是一个嵌套类...你的意思是匿名类和内部类吗？

编辑:如果你实际上意味着内部与匿名......内部类只是在类中定义的类,例如:

public class A {
    public class B {
    }
}

而匿名类是匿名定义的类的扩展,因此没有定义实际的"类",如:

public class A {
}

A anon = new A() { /* you could change behavior of A here */ };

进一步编辑:

维基百科声称 Java 存在差异,但我已经使用Java工作了8年,这是我第一次听到这样的区别......更不用说那里没有提到支持声明了...... line,内部类是在类中定义的类(静态或非静态),嵌套只是另一个术语,意思是相同的东西.

静态和非静态嵌套类之间存在细微差别...基本上非静态内部类具有对实例字段的隐式访问和封闭类的方法(因此它们不能在静态上下文中构造,它将是一个编译器错误).另一方面,静态嵌套类没有对实例字段和方法的隐式访问,并且可以在静态上下文中构造.

针对学习者,他们是Java和/或嵌套类的新手

嵌套类可以是:
1.静态嵌套类.
2.非静态嵌套类.(也称为内课)=>请记住这一点

1.Inner类
示例:

class OuterClass  {
/*  some code here...*/
     class InnerClass  {  }
/*  some code here...*/
}

内部类是嵌套类的子集:

内部类是嵌套类的特定类型

内部类是嵌套类的子集

你可以说内部类也是一个嵌套类,但你不能说嵌套类也是一个内部类.

内班专业:

内部类的实例可以访问外部类的所有成员,甚至是那些标记为"私有"的成员

2.静态嵌套类:
示例:

class EnclosingClass {
  static class Nested {
    void someMethod() { System.out.println("hello SO"); }
  }
}

情况1:从非封闭类中实例化静态嵌套类

class NonEnclosingClass {

  public static void main(String[] args) {
    /*instantiate the Nested class that is a static
      member of the EnclosingClass class:
    */

    EnclosingClass.Nested n = new EnclosingClass.Nested(); 
    n.someMethod();  //prints out "hello"
  }
}

情况2:从封闭类中实例化静态嵌套类

class EnclosingClass {

  static class Nested {
    void anotherMethod() { System.out.println("hi again"); } 
  }

  public static void main(String[] args) {
    //access enclosed class:

    Nested n = new Nested(); 
    n.anotherMethod();  //prints out "hi again"
  }

}

静态课程专业:

静态内部类只能访问外部类的静态成员,并且无权访问非静态成员.

结论:
问题: Java中内部类和静态嵌套类之间的主要区别是什么？
答:只需仔细阅读上面提到的每个课程的具体内容.

Java中的内部类和嵌套静态类都是在另一个类中声明的类,在Java中称为顶级类.在Java术语中,如果声明嵌套类为static,则它将在Java中调用嵌套静态类,而非静态嵌套类则简称为内部类.

什么是Java中的内部类？

任何不是顶级或在另一个类中声明的类称为嵌套类,在这些嵌套类中,声明为非静态的类在Java中称为Inner类.Java中有三种内部类:

1)本地内部类 - 在代码块或方法中声明.
2)匿名内部类 - 是一个没有名称可引用的类,并在创建它的同一位置初始化.
3)成员内部类 - 被声明为外部类的非静态成员.

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. main() 
        class Local {
            public void name() {
                System.out.println("Example of Local class in Java");

            }
        }      
        //creating instance of local inner class
        Local local = new Local();
        local.name(); //calling method from local inner class

        //Creating anonymous inner class in Java for implementing thread
        Thread anonymous = new Thread(){
            @Override
            public void run(){
                System.out.println("Anonymous class example in java");
            }
        };
        anonymous.start();

        //example of creating instance of inner class
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.Inner inner = test.new Inner();
        inner.name(); //calling method of inner class
    }

     //Creating Inner class in Java
    private class Inner{
        public void name(){
            System.out.println("Inner class example in java");
        }
    }
}

什么是Java中的嵌套静态类？

嵌套静态类是另一个类,它在类中声明为成员并且是静态的.嵌套静态类也被声明为外部类的成员,可以像任何其他成员一样使其成为私有,公共或受保护.嵌套静态类相对于内部类的主要好处之一是嵌套静态类的实例未附加到任何外部类的外部实例.您也不需要任何Outer实例来在Java中创建嵌套静态类的实例.

1)它可以访问外部类的静态数据成员,包括private.
2)静态嵌套类无法访问非静态(实例)数据成员或方法.

public class NestedStaticExample {
    public static void main(String args[]){  
        StaticNested nested = new StaticNested();
        nested.name();
    }  
    //static nested class in java
    private static class StaticNested{
        public void name(){
            System.out.println("static nested class example in java");
        }
    }
}

参考:Java中的内部类和嵌套静态类与示例

我想这里的人应该注意到海报:Static Nest Class只是第一个内部类.例如:

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

因此,总结一下,静态类不依赖于它包含哪个类.所以,他们不能在正常的课堂上.(因为普通类需要一个实例).

当我们在类中声明静态成员类时,它被称为顶级嵌套类或静态嵌套类.它可以证明如下:

class Test{
    private static int x = 1;
        static class A{
        private static int y = 2;
        public static int getZ(){
            return B.z+x;
        }
    }
    static class B{
        private static int z = 3;
        public static int getY(){
            return A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

当我们在类中声明非静态成员类时,它被称为内部类.内部类可以如下所示:

    class Test{
        private int i = 10;
        class A{
            private int i =20;
            void display(){
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);
            System.out.println(Test.this.i);
        }
    }
}