Question

Java中内部类和静态嵌套类之间的主要区别是什么？设计/实施是否在选择其中一个方面发挥作用？

Answer 1

嵌套类分为两类：静态和非静态。声明为static的嵌套类简称为静态嵌套类。非静态嵌套类称为内部类。

使用封闭的类名访问静态嵌套类：

OuterClass.StaticNestedClass

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

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

作为内部类实例的对象存在于外部类的实例中。请考虑以下类：

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

InnerClass的实例只能存在于OuterClass的实例中，并且可以直接访问其封闭实例的方法和字段。

要实例化内部类，必须首先实例化外部类。然后，使用以下语法在外部对象中创建内部对象：

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

请参阅：Java Tutorial - Nested Classes

为了完整性，请注意还有inner class without an enclosing instance：

这样的事情

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

此处，new A() { ... }是在静态上下文中定义的内部类，并且没有封闭的实例。

Answer 2

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

首先让条款正确：

嵌套类是一个类，它包含在源代码级别的另一个类中。
如果使用静态修饰符声明它，则为静态。
非静态嵌套类称为内部类。（我留在非静态嵌套类中。）

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

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

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

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.this访问Container的封闭实例。

以下更多核心解释：

如果你看一下编译器为（非静态）嵌套类生成的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 <init>(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.<init>() : 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)

为了完整起见：

匿名类是非静态嵌套类的完美示例，它没有与之关联的名称，以后也无法引用。

Answer 3

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

概述

嵌套类可以是非静态的或静态的，并且在每种情况下是在另一个类中定义的类。 嵌套类应仅存在于包含类，如果嵌套类对其他类（不仅是封闭的）有用，则应声明为顶级类。

差分

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

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

结论

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

Answer 4

简单来说，我们需要嵌套类，主要是因为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仅与{{1}相关}}。内部课程进入了画面。

要创建内部类的实例，您需要创建外部类的实例。

Class A

或

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

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

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

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

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

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

Answer 5

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

希望它有所帮助！

内部课程

可以访问外部类实例和静态方法和字段
与封闭类的实例相关联所以要实例化它首先需要一个外部类的实例（注意 new 关键字的地方）：
```
Outerclass.InnerClass innerObject = outerObject.new Innerclass();
```
无法定义任何静态成员本身
无法拥有类或接口声明

静态嵌套类

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

与封闭类的任何实例无关因此要实例化它：

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

相似性

内部课程都可以访问外部课程的私有字段和方法
此外，外部课程可以访问内部课程的私有字段和方法
这两个类都可以拥有私有，受保护或公共访问修饰符

为什么要使用嵌套类？

根据Oracle文档，有几个原因（full documentation）：

这是一种逻辑分组仅在一个地方使用的类的方法：如果一个类只对另一个类有用，那么将它嵌入该类是合乎逻辑的把两者放在一起。嵌套这样的＆＃34;助手类＆＃34;使他们的包更加简化。



它增加了封装：考虑两个顶级类A和B，其中B需要访问A的成员，否则这些成员将被声明为私有。通过将B类隐藏在A类中，可以将A＆＃39的成员声明为私有，B可以访问它们。此外，B本身可以隐藏在外面世界。



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

Answer 6

我认为，通常遵循的惯例是：

静态类是嵌套类
非静态类是内部类，进一步还有两种形式：
- 本地类 - 在方块或构造函数体内的块内声明的命名类
- 匿名类 - 在表达式和语句中创建实例的未命名类

但是，很少有其他要记住的要点：

顶级类和静态嵌套类在语义上是相同的，除非在静态嵌套类的情况下，它可以对其外部[parent]类的私有静态字段/方法进行静态引用，反之亦然。
内部类可以访问Outer [parent]类的封闭实例的实例变量。但是，并非所有内部类都包含实例，例如静态上下文中的内部类，如静态初始化程序块中使用的匿名类，不会。
默认情况下，匿名类扩展父类或实现父接口，并且没有其他子句可以扩展任何其他类或实现更多接口。所以，
- new YourClass(){};表示class [Anonymous] extends YourClass {}
- new YourInterface(){};表示class [Anonymous] implements YourInterface {}

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

Answer 7

嵌套类：类

中的类

类型：

静态嵌套类
非静态嵌套类[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);

Answer 8

在创建外部类的实例时创建内部类的实例。因此，内部类的成员和方法可以访问外部类的实例（对象）的成员和方法。当外部类的实例超出范围时，内部类实例也不再存在。

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

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

Answer 9

关于使用嵌套静态类的细微之处可能在某些情况下很有用。

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

考虑这个例子：

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中看到的。

Answer 10

我不认为这里有很多内容，大多数答案完美地解释了静态嵌套类和内部类之间的区别。但是，在使用嵌套类与内部类时请考虑以下问题。正如在几个答案中提到的那样，内部类不能在没有封闭类的实例的情况下实例化，这意味着它们 HOLD 一个指针到它们的封闭类的实例，它可以导致内存溢出或堆栈溢出异常，因为即使不再使用GC，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;的评论，该程序将会输出＆＃34; 我被摧毁了！＆＃34;，但保留此评论它不会。
原因是仍然引用了白色内部实例GC无法收集它，并且因为它引用（有一个指针）外部实例它也没有被收集。在项目中有足够的这些对象，可能会耗尽内存与不支持内部类实例的静态内部类相比，因为它与实例无关但与类相关。上述程序可以打印＆＃34; 我被销毁了！＆＃34;如果使Inner类静态并使用Outer.Inner i = new Outer.Inner();

进行实例化

Answer 11

在创建实例的情况下，非实例静态内部类是使用引用创建的定义它的外部类的对象。这个意味着它有实例。但是静态内部类的实例是使用外类的引用创建的，而不是外类对象的借鉴。这意味着它没有透露实例。

例如：

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

Answer 12

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

public class Outer {
    public class Inner {}

    public static class Nested {}
}

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

Answer 13

嵌套类是一个非常通用的术语：每个不是顶级的类都是嵌套类。内部类是非静态嵌套类。约瑟夫达西写了一篇关于Nested, Inner, Member, and Top-Level Classes的非常好的解释。

Answer 14

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

嵌套类可以是：
1.静态嵌套类。
2.非静态嵌套类。（也称为内部课程）=＆gt;请记住这一点

1.内部课程
例如：

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

内部类是嵌套类的子集：

内部类是嵌套类的特定类型
内部类是嵌套类的子集
您可以说内部类也是嵌套类，但您可以 NOT 说嵌套类也是内部类。

内班专业：

内部类的实例具有访问外部类成员的所有，甚至是那些标记为“私有”的成员

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中内部类和静态嵌套类之间的主要区别是什么？ 答案：只是详细介绍了上面提到的每个课程。

Answer 15

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

编辑：如果你实际上是指内部与匿名......内部类只是在类中定义的类，例如：

public class A {
    public class B {
    }
}

而匿名类是匿名定义的类的扩展，因此没有定义实际的“类”，如：

public class A {
}

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

进一步编辑：

Java中的维基百科claims there is a difference，但我已经使用Java工作了8年，这是我第一次听到这样的区别......更不用说那里没有提及支持声明了。 ..底线，内部类是在类中定义的类（静态或非静态），嵌套只是另一个术语，意思相同。

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

Answer 16

Java中的

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

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中的嵌套静态类？

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

1）它可以访问外部类的静态数据成员，包括私有 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");
        }
    }
}

参考：Inner class and nested Static Class in Java with Example

Answer 17

我认为这里的人应该注意到海报：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 !!!

 }

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

Answer 18

以下是static nested class和inner class的示例：

<强> OuterClass.java

public class OuterClass {
     private String someVariable = "Non Static";

     private static String anotherStaticVariable = "Static";  

     OuterClass(){

     }

     //Nested classes are static
     static class StaticNestedClass{
        private static String privateStaticNestedClassVariable = "Private Static Nested Class Variable"; 

        //can access private variables declared in the outer class
        public static void getPrivateVariableofOuterClass(){
            System.out.println(anotherStaticVariable);
        }
     }

     //non static
     class InnerClass{

         //can access private variables of outer class
         public String getPrivateNonStaticVariableOfOuterClass(){
             return someVariable;
         }
     }

     public static void accessStaticClass(){
         //can access any variable declared inside the Static Nested Class 
         //even if it private
         String var = OuterClass.StaticNestedClass.privateStaticNestedClassVariable; 
         System.out.println(var);
     }

}

<强> OuterClassTest：

public class OuterClassTest {
    public static void main(String[] args) {

        //access the Static Nested Class
        OuterClass.StaticNestedClass.getPrivateVariableofOuterClass();

        //test the private variable declared inside the static nested class
        OuterClass.accessStaticClass();
        /*
         * Inner Class Test
         * */

        //Declaration

        //first instantiate the outer class
        OuterClass outerClass = new OuterClass();

        //then instantiate the inner class
        OuterClass.InnerClass innerClassExample =  outerClass. new InnerClass();

        //test the non static private variable
        System.out.println(innerClassExample.getPrivateNonStaticVariableOfOuterClass()); 

    }

}

Answer 19

我认为以上答案均未为您提供真实的示例，这说明了在应用程序设计方面嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。

让我们看一下以下两个示例。

静态嵌套类：使用静态嵌套类的一个很好的例子是构建器模式（https://dzone.com/articles/design-patterns-the-builder-pattern）。

对于BankAccount，我们使用静态的嵌套类，主要是因为

静态嵌套类实例可以在外部类之前创建。
在构建器模式中，构建器是用于创建BankAccount的帮助程序类。
BankAccount.Builder仅与BankAccount关联。没有其他类与BankAccount.Builder相关。因此最好不使用名称约定将它们组织在一起。

public class BankAccount {

    private long accountNumber;
    private String owner;
    ...

    public static class Builder {

    private long accountNumber;
    private String owner;
    ...

    static public Builder(long accountNumber) {
        this.accountNumber = accountNumber;
    }

    public Builder withOwner(String owner){
        this.owner = owner;
        return this; 
    }

    ...
    public BankAccount build(){
            BankAccount account = new BankAccount(); 
            account.accountNumber = this.accountNumber;
            account.owner = this.owner;
            ...
            return account;
        }
    }
}

内部类：内部类的常见用法是定义事件处理程序。 https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html

对于MyClass，我们使用内部类，主要是因为：

内部类MyAdapter需要访问外部类成员。
在此示例中，MyAdapter仅与MyClass关联。没有其他类与MyAdapter相关。因此最好不使用名称约定将它们组织在一起

public class MyClass extends Applet {
    ...
        someObject.addMouseListener(new MyAdapter());
    ...
    class MyAdapter extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {
            ...// Event listener implementation goes here...
            ...// change some outer class instance property depend on the event
        }
    }
}

Answer 20

首先没有这样的类叫做静态类。静态修饰符用于内部类（称为嵌套类）表示它是外部类的静态成员，这意味着我们可以像使用其他静态成员一样访问它没有任何外类实例。（这最初是静电的好处。）

使用嵌套类和常规Inner类之间的区别是：

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

首先我们可以实例化Outerclass然后我们可以访问Inner。

但是如果Class是嵌套的，那么语法是：

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

使用静态语法作为静态关键字的正常实现。

Answer 21

Java编程语言允许您在另一个类中定义一个类。这样的类称为嵌套类，并在此处进行说明：

SELECT userdata.*, (select sum(expense) from expense where expense.user_id=userdata.id) as expense FROM `userdata`

嵌套类分为两类：静态和非静态。声明为静态的嵌套类称为静态嵌套类。非静态嵌套类称为内部类。我们应该记住的一件事是，非静态嵌套类（内部类）可以访问封闭类的其他成员，即使它们被声明为私有的也是如此。如果静态嵌套类是静态的，则它们只能访问封闭类的其他成员。它不能访问外部类的非静态成员。与类方法和变量一样，静态嵌套类与其外部类相关联。例如，要为静态嵌套类创建一个对象，请使用以下语法：

class OuterClass {
...
class NestedClass {
    ...
    }
}

要实例化内部类，必须首先实例化外部类。然后，使用以下语法在外部对象内创建内部对象：

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

为什么我们使用嵌套类

这是一种对仅在一个地方使用的类进行逻辑分组的方法。
它增加了封装。
这可能会导致代码更具可读性和可维护性。

来源：The Java™ Tutorials - Nested Classes

Answer 22

图

static nested和non-static nested类之间的差异

非静态嵌套类（内部类）可以访问其外部类的所有成员（静态和非静态变量和方法，包括私有的），并且可以像其他非静态成员一样直接引用它们外来阶级的人。

了解更多here

Answer 23

图

和non-static nested类之间的主要区别是static nested无法访问非静态外部类成员

Answer 24

除了已经提到的那些之外，嵌套类的另一个用例是嵌套类具有只能从外部类访问的方法。这是可能的，因为外部类可以访问嵌套类的私有构造函数、字段和方法。

在下面的例子中，Bank 可以发出一个 Bank.CreditCard，它有一个私有的构造函数，并且可以根据当前的银行政策使用私有的 setLimit(...) Bank.CreditCard 的实例方法。（在这种情况下，对实例变量 limit 的直接字段访问也适用）。从任何其他类只能访问 Bank.CreditCard 的公共方法。

public class Bank {

    // maximum limit as per current bank policy
    // is subject to change
    private int maxLimit = 7000;

    // ------- PUBLIC METHODS ---------

    public CreditCard issueCard(
            final String firstName,
            final String lastName
    ) {
        final String number = this.generateNumber();
        final int expiryDate = this.generateExpiryDate();
        final int CVV = this.generateCVV();
        return new CreditCard(firstName, lastName, number, expiryDate, CVV);
    }


    public boolean setLimit(
            final CreditCard creditCard,
            final int limit
    ) {
        if (limit <= this.maxLimit) {    // check against current bank policy limit
            creditCard.setLimit(limit);  // access private method Bank.CreditCard.setLimit(int)
            return true;
        }
        return false;
    }

    // ------- PRIVATE METHODS ---------

    private String generateNumber() {
        return "1234-5678-9101-1123";   // the numbers should be unique for each card
    }


    private int generateExpiryDate() {
        return 202405;                  // date is YYYY=2024, MM=05
    }


    private int generateCVV() {
        return 123;                     // is in real-life less predictable
    }


    // ------- PUBLIC STATIC NESTED CLASS ---------

    public static final class CreditCard {
        private final String firstName;
        private final String lastName;
        private final String number;
        private final int expiryDate;
        private final int CVV;

        private int balance;
        private int limit = 100; // default limit

        // the constructor is final but is accessible from outer class
        private CreditCard(
                final String firstName,
                final String lastName,
                final String number,
                final int expiryDate,
                final int CVV
        ) {
            this.firstName = firstName;
            this.lastName = lastName;
            this.number = number;
            this.expiryDate = expiryDate;
            this.CVV = CVV;
        }

        // ------- PUBLIC METHODS ---------

        public String getFirstName() {
            return this.firstName;
        }

        public String getLastName() {
            return this.lastName;
        }

        public String getNumber() {
            return this.number;
        }

        public int getExpiryDate() {
            return this.expiryDate;
        }

        // returns true if financial transaction is successful
        // otherwise false
        public boolean charge(final int amount) {
            final int newBalance = this.balance - amount;
            if (newBalance < -this.limit) {
                return false;
            }
            this.balance = newBalance;
            return true;
        }

        // ------- PRIVATE METHODS ---------

        private int getCVV() {
            return this.CVV;
        }

        private int getBalance() {
            return this.balance;
        }

        private void setBalance(final int balance) {
            this.balance = balance;
        }

        private int getLimit() {
            return limit;
        }

        private void setLimit(final int limit) {
            this.limit = limit;
        }
    }
}

Answer 25

不同之处在于，静态的嵌套类声明可以在封闭类之外实例化。

当你有一个不静态的嵌套类声明（也称为内部类）时，除了通过封闭类之外，Java不允许你实例化它。从内部类创建的对象链接到从外部类创建的对象，因此内部类可以引用外部类的字段。

但是如果它是静态的，那么链接就不存在了，外部字段不能被访问（除了通过像任何其他对象那样的普通引用），因此你可以自己实例化嵌套类。

Answer 26

比较静态本地类和非静态内部类非常简单
差异：
静态本地类：
只能访问外部类的静态成员。
不能有静态初始化器
不能直接从声明其的函数外部访问

Answer 27

我已经说明了在java代码中可能出现的各种可能的纠正和错误情况。

    class Outter1 {

        String OutStr;

        Outter1(String str) {
            OutStr = str;
        }

        public void NonStaticMethod(String st)  {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            //  below static attribute not permitted
            // static String tempStatic1 = "static";    

            //  below static with final attribute not permitted         
            // static final String  tempStatic1 = "ashish";  

            // synchronized keyword is not permitted below          
            class localInnerNonStatic1 {            

                synchronized    public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /* 
        //  static method with final not permitted
          public static void innerStaticMethod(String str11) { 

                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }                            

        }

        public static  void StaticMethod(String st)     {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            // static attribute not permitted below
            //static String tempStatic1 = "static";     

            //  static with final attribute not permitted below
            // static final String  tempStatic1 = "ashish";                         

            class localInnerNonStatic1 {
                public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /*
    // static method with final not permitted
    public static void innerStaticMethod(String str11) {  
                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }    

        }

        // synchronized keyword is not permitted
        static  class inner1 {          

            static String  temp1 = "ashish";
            String  tempNonStatic = "ashish";
            // class localInner1 {

            public void innerMethod(String str11) {
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            public static void innerStaticMethod(String str11) {
                //  error in below step
                str11 = temp1 +" india";    
                //str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }
            //}
        }

        //synchronized keyword is not permitted below
        class innerNonStatic1 {             

//This is important we have to keep final with static modifier in non
// static innerclass below
            static final String  temp1 = "ashish";  
            String  tempNonStatic = "ashish";
            // class localInner1 {

            synchronized    public void innerMethod(String str11) {
                tempNonStatic = tempNonStatic +" ...";
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            /*
            //  error in below step
            public static void innerStaticMethod(String str11) {   
                            //  error in below step
                            // str11 = tempNonStatic +" india";                     
                            str11 = temp1 +" india";
                            System.out.println("innerMethod ===> "+str11);
                        }*/
                    //}
                }
    }

Java内部类和静态嵌套类

28 个答案:

概述

差分

结论

内部课程

静态嵌套类

相似性

为什么要使用嵌套类？