Java中内部类和静态嵌套类的主要区别是什么？设计/实现是否在选择其中一个方面发挥作用？
当前回答
我认为上面的答案都没有给你一个真正的例子，说明在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。
让我们看看下面的两个例子。
静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(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
}
}
}
其他回答
我认为上面的答案都没有给你一个真正的例子，说明在应用程序设计方面，嵌套类和静态嵌套类之间的区别。静态嵌套类和内部类之间的主要区别是访问外部类实例字段的能力。
让我们看看下面的两个例子。
静态嵌套类：使用静态嵌套类的一个好例子是生成器模式(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
}
}
}
A图表
静态嵌套类和非静态嵌套类之间的主要区别在于，静态嵌套类不能访问非静态外部类成员
嵌套类：类内的类
类型：
静态嵌套类非静态嵌套类[内部类]
差异：
非静态嵌套类[内部类]
在非静态嵌套类中，内部类的对象存在于外部类的对象中。因此，内部类可以访问外部类的数据成员。所以要创建内部类的对象，我们必须首先创建外部类的对象。
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);
嵌套类的另一个用例，除了已经提到的那些用例之外，是当嵌套类具有只能从外部类访问的方法时。这是可能的，因为外部类可以访问嵌套类的私有构造函数、字段和方法。
在下面的示例中，银行可以发行具有私有构造函数的Bank.CreditCard，并可以使用Bank.credit card的私有setLimit（…）实例方法根据当前银行策略更改信用卡的限额。从任何其他类只能访问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;
}
}
}
Java中的内部类和嵌套静态类都是在另一个类中声明的类，在Java中称为顶级类。在Java术语中，如果您将嵌套类声明为静态的，则在Java中将其称为嵌套静态类，而非静态嵌套类则简称为内部类。
什么是Java中的内部类？
任何不是顶级或在另一个类中声明的类都称为嵌套类，在这些嵌套类中，声明为非静态的类在Java中称为内部类。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） 它可以访问外部类（包括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中的内部类和嵌套静态类及其示例
推荐文章
- Intellij IDEA Java类在保存时不能自动编译
- 何时使用Mockito.verify()?
- 在maven中安装mvn到底做什么
- 不可变与不可修改的集合
- 如何在JSON中使用杰克逊更改字段名
- GSON -日期格式
- 如何从线程捕获异常
- 无法解析主机"<URL here>"没有与主机名关联的地址
- 如何在Java中打印二叉树图?
- String.format()在Java中格式化双重格式
- com.jcraft.jsch.JSchException： UnknownHostKey
- Java中的操作符重载
- 如何加速gwt编译器?
- 在Hibernate中重新连接分离对象的正确方法是什么?
- 应该……接住环内还是环外?
