Java内部类案例分析

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 内部类的案例。内部类能够提供更好的封装和组织代码的能力，在某些场景下非常有用。