静态内部类案例

本文目录导读：

1. 基础案例：经典的单例模式
2. 实际应用：实现链表的 Node 类
3. 实际应用：计算器中的运算单元
4. 实际应用：构建者模式
5. 实际应用：数据结构的 Pair 类
6. 静态内部类的主要优点

我来为你展示一个完整的静态内部类案例,包含实际应用场景。

基础案例：经典的单例模式

public class Singleton {
    // 私有构造函数
    private Singleton() {
        System.out.println("Singleton 实例被创建");
    }
    // 静态内部类（饿汉式单例的优化版）
    private static class SingletonHolder {
        // 静态常量，类加载时初始化
        private static final Singleton INSTANCE = new Singleton();
    }
    // 对外提供获取实例的方法
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
    public static void main(String[] args) {
        // 测试单例模式
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println("s1 == s2 ? " + (s1 == s2)); // true
        s1.showMessage();
    }
}

实际应用：实现链表的 Node 类

public class LinkedList {
    // 静态内部类 - 链表节点
    private static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
    private Node head;
    private int size;
    public LinkedList() {
        head = null;
        size = 0;
    }
    // 添加元素
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
        size++;
    }
    // 移除元素
    public boolean remove(int data) {
        if (head == null) return false;
        if (head.data == data) {
            head = head.next;
            size--;
            return true;
        }
        Node current = head;
        while (current.next != null) {
            if (current.next.data == data) {
                current.next = current.next.next;
                size--;
                return true;
            }
            current = current.next;
        }
        return false;
    }
    // 遍历打印
    public void display() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    public int getSize() {
        return size;
    }
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        System.out.println("链表元素:");
        list.display(); // 10 20 30 40
        list.remove(20);
        System.out.println("删除20后:");
        list.display(); // 10 30 40
        System.out.println("链表大小: " + list.getSize()); // 3
    }
}

实际应用：计算器中的运算单元

import java.util.ArrayList;
import java.util.List;
public class Calculator {
    // 静态内部类 - 运算结果
    public static class Result {
        private final double value;
        private final String expression;
        public Result(double value, String expression) {
            this.value = value;
            this.expression = expression;
        }
        public double getValue() {
            return value;
        }
        public String getExpression() {
            return expression;
        }
        @Override
        public String toString() {
            return expression + " = " + value;
        }
    }
    // 静态内部类 - 历史记录
    private static class History {
        private final List<Result> records = new ArrayList<>();
        public void add(Result result) {
            records.add(result);
        }
        public void clear() {
            records.clear();
        }
        public List<Result> getRecords() {
            return new ArrayList<>(records);
        }
        public Result getLast() {
            if (records.isEmpty()) {
                return null;
            }
            return records.get(records.size() - 1);
        }
        public int size() {
            return records.size();
        }
    }
    private final History history;
    public Calculator() {
        this.history = new History();
    }
    // 加法
    public Result add(double a, double b) {
        Result result = new Result(a + b, a + " + " + b);
        history.add(result);
        return result;
    }
    // 减法
    public Result subtract(double a, double b) {
        Result result = new Result(a - b, a + " - " + b);
        history.add(result);
        return result;
    }
    // 乘法
    public Result multiply(double a, double b) {
        Result result = new Result(a * b, a + " × " + b);
        history.add(result);
        return result;
    }
    // 除法
    public Result divide(double a, double b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为0");
        }
        Result result = new Result(a / b, a + " ÷ " + b);
        history.add(result);
        return result;
    }
    // 显示历史记录
    public void showHistory() {
        System.out.println("=== 计算历史 ===");
        for (Result r : history.getRecords()) {
            System.out.println(r);
        }
        System.out.println("===============");
    }
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        // 使用静态内部类 Result
        Calculator.Result r1 = calc.add(10, 5);
        Calculator.Result r2 = calc.subtract(10, 3);
        Calculator.Result r3 = calc.multiply(4, 6);
        Calculator.Result r4 = calc.divide(20, 4);
        System.out.println("最新结果: " + r1);
        System.out.println("所有结果: " + r2);
        System.out.println("乘法结果: " + r3);
        System.out.println("除法结果: " + r4);
        // 显示计算历史
        calc.showHistory();
        // 直接访问静态内部类（不需要外部类实例）
        Calculator.Result standalone = new Calculator.Result(42, "6 × 7");
        System.out.println("独立结果: " + standalone);
    }
}

实际应用：构建者模式

public class Person {
    // 必填字段
    private final String name;
    private final int age;
    // 可选字段
    private final String email;
    private final String phone;
    private final String address;
    // 私有构造函数，接收 Builder
    private Person(Builder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.email = builder.email;
        this.phone = builder.phone;
        this.address = builder.address;
    }
    // 静态内部类 - Builder
    public static class Builder {
        // 必填字段
        private final String name;
        private final int age;
        // 可选字段（带默认值）
        private String email = "";
        private String phone = "";
        private String address = "";
        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }
        public Builder address(String address) {
            this.address = address;
            return this;
        }
        public Person build() {
            return new Person(this);
        }
    }
    // getter 方法
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
    public String getPhone() { return phone; }
    public String getAddress() { return address; }
    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", email='" + email + '\'' +
               ", phone='" + phone + '\'' +
               ", address='" + address + '\'' +
               '}';
    }
    public static void main(String[] args) {
        // 使用 Builder 创建对象
        Person person1 = new Person.Builder("张三", 25)
                .email("zhangsan@example.com")
                .phone("138-0000-0000")
                .build();
        Person person2 = new Person.Builder("李四", 30)
                .email("lisi@example.com")
                .address("北京市海淀区")
                .build();
        Person person3 = new Person.Builder("王五", 28).build();
        System.out.println(person1);
        System.out.println(person2);
        System.out.println(person3);
    }
}

实际应用：数据结构的 Pair 类

public class PairExample {
    // 静态内部类 - 通用的键值对
    public static class Pair<K, V> {
        private final K key;
        private final V value;
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
        public K getKey() { return key; }
        public V getValue() { return value; }
        @Override
        public String toString() {
            return "(" + key + ", " + value + ")";
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Pair<?, ?> pair = (Pair<?, ?>) obj;
            return key.equals(pair.key) && value.equals(pair.value);
        }
        @Override
        public int hashCode() {
            return key.hashCode() * 31 + value.hashCode();
        }
    }
    public static void main(String[] args) {
        // 创建各种类型的 Pair
        Pair<String, Integer> pair1 = new Pair<>("年龄", 25);
        Pair<String, String> pair2 = new Pair<>("城市", "上海");
        Pair<Integer, String> pair3 = new Pair<>(1, "第一名");
        System.out.println("Pair1: " + pair1);
        System.out.println("Pair2: " + pair2);
        System.out.println("Pair3: " + pair3);
        // 创建集合存放多个 Pair
        List<Pair<String, Integer>> scores = new ArrayList<>();
        scores.add(new Pair<>("张三", 90));
        scores.add(new Pair<>("李四", 85));
        scores.add(new Pair<>("王五", 92));
        System.out.println("\n学生成绩: ");
        for (Pair<String, Integer> score : scores) {
            System.out.println(score.getKey() + ": " + score.getValue() + "分");
        }
    }
}

静态内部类的主要优点

1. 不用依赖外部类的实例：可以独立创建使用
2. 更好的封装性：将相关的类组织在一起
3. 节省内存：相比非静态内部类，不会隐式持有外部类的引用
4. 实现单例模式的安全方式：如案例1所示
5. 代码组织更清晰：Builder 模式

• 🔹 单例模式：使用静态内部类实现懒加载且线程安全的单例
• 🔹 数据结构辅助类：如链表的 Node 节点
• 🔹 构建者模式：Builder 内部类
• 🔹 工具类分组：将相关的辅助类放在一起
• 🔹 公共数据结构：如 Pair、Result 等通用数据结构

静态内部类是 Java 中非常实用的特性，合理使用可以让代码更加清晰、高效。