Java内部类和静态嵌套类

Question

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

Answer 1

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

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

OuterClass.StaticNestedClass

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

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

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

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

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

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

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 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 3

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

例如：

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 4

我不认为这里有很多内容，大多数答案完美地解释了静态嵌套类和内部类之间的区别。但是，在使用嵌套类与内部类时请考虑以下问题。正如在几个答案中提到的那样，内部类不能在没有它们的封闭类的实例化的情况下被实例化，这意味着它们持有指向其封闭类的实例的指针，这可能导致内存溢出或由于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无法收集它，并且因为它引用（有一个指针）外部实例它也没有被收集。在项目中有足够的这些对象，并且可能会耗尽内存。与不与内部类实例有关的静态内部类相比，因为它与实例无关但与类相关。上面的程序可以打印“我被摧毁了！”如果你使内部类静态并使用Outer.Inner i = new Outer.Inner();实例化

Answer 5

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

public class Outer {
    public class Inner {}

    public static class Nested {}
}

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

Answer 6

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

Answer 7

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

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

public class A {
    public class B {
    }
}

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

public class A {
}

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

进一步编辑：

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

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

Answer 8

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

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

1.内部课程例：

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中内部类和静态嵌套类之间的主要区别是什么？答：只需仔细阅读上面提到的每个课程的具体内容。

Answer 9

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

嵌套静态类是另一个类，它在类中声明为成员并且是静态的。嵌套静态类也被声明为外部类的成员，可以像任何其他成员一样使其成为私有，公共或受保护。嵌套静态类相对于内部类的主要好处之一是嵌套静态类的实例未附加到任何外部类的外部实例。您也不需要任何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");
        }
    }
}

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

Answer 10

我想这里的人应该注意到Poster：Static Nested 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 11

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

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

Answer 12

Java tutorial says：

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

一般说来，术语“嵌套”和“内部”可以被大多数程序员互换使用，但我会使用正确的术语“嵌套类”，它涵盖了内部和静态。

类可以无限制地嵌套，例如，类A可以包含类B，其中包含类C，其中包含类D等。但是，类嵌套的级别很少，因为它通常是糟糕的设计。

您可以创建嵌套类有三个原因：

组织：有时将类排序到另一个类的命名空间中是最明智的，特别是当它不会在任何其他上下文中使用时
access：嵌套类具有对其包含类的变量/字段的特殊访问权限（确切地说，哪些变量/字段取决于嵌套类的类型，无论是内部还是静态）。
方便：必须为每个新类型创建一个新文件是麻烦的，特别是当该类型只在一个上下文中使用时

Java中有四种嵌套类。简而言之，它们是：

static class：声明为另一个类的静态成员
内部类：声明为另一个类的实例成员
本地内部类：在另一个类的实例方法中声明
匿名内部类：类似于本地内部类，但写为返回一次性对象的表达式

让我详细说明一下。

静态类

静态类是最容易理解的类，因为它们与包含类的实例无关。

静态类是声明为另一个类的静态成员的类。就像其他静态成员一样，这样的类实际上只是一个使用包含类作为其命名空间的挂钩，例如在包披萨中声明为类Rhino的静态成员的类Goat名为pizza.Rhino.Goat。

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

坦率地说，静态类是一个非常没用的功能，因为类已经被包分成了命名空间。创建静态类的唯一真正可能的原因是这样的类可以访问其包含类的私有静态成员，但我发现这是静态类特性存在的一个相当蹩脚的理由。

内在的类

内部类是声明为另一个类的非静态成员的类：

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

与静态类一样，内部类被称为包含类名称pizza.Rhino.Goat的限定类，但在包含类中，它可以通过其简单名称来识别。但是，内部类的每个实例都绑定到其包含类的特定实例：上面，在jerry中创建的Goat隐含地绑定到jerry中的Rhino实例。否则，我们在实例化Goat时使关联的Rhino实例显式化：

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

（注意你用奇怪的新语法将内部类型称为Goat：Java从rhino部分推断出包含类型。而且，新的rhino.Goat（）对我来说也更有意义。）

那么这对我们有什么影响呢？好吧，内部类实例可以访问包含类实例的实例成员。这些封闭的实例成员仅通过它们的简单名称引用到内部类中，而不是通过它（这在内部类中引用内部类实例，而不是关联的包含类实例）：

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

在内部类中，您可以将包含类的内容称为Rhino.this，并且可以使用它来引用其成员，例如Rhino.this.barry。

本地内部类

本地内部类是在方法体中声明的类。这样的类只在其包含方法中是已知的，因此它只能被实例化并在其包含方法中访问其成员。增益是本地内部类实例绑定并可以访问其包含方法的最终局部变量。当实例使用其包含方法的final local时，该变量将保留实例创建时保留的值，即使该变量已超出范围（这实际上是Java的粗略，有限版本的闭包）。

由于本地内部类既不是类或包的成员，也不会使用访问级别声明它。（但要明确的是，它自己的成员具有像普通类一样的访问级别。）

如果在实例方法中声明了本地内部类，则在创建实例时，内部类的实例化与包含该方法的实例相关联，因此包含类的实例成员可以像在实例中一样访问内心阶级。仅通过其名称来实例化本地内部类，例如，本地内部类Cat被实例化为新的Cat（），而不是你想象的新的this.Cat（）。

匿名内部类

匿名内部类是编写本地内部类的语法上方便的方法。最常见的是，每次运行包含方法时，本地内部类最多只被实例化一次。那么，如果我们可以将本地内部类定义和它的单个实例化组合成一个方便的语法形式，那将是很好的，如果我们不必为该类想出一个名称也会很好（无用的更少）你的代码包含的名称越多越好。匿名内部类允许这两件事：

new *ParentClassName*(*constructorArgs*) {*members*}

这是一个返回未命名类的新实例的表达式，该实例扩展了ParentClassName。你不能提供自己的构造函数;相反，一个是隐式提供的，它只是调用超级构造函数，因此提供的参数必须适合超级构造函数。（如果父级包含多个构造函数，则称为“最简单”的构造函数，“最简单”，由一组相当复杂的规则确定，不值得详细学习 - 只需注意NetBeans或Eclipse告诉您的内容。）

或者，您可以指定要实现的接口：

new *InterfaceName*() {*members*}

这样的声明创建了一个未命名类的新实例，它扩展了Object并实现了InterfaceName。同样，你不能提供自己的构造函数;在这种情况下，Java隐式地提供了一个no-arg，do-nothing构造函数（因此在这种情况下永远不会有构造函数参数）。

即使你不能给匿名内部类一个构造函数，你仍然可以使用初始化块（在任何方法之外放置一个{}块）进行任何你想要的设置。

要明确的是，匿名内部类只是一种使用一个实例创建本地内部类的灵活性较低的方法。如果你想要一个实现多个接口的本地内部类，或者在扩展某个类而不是Object或者指定自己的构造函数的情况下实现接口，那么你就会陷入创建常规命名的本地内部类的困境。

Answer 13

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

outer class.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 14

我认为上述答案都没有给出真实的例子，在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。

我们来看看以下两个例子。

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

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

可以在外部类之前创建静态嵌套类实例。
在构建器模式中，构建器是一个帮助程序类，用于创建BankAccount。
Bank Account.Builder仅与银行帐户相关联。没有其他类与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 15

图

static nested和non-static nested类之间的区别

静态嵌套类不能直接访问封闭类的其他成员（非静态变量和方法），因为它是静态的，它必须通过对象访问其封闭类的非静态成员。也就是说，它不能直接引用其封闭类的非静态成员。由于这种限制，很少使用静态嵌套类。
非静态嵌套类（内部类）可以访问其外部类的所有成员（静态和非静态变量和方法，包括私有），并且可以直接以与外部其他非静态成员相同的方式引用它们上课。

阅读更多here

Answer 16

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

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

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

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

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

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

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

Answer 17

Java编程语言允许您在另一个类中定义类。这样的类称为嵌套类，如下所示：

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

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

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

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

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

为什么我们使用嵌套类

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

资料来源：The Java™ Tutorials - Nested Classes

Answer 18

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

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

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

Answer 19

我已经说明了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);
                        }*/
                    //}
                }
    }

Answer 20

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

首先要使条款正确：

嵌套类是一个类，它包含在源代码级别的另一个类中。
如果使用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.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 21

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

概观

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

区别

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

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

结论

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

Answer 22

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

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

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

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

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

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

Answer 23

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

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

但是，要记住的其他几点是：

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

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

Answer 24

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

希望能帮助到你！

Inner class

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

Static nested class

无法访问外部类实例方法或字段
与封闭类的任何实例都没有关联，以便实例化它： OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Similarities

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

Why Use Nested Classes?

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

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

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

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

Answer 25

嵌套类：类内部的类

类型：

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

Answer 26

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

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

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

Java内部类和静态嵌套类

问题描述投票：1621回答：25

25个回答

静态类

内在的类

本地内部类

匿名内部类

概观

区别

结论

Inner class

Static nested class

Similarities

Why Use Nested Classes?

最新问题

Java内部类和静态嵌套类

问题描述 投票：1621回答：25

25个回答

静态类

内在的类

本地内部类

匿名内部类

概观

区别

结论

Inner class

Static nested class

Similarities

Why Use Nested Classes?

最新问题

问题描述投票：1621回答：25