在 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 模式中,内部类可以帮助我们更方便地创建对象,并且可以保证对象在构造过程中不可变。例如:
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 模式中,内部类可以帮助我们更方便地创建对象,并且可以保证对象在构造过程中不可变,同时也方便了我们的创建过程。内部类的使用可以提高代码的可读性和可维护性,值得我们在开发中多加尝试。