Java中内部类和静态嵌套类的主要区别是什么？设计/实现是否在选择其中一个方面发挥作用？
当前回答
我认为在上述答案中，真正的区别并不明显。
首先要正确使用条款：
嵌套类是包含在源代码级别的另一个类中的类。如果使用static修饰符声明它，则它是静态的。非静态嵌套类称为内部类。（我使用非静态嵌套类。）
到目前为止，马丁的回答是正确的。然而，实际的问题是：声明一个嵌套类静态或不静态的目的是什么？
如果您只想将类保持在一起（如果它们在主题上属于一起），或者如果嵌套类只在封闭类中使用，则可以使用静态嵌套类。静态嵌套类和其他类之间没有语义差异。
非静态嵌套类是另一种野兽。与匿名内部类类似，此类嵌套类实际上是闭包。这意味着它们捕获其周围范围和封闭实例，并使其可访问。也许一个例子可以说明这一点。查看容器的存根：
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访问容器的封闭实例。
更多核心解释如下：
如果您查看编译器为（非静态）嵌套类生成的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)
为完整起见：
匿名类是一个非静态嵌套类的完美例子，它只是没有与之关联的名称，以后无法引用。
其他回答
我认为在上述答案中，真正的区别并不明显。
首先要正确使用条款：
嵌套类是包含在源代码级别的另一个类中的类。如果使用static修饰符声明它，则它是静态的。非静态嵌套类称为内部类。（我使用非静态嵌套类。）
到目前为止，马丁的回答是正确的。然而，实际的问题是：声明一个嵌套类静态或不静态的目的是什么？
如果您只想将类保持在一起（如果它们在主题上属于一起），或者如果嵌套类只在封闭类中使用，则可以使用静态嵌套类。静态嵌套类和其他类之间没有语义差异。
非静态嵌套类是另一种野兽。与匿名内部类类似，此类嵌套类实际上是闭包。这意味着它们捕获其周围范围和封闭实例，并使其可访问。也许一个例子可以说明这一点。查看容器的存根：
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访问容器的封闭实例。
更多核心解释如下：
如果您查看编译器为（非静态）嵌套类生成的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)
为完整起见：
匿名类是一个非静态嵌套类的完美例子，它只是没有与之关联的名称，以后无法引用。
我认为上面的答案都没有给你一个真正的例子，说明在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。
让我们看看下面的两个例子。
静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(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
}
}
}
我认为这里的人应该注意到海报：静态嵌套类只是第一个内部类。例如：
public static class A {} //ERROR
public class A {
public class B {
public static class C {} //ERROR
}
}
public class A {
public static class B {} //COMPILE !!!
}
所以，总结一下，静态类并不取决于它包含的类。所以，他们不能在正常班级上课。（因为普通类需要一个实例）。
不同之处在于，同样是静态的嵌套类声明可以在封闭类之外实例化。
当您有一个非静态的嵌套类声明（也称为内部类）时，Java不允许您实例化它，除非通过封闭类。从内部类创建的对象链接到从外部类创建的目标，因此内部类可以引用外部类的字段。
但是如果它是静态的，那么链接就不存在，外部字段就不能被访问（除非像其他对象一样通过普通引用），因此您可以自己实例化嵌套类。
从Java教程：
嵌套类分为两类：静态类和非静态类。声明为静态的嵌套类简单地称为静态嵌套类。非静态嵌套类称为内部类。
使用封闭类名访问静态嵌套类：
OuterClass.StaticNestedClass
例如，要为静态嵌套类创建对象，请使用以下语法：
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
作为内部类实例的对象存在于外部类的实例中。考虑以下类别：
class OuterClass {
...
class InnerClass {
...
}
}
InnerClass实例只能存在于OuterClass实例中，并且可以直接访问其封闭实例的方法和字段。
要实例化内部类，必须首先实例化外部类。然后，使用以下语法在外部对象中创建内部对象：
OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
请参见：Java教程-嵌套类
为了完整性，请注意还有这样一种东西，即没有封闭实例的内部类：
class A {
int t() { return 1; }
static A a = new A() { int t() { return 2; } };
}
这里，new A（）｛…｝是在静态上下文中定义的内部类，没有封闭实例。
推荐文章
- 在Java中使用UUID的最重要位的碰撞可能性
- 转换列表的最佳方法:map还是foreach?
- 如何分割逗号分隔的字符串?
- Java字符串—查看字符串是否只包含数字而不包含字母
- Mockito.any()传递带有泛型的接口
- 在IntelliJ 10.5中运行测试时，出现“NoSuchMethodError: org.hamcrest. matcher . descripbemismatch”
- 使用String.split()和多个分隔符
- Java数组有最大大小吗?
- 在Android中将字符串转换为Uri
- 从JSON生成Java类?
- 为什么java.util.Set没有get(int index)?
- Swing和AWT的区别是什么?
- 为什么Java流是一次性的?
- 四舍五入BigDecimal *总是*有两位小数点后
- 设计模式:工厂vs工厂方法vs抽象工厂
