Java的内部类

内部类的概念

在 Java 中，内部类是定义在另一个类或者方法的内部的类。内部类可以访问外部类的所有成员和方法，同时可以被外部类和其他类所访问。内部类可以分为四种类型：静态内部类、成员内部类、局部内部类和匿名内部类。

静态内部类

静态内部类是被声明为静态的内部类，它可以访问其外部类的静态成员，但不能访问其外部类的非静态成员。在声明静态内部类时，需要加上 static 关键字，例如：

class Outer {
    static class Inner {
        public void hello() {
            System.out.println("Hello from Inner class");
        }
    }
}

在上面的例子中，我们声明了一个静态内部类 Inner，并定义了一个方法 hello。

静态内部类可以通过其外部类的名字来访问，例如：

Outer.Inner inner = new Outer.Inner();
inner.hello();

在上面的例子中，我们通过 Outer.Inner 来访问内部类，并调用它的方法 hello。

成员内部类

成员内部类是被声明在外部类的成员位置上的类。与静态内部类不同的是，它可以访问外部类的所有成员，包括非静态成员和静态成员。成员内部类需要在外部类的方法中进行实例化，例如：

class Outer {
    private int x = 10;

    class Inner {
        public void hello() {
            System.out.println("Hello from Inner class, x is " + x);
        }
    }
}

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.hello();

在上面的例子中，我们声明了一个成员内部类 Inner，它可以访问外部类的属性 x。通过调用 outer.new Inner() 来进行实例化。

局部内部类

局部内部类是被声明在方法内部的类。局部内部类可以访问外部类的成员和方法，但只能在声明它的方法中使用。例如：

public class Outer {
    private int x = 10;

    public void test() {
        class Inner {
            public void hello() {
                System.out.println("Hello from Inner class, x is " + x);
            }
        }
        Inner inner = new Inner();
        inner.hello();
    }
}

Outer outer = new Outer();
outer.test();

在上面的例子中，我们声明了一个局部内部类 Inner，并访问了外部类的属性 x。在 test 方法中，创建了一个 Inner 的实例来调用它的方法 hello。

匿名内部类

匿名内部类是没有名字的内部类，它通常用于创建只需要使用一次的类。匿名内部类需要继承一个父类或者实现一个接口，同时也可以访问其外部类的成员和方法。例如：

public class Outer {
    interface Inner {
        void hello();
    }

    public void test() {
        Inner inner = new Inner() {
            @Override
            public void hello() {
                System.out.println("Hello from anonymous Inner class");
            }
        };
        inner.hello();
    }
}

Outer outer = new Outer();
outer.test();

在上面的例子中，我们定义了一个接口 Inner，并在 test 方法中创建了一个匿名内部类来实现它的方法。

内部类在 Builder 模式中的使用

在 Builder 模式中，内部类可以帮助我们更方便地创建对象，并且可以保证对象在构造过程中不可变。例如：

public class Person {
    private final String firstName;
    private final String lastName;
    private final int age;
    private final String gender;
    private final String phone;

    private Person(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.gender = builder.gender;
        this.phone = builder.phone;
    }

    public static class Builder {
        private String firstName;
        private String lastName;
        private int age;
        private String gender;
        private String phone;

        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder gender(String gender) {
            this.gender = gender;
            return this;
        }

        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }
}

在上面的例子中，我们定义了一个 Person 类，它的属性可以通过 Builder 模式来设置。在 Builder 类中，每个属性都对应一个方法来设置。最后，通过 build 方法来构造 Person 对象。由于 Builder 类是 Person 类的静态内部类，因此只能通过 Person.Builder 来访问它。这样可以保证 Person 对象在构造过程中是不可变的，同时也方便了我们的创建过程。

下面是一个使用 Builder 模式构造 Person 对象的例子：

Person person = new Person.Builder()
                .firstName("John")
                .lastName("Doe")
                .age(30)
                .gender("Male")
                .phone("1234567890")
                .build();

总结

内部类是一种定义在另一个类或方法内部的类，它可以访问外部类的所有成员和方法。Java 中有四种类型的内部类：静态内部类、成员内部类、局部内部类和匿名内部类。不同类型的内部类有不同的特点和用途。在 Builder 模式中，内部类可以帮助我们更方便地创建对象，并且可以保证对象在构造过程中不可变，同时也方便了我们的创建过程。内部类的使用可以提高代码的可读性和可维护性，值得我们在开发中多加尝试。