【Java 基础篇】Java内部类：探索内部的世界

繁依Fanyi

发布于 2023-10-12 10:12:22

3730

文章被收录于专栏：繁依Fanyi 的专栏繁依Fanyi 的专栏

导言

在Java中，内部类是一种定义在其他类内部的类。它们允许我们在一个类的内部创建另一个类，从而实现更好的封装和组织代码的能力。本篇博客将围绕Java内部类展开讨论，包括内部类的概念、语法、用法以及内部类在Java编程中的重要性。

一、内部类的概念

内部类是指定义在其他类内部的类。它们被视为外部类的成员，并可以访问外部类的成员变量和方法，包括私有成员。内部类与外部类之间形成了一种特殊的关系，内部类可以直接访问外部类的成员，而外部类需要通过内部类对象来访问内部类的成员。

内部类可以分为四种类型：

成员内部类（Member Inner Class）：定义在外部类的成员位置，与外部类的实例绑定。
静态内部类（Static Inner Class）：定义在外部类的成员位置，但是使用static关键字修饰，与外部类的实例无关。
方法内部类（Method Local Inner Class）：定义在方法内部，只在该方法的作用域内有效。
匿名内部类（Anonymous Inner Class）：没有显式的名称，直接作为方法参数或者赋值给一个变量。

二、内部类的语法

在Java中，内部类的语法格式如下：

public class OuterClass {
    // 外部类的成员变量和方法

    public class InnerClass {
        // 内部类的成员变量和方法
    }

    public static class StaticInnerClass {
        // 静态内部类的成员变量和方法
    }

    public void someMethod() {
        class MethodInnerClass {
            // 方法内部类的成员变量和方法
        }
    }

    public void someOtherMethod() {
        // 匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 实现匿名内部类的方法
            }
        };
    }
}

三、内部类的用法

1. 实现封装和隐藏

内部类可以实现更好的封装和隐藏，将相关的类组织在一起。内部类可以直接访问外部类的成员，包括私有成员，从而实现更细粒度的封装。同时，内部类对外部世界是不可见的，只能在外部类中进行访问，提高了代码的安全性和可读性。

public class ShoppingCart {
    private List<Item> items;

    public void addItem(Item item) {
        items.add(item);
    }

    public void removeItem(Item item) {
        items.remove(item);
    }

    public 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类表示一个购物车，它包含一个Item类作为其成员内部类。Item类封装了商品的名称和价格，只能在ShoppingCart类中进行访问。这样可以更好地组织和封装相关的类，同时隐藏了Item类对外部世界的可见性。

2. 实现接口的适配器模式

内部类可以作为接口的适配器，简化接口的实现过程。接口适配器模式是一种设计模式，它允许我们在一个类中实现多个接口，并提供默认的实现方法。内部类可以作为接口适配器，将接口的实现细节隐藏在内部类中，从而简化了外部类对接口的实现。

public interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class ShapeAdapter {
    public static Shape createRectangle() {
        return new Shape() {
            @Override
            public void draw() {
                System.out.println("Drawing a rectangle.");
            }
        };
    }

    public static Shape createCircle() {
        return new Shape() {
            @Override
            public void draw() {
                System.out.println("Drawing a circle.");
            }
        };
    }
}

在上面的示例中，Shape是一个接口，Rectangle和Circle分别实现了该接口。ShapeAdapter是一个内部类，它提供了创建矩形和圆形的静态方法，并返回实现了Shape接口的内部类对象。这样，外部类可以直接调用ShapeAdapter的静态方法来创建矩形和圆形对象，而无需关注内部类的实现细节。

3. 实现回调函数

内部类可以作为回调函数的实现方式，用于实现异步任务的回调。回调函数是一种常见的编程模式，用于处理异步任务的完成通知和结果返回。内部类作为回调函数可以访问外部类的成员变量和方法，从而实现更灵活和复杂的回调逻辑。

public interface Callback {
    void onTaskCompleted(String result);
}

public class Task {
    public void performAsyncTask(Callback callback) {
        new Thread(() -> {
            // 模拟异步任务
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 完成任务并调用回调函数
            String result = "Task completed.";
            callback.onTaskCompleted(result);


        }).start();
    }
}

public class Main {
    public static void main(String[] args) {
        Task task = new Task();
        task.performAsyncTask(new Callback() {
            @Override
            public void onTaskCompleted(String result) {
                System.out.println("Task result: " + result);
            }
        });
    }
}

在上面的示例中，Task类表示一个异步任务，它的performAsyncTask方法接受一个Callback接口作为参数。在异步任务完成后，通过调用回调函数的onTaskCompleted方法返回任务结果。在Main类中，我们创建了一个Task对象，并通过匿名内部类实现了回调函数的逻辑。当异步任务完成时，回调函数会被调用，并打印任务的结果。