Java内部类的应用分析

3 0 0

最近看了几篇博客，又温习了一次内部类相关的内容，感觉有必要在这方面写点博客记录一下，毕竟我个人接触的也不多，平时写代码也不常用，方便以后再次温习。

啥是内部类呢，简单来说就是写在类里面的类(Inner Class)，也被叫做嵌套类（Nested Class）




class Outer {


    class Inner {


        // 定义了一个Inner Class


    }


}

具体的介绍可以看这里：内部类 – Java教程 – 廖雪峰的官方网站 (liaoxuefeng.com)，我在这里就不多赘述了。

内部类是一个统称，具体的分类有哪些呢？

Java内部类的应用分析

内部类的主要应用

访问外部类的私有成员，类似于写一个getter/setter方法，提供了一个外部管理私有字段的方法。我们来举个例子：




public class Outer {


    private String outerField = "Hello from Outer Class!";


 


    // 成员内部类


    class Inner {


        void displayOuterField() {


            // 内部类访问外部类的私有成员


            System.out.println(outerField);


        }


    }


 


    // 创建内部类的实例并调用其方法


    void createInner() {


        Inner inner = new Inner();


        inner.displayOuterField();


    }


 


    public static void main(String[] args) {


        Outer outer = new Outer();


        outer.createInner();  // 调用外部类的方法


    }


}

封装代码，从第一条就能看出来。简化代码结构，例如想要手动实现一个表，那么这个表的数据结构肯定会占很大篇幅，这时候不妨把代码放到内部类，和其他逻辑区分开。比如我们来写一个图的结构：




import java.util.ArrayList;


import java.util.List;


 


public class Graph {


    // 内部类表示图的顶点


    class Vertex {


        String name;


        List<Vertex> adjacentVertices;


 


        // 构造函数


        Vertex(String name) {


            this.name = name;


            this.adjacentVertices = new ArrayList<>();


        }


 


        // 添加邻接顶点


        void addAdjacent(Vertex vertex) {


            adjacentVertices.add(vertex);


        }


 


        // 打印顶点及其邻接顶点


        void display() {


            System.out.print("Vertex: " + name + " is connected to: ");


            for (Vertex v : adjacentVertices) {


                System.out.print(v.name + " ");


            }


            System.out.println();


        }


    }


 


    private List<Vertex> vertices;


 


    // 构造函数


    public Graph() {


        this.vertices = new ArrayList<>();


    }


 


    // 添加顶点


    public Vertex addVertex(String name) {


        Vertex vertex = new Vertex(name);


        vertices.add(vertex);


        return vertex;


    }


 


    // 打印所有顶点


    public void displayGraph() {


        for (Vertex vertex : vertices) {


            vertex.display();


        }


    }


 


    public static void main(String[] args) {


        Graph graph = new Graph();


        Graph.Vertex v1 = graph.addVertex("A");


        Graph.Vertex v2 = graph.addVertex("B");


        Graph.Vertex v3 = graph.addVertex("C");


 


        // 添加邻接关系


        v1.addAdjacent(v2);


        v1.addAdjacent(v3);


        v2.addAdjacent(v3);


 


        // 打印图的信息


        graph.displayGraph();


    }


}

处理监听事件，这个和c#的事件委托机制很像，例如有了内部类，可以把所有鼠标点击回调的逻辑放到一个内部类里，以后需要添加或修改鼠标点击的逻辑的时候，只需要修改这个内部类就可以了
举个例子：




import javax.swing.JButton;


import javax.swing.JFrame;


 


public class ButtonExample {


    private String buttonLabel = "Click me!";


 


    public ButtonExample() {


        JFrame frame = new JFrame();


        JButton button = new JButton(buttonLabel);


 


        // 成员内部类作为事件监听器


        button.addActionListener(new ButtonClickListener());


 


        frame.add(button);


        frame.setSize(200, 200);


        frame.setVisible(true);


    }


 


    // 内部类


    class ButtonClickListener implements java.awt.event.ActionListener {


        public void actionPerformed(java.awt.event.ActionEvent e) {


            System.out.println("Button clicked! Label: " + buttonLabel);


        }


    }


 


    public static void main(String[] args) {


        new ButtonExample();


    }


}

实现接口，或者多重继承，我们不想让外部访问到我们的实现方式，只需要在私有的内部类里面写接口的实现即可。




// 定义接口


interface Animal {


    void makeSound();  // 声明一个抽象方法


}


 


// 外部类


public class AnimalShelter {


    


    // 成员内部类 Dog


    private class Dog implements Animal {


        @Override


        public void makeSound() {


            System.out.println("Woof!");  // 实现狗叫声


        }


    }


 


    // 成员内部类 Cat


    private class Cat implements Animal {


        @Override


        public void makeSound() {


            System.out.println("Meow!");  // 实现猫叫声


        }


    }


 


    // 方法来创建并使用内部类


    public void adoptAnimals() {


        Animal dog = new Dog();  // 创建 Dog 对象


        Animal cat = new Cat();   // 创建 Cat 对象


 


        dog.makeSound();  // 调用 Dog 的方法


        cat.makeSound();  // 调用 Cat 的方法


    }


 


    public static void main(String[] args) {


        AnimalShelter shelter = new AnimalShelter(); // 创建 AnimalShelter 对象


        shelter.adoptAnimals(); // 调用 adoptAnimals 方法


    }


}

至于静态内部类，大多是在设计模式中应用，例如实现工厂模式中的工厂类：




public class Outer {


    private static int count = 0;


 


    // 静态内部类


    static class Inner {


        private int id;


 


        Inner() {


            this.id = ++count;  // 为每个内部类实例分配一个唯一 ID


        }


 


        public int getId() {


            return id;


        }


    }


 


    public static void main(String[] args) {


        Inner inner1 = new Inner();


        Inner inner2 = new Inner();


 


        System.out.println("Inner 1 ID: " + inner1.getId());  // 输出：Inner 1 ID: 1


        System.out.println("Inner 2 ID: " + inner2.getId());  // 输出：Inner 2 ID: 2


    }


}

方法内部类我用的较少，但是还是举个例子，这是用局部内部类（方法内部类）进行临时算法的封装：




public class Calculator {


    


    public double calculate(int base, int exponent) {


        


        // 局部静态类用于计算幂


        class PowerCalculator {


            double calculatePower() {


                return Math.pow(base, exponent);


            }


        }


        


        PowerCalculator powerCalculator = new PowerCalculator();


        return powerCalculator.calculatePower();  // 调用局部静态类的方法


    }


 


    public static void main(String[] args) {


        Calculator calculator = new Calculator();


        double result = calculator.calculate(2, 3);  // 2的3次方


        System.out.println("Result: " + result);  // 输出：Result: 8.0


    }


}

匿名内部类比较特殊，不需要变量名，创建时自带一个生命周期，在生命周期内自动被调用，也就是说，匿名内部类一般和其他的类或者方法是绑定在一起的，由其他的类或方法来控制其行为。它的应用大概有这些：

事件处理，这里先给出一个例子




import javax.swing.JButton;


import javax.swing.JFrame;


 


public class ButtonExample {


    public static void main(String[] args) {


        JFrame frame = new JFrame("Button Example");


        JButton button = new JButton("Click me!");


 


        // 使用匿名内部类实现 ActionListener


        button.addActionListener(new java.awt.event.ActionListener() {


            @Override


            public void actionPerformed(java.awt.event.ActionEvent e) {


                System.out.println("Button clicked!");


            }


        });


 


        frame.add(button);


        frame.setSize(200, 200);


        frame.setVisible(true);


        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


    }


}

这里和C#的事件委托机制是一样的，只是java有些区别罢了，创建的事件类并没有一个确切的名字，它单纯是和我们的buttonclick绑定在了一起，每次这个按钮被点击，就会激活这个事件，但是具体这个事件较什么名字我们并不清楚，只知道要让这个事件去做一些事，调一些函数。

代码简化




public class AnimalExample {


    public static void main(String[] args) {


        // 使用匿名内部类实现接口


        Animal dog = new Animal() {


            @Override


            public void makeSound() {


                System.out.println("Woof!");


            }


        };


 


        dog.makeSound();  // 输出：Woof!


    }


}

实现比较器，集合排序的时候是需要一个比较器的，也就是我们排序需要一个规则，这和数据库的理论很像，这个时候我们可以用匿名内部类来实现Comparator接口：




import java.util.Arrays;


import java.util.Comparator;


 


public class SortExample {


    public static void main(String[] args) {


        String[] names = {"Alice", "Bob", "Charlie"};


 


        // 使用匿名内部类实现Comparator


        Arrays.sort(names, new Comparator<String>() {


            @Override


            public int compare(String s1, String s2) {


                return s1.length() - s2.length();  // 按字符串长度排序


            }


        });


 


        System.out.println(Arrays.toString(names));  // 输出：[Bob, Alice, Charlie]


    }


}

# 随笔