Java中内部类和静态嵌套类的主要区别是什么?设计/实现是否在选择其中一个方面发挥作用?
当前回答
嵌套类的另一个用例,除了已经提到的那些用例之外,是当嵌套类具有只能从外部类访问的方法时。这是可能的,因为外部类可以访问嵌套类的私有构造函数、字段和方法。
在下面的示例中,银行可以发行具有私有构造函数的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;
}
}
}
其他回答
A图表
静态嵌套类和非静态嵌套类之间的主要区别在于,静态嵌套类不能访问非静态外部类成员
首先,没有这样的类称为静态类。与内部类一起使用的静态修饰符(称为嵌套类)表示它是外部类的静态成员,这意味着我们可以像其他静态成员一样访问它,而不需要外部类的任何实例。(这本来就是静态的好处。)
使用嵌套类和常规内部类之间的区别是:
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
首先我们可以实例化Outerclass,然后我们可以访问Inner。
但如果类是嵌套的,则语法为:
OuterClass.InnerClass inner = new OuterClass.InnerClass();
它使用静态语法作为静态关键字的正常实现。
这些术语可以互换使用。如果你真的想变得迂腐,那么你可以定义“嵌套类”来引用一个静态的内部类,这个类没有封闭的实例。在代码中,您可能有如下内容:
public class Outer {
public class Inner {}
public static class Nested {}
}
但这并不是一个被广泛接受的定义。
不同之处在于,同样是静态的嵌套类声明可以在封闭类之外实例化。
当您有一个非静态的嵌套类声明(也称为内部类)时,Java不允许您实例化它,除非通过封闭类。从内部类创建的对象链接到从外部类创建的目标,因此内部类可以引用外部类的字段。
但是如果它是静态的,那么链接就不存在,外部字段就不能被访问(除非像其他对象一样通过普通引用),因此您可以自己实例化嵌套类。
Java教程说:
术语:嵌套类是分为两类:静态并且是非静态的。嵌套的类被声明为静态的静态嵌套类。非静态嵌套类称为内部类类。
一般来说,术语“嵌套”和“内部”被大多数程序员互换使用,但我将使用正确的术语“嵌套类”,它涵盖内部和静态。
类可以无限嵌套,例如类A可以包含B类,B类包含C类,C类包含D类等。但是,很少有一个以上的类嵌套,因为这通常是错误的设计。
创建嵌套类有三个原因:
组织:有时将一个类分类到另一个类的命名空间中似乎是最明智的,尤其是当它不会在任何其他上下文中使用时访问:嵌套类具有对其包含类的变量/字段的特殊访问权限(确切地说,哪些变量/字段取决于嵌套类的类型,无论是内部的还是静态的)。方便:必须为每个新类型创建一个新文件,这同样令人烦恼,尤其是当该类型只在一个上下文中使用时
Java中有四种嵌套类。简而言之,它们是:
静态类:声明为另一个类的静态成员内部类:声明为另一个类的实例成员本地内部类:在另一个类的实例方法中声明匿名内部类:类似于本地内部类,但作为返回一次性对象的表达式编写
让我详细说明一下。
静态类
静态类最容易理解,因为它们与包含类的实例无关。
静态类是声明为另一个类的静态成员的类。就像其他静态成员一样,这样的类实际上只是一个使用包含类作为其名称空间的挂接器,例如,pizza包中声明为Rhino类静态成员的Goat类被称为pizza.Hino.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.Hino.Goat来限定,但在包含类内部,可以通过其简单名称来限定。然而,内部类的每个实例都与其包含类的一个特定实例相关联:上面,在jerry中创建的Goat被隐式地绑定到Rhino实例,这是在jerrry中创建的。否则,当我们实例化Goat时,我们将显式显示关联的Rhino实例:
Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();
(注意,你在奇怪的新语法中将内部类型称为Goat:Java从rhino部分推断出包含类型。是的,new rhino.Goat()对我来说也更有意义。)
那么这给我们带来了什么?内部类实例可以访问包含类实例的实例成员。这些封闭实例成员仅通过其简单名称在内部类中引用,而不是通过this(内部类中的this引用内部类实例,而不是关联的包含类实例):
public class Rhino {
private String barry;
public class Goat {
public void colin() {
System.out.println(barry);
}
}
}
在内部类中,您可以将包含类的this引用为Rhino.this,也可以使用它来引用其成员,例如Rhino.tis.barry。
本地内部类
本地内部类是在方法体中声明的类。这样的类只在其包含方法中是已知的,因此只能在其包含的方法中实例化并访问其成员。这样做的好处是,本地内部类实例绑定到并可以访问其包含方法的最终本地变量。当实例使用其包含方法的最终局部变量时,即使变量已超出范围(这实际上是Java的粗糙、有限版本的闭包),该变量仍保留其在创建实例时所保持的值。
因为本地内部类既不是类或包的成员,所以它没有用访问级别声明。(但是,要清楚,它自己的成员拥有与普通类一样的访问级别。)
如果在实例方法中声明了本地内部类,则在创建实例时,内部类的实例化与包含方法的this所持有的实例相关联,因此包含类的实例成员可以像在实例内部类中一样访问。本地内部类仅通过其名称实例化,例如,本地内部类Cat被实例化为new Cat(),而不是您可能期望的new this.Cat()。
匿名内部类
匿名内部类是编写本地内部类的语法上方便的方法。最常见的情况是,本地内部类在每次运行其包含方法时最多实例化一次。那么,如果我们能够将本地内部类定义及其单个实例化组合成一种方便的语法形式,这将是很好的,如果我们不必为类想出一个名称(代码中包含的无用名称越少越好),这也是很好的。匿名内部类同时允许以下两种功能:
new *ParentClassName*(*constructorArgs*) {*members*}
这是一个返回扩展ParentClassName的未命名类的新实例的表达式。您不能提供自己的构造函数;相反,一个是隐式提供的,它只是调用超级构造函数,因此提供的参数必须适合超级构造函数。(如果父级包含多个构造函数,则称为“最简单”的构造函数,由一组相当复杂的规则决定,不值得详细学习——只需注意NetBeans或Eclipse告诉您的内容。)
或者,您可以指定要实现的接口:
new *InterfaceName*() {*members*}
这样的声明创建了一个未命名类的新实例,该类扩展了Object并实现了InterfaceName。同样,您不能提供自己的构造函数;在本例中,Java隐式地提供了一个无参数、不做任何事情的构造函数(因此在本例中将不会有构造函数参数)。
即使您不能给匿名内部类一个构造函数,您仍然可以使用初始值设定项块(放置在任何方法外部的{}块)进行任何设置。
请注意,匿名内部类只是用一个实例创建本地内部类的一种不太灵活的方式。如果您想要一个实现多个接口的本地内部类,或者在扩展除Object之外的某个类时实现接口,或者指定自己的构造函数,那么您只能创建一个常规的命名本地内部类。
推荐文章
- 套接字的连接超时和读超时之间的区别是什么?
- Java整数到字节数组
- 如何设置Windows环境下Java的环境变量
- Java Swing revalidate() vs repaint()
- Java中文件中的行数
- 指定的子节点已经有一个父节点。你必须先在子对象的父对象上调用removeView() (Android)
- 对于一个布尔字段,它的getter/setter的命名约定是什么?
- 如何获得当前屏幕方向?
- 如何在Android中渲染PDF文件
- 如何计算一个元素在列表中出现的次数
- c++中类似于java的instanceof
- 我如何解决错误“minCompileSdk(31)指定在一个依赖的AAR元数据”在本机Java或Kotlin?
- 如何POST表单数据与Spring RestTemplate?
- Mockito中检测到未完成的存根
- 我应该如何复制字符串在Java?