Java内部类,也称为嵌套类,是指在一个类内部定义的类。内部类可以访问外部类的所有成员,包括私有成员。同时,外部类也可以访问内部类的所有成员。内部类主要有以下几种类型:静态内部类、实例内部类、局部内部类和匿名内部类。
1. 静态内部类(Static Nested Class):
静态内部类使用static修饰符定义。它可以访问外部类的所有静态成员,但不能直接访问外部类的非静态成员。静态内部类通常用于创建属于外部类的静态成员对象。
示例:
public class OuterClass {
private static int outerStaticField = 10;
private int outerField = 20;
static class StaticInnerClass {
public void printFields() {
System.out.println("Outer static field: " + OuterClass.outerStaticField);
// System.out.println("Outer field: " + outerField); // 错误,无法访问非静态成员
}
}
}
2. 实例内部类(Instance Inner Class):
实例内部类不使用static修饰符定义。它拥有对外部类实例的引用,可以访问外部类的所有成员。实例内部类通常用于创建属于外部类实例的非静态成员对象。
示例:
public class OuterClass {
private int outerField = 20;
class InnerClass {
public void printField() {
System.out.println("Outer field: " + outerField);
}
}
}
3. 局部内部类(Local Inner Class):
局部内部类定义在方法、作用域或匿名方法中。它们只能访问方法中声明的final变量。局部内部类主要用于创建仅在方法内部使用的类。
示例:
public class OuterClass {
private int outerField = 20;
public void method() {
final int localVariable = 30;
class LocalInnerClass {
public void printField() {
System.out.println("Outer field: " + outerField);
System.out.println("Local variable: " + localVariable);
}
}
LocalInnerClass localInnerObject = new LocalInnerClass();
localInnerObject.printField();
}
}
4. 匿名内部类(Anonymous Inner Class):
匿名内部类是一个没有名称的内部类,它直接实现接口或继承类。匿名内部类主要用于创建只需要使用一次的类。
示例:
public class OuterClass {
private int outerField = 20;
public void method() {
new Object() {
public void printField() {
System.out.println("Outer field: " + outerField);
}
}.printField();
}
}
作用:
内部类提供了一种在类中定义新类的机制,使得代码组织更加清晰,提高了代码的可读性和可维护性。同时,内部类可以访问外部类的所有成员,有利于封装和信息隐藏。
下面分析实例更好理解 内部类。
实例分析:
假设我们正在构建一个电子商务平台,其中包含商品和购物车两个类。为了方便起见,我们希望在购物车类中实现一个内部类来表示购物车中的商品条目。以下是示例代码:
public class ShoppingCart {
private List<Item> itemList;
public ShoppingCart() {
itemList = new ArrayList<>();
}
public void addItem(String name, double price) {
Item item = new Item(name, price);
itemList.add(item);
}
public void displayItems() {
for (Item item : itemList) {
System.out.println(item.getName() + ": $" + item.getPrice());
}
}
// 内部类 Item
private class Item {
private String name;
private double price;
public Item(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
}
在这个例子中,我们首先定义了一个外部类 ShoppingCart,它代表着购物车。购物车内部有一个私有的 itemList 列表,用于存储购物车中的商品条目。
然后,在 ShoppingCart 类的内部,我们定义了一个私有的内部类 Item。这个内部类代表着购物车中的商品条目。它有自己的成员变量 name 和 price,并提供了 getter 方法来获取商品名称和价格。
在 ShoppingCart 类的 addItem 方法中,我们创建了一个 Item 对象,并将其添加到 itemList 中。在 displayItems 方法中,我们遍历 itemList,并打印出每个商品条目的名称和价格。
使用内部类的好处之一是它们可以直接访问外部类(购物车)的私有成员。在内部类 Item 的构造方法中,我们可以直接访问外部类的 itemList 变量,并且在 addItem 方法中也可以直接使用内部类 Item。
下面是使用内部类的示例代码:
public class Main {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();
cart.addItem("Item 1", 10.99);
cart.addItem("Item 2", 19.99);
cart.addItem("Item 3", 5.99);
cart.displayItems();
}
}
在主程序中,我们创建了一个 ShoppingCart 对象,并通过 addItem 方法向购物车中添加了三个商品条目。然后,我们调用 displayItems 方法来显示购物车中的所有商品。
输出结果:
Item 1: $10.99
Item 2: $19.99
Item 3: $5.99
可以看到,内部类 Item 能够轻松地访问外部类 ShoppingCart 的私有成员 itemList,并且购物车类的使用更加灵活和方便。
这就是一个简单的 Java 内部类的案例。内部类能够提供更好的封装和组织代码的能力,在某些场景下非常有用。