Java内部类

Java的各种内部类介绍

在Java中，内部类是定义在另一个类内部的类。内部类可以访问外部类的成员，包括私有成员，而外部类也可以访问内部类的成员。内部类提供了一种更好的封装和组织代码的方式。

有四种类型的内部类：成员内部类、局部内部类、匿名内部类和静态嵌套类。

1. 成员内部类（Member Inner Class）：

• 成员内部类是定义在另一个类内部的普通类。
• 可以访问外部类的成员，包括私有成员。
• 通常使用外部类的实例创建内部类的实例。

```java
public class OuterClass {
    private int outerVar;

    public class InnerClass {
        public void accessOuterVar() {
            System.out.println(outerVar);
        }
    }
}
```

2. 局部内部类（Local Inner Class）：

• 局部内部类是定义在方法或作用域内的类。
• 只能在声明它的方法或作用域内访问。
• 可以访问外部类的成员，包括私有成员。

```java
public class OuterClass {
    public void outerMethod() {
        int outerVar = 10;

        class LocalInnerClass {
            public void accessOuterVar() {
                System.out.println(outerVar);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.accessOuterVar();
    }
}
```

3. 匿名内部类（Anonymous Inner Class）：

• 匿名内部类是没有名字的局部内部类，通常用于创建接口的实例。
• 不能有显式的构造函数。
• 可以实现接口或继承抽象类。

```java
public interface MyInterface {
    void myMethod();
}

public class OuterClass {
    public MyInterface getMyInterfaceInstance() {
        return new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Anonymous Inner Class method");
            }
        };
    }
}
```

4.静态嵌套类（Static Nested Class）：

• 静态嵌套类是定义在另一个类内部的静态类。
• 只能访问外部类的静态成员。
• 不依赖于外部类的实例，可以直接通过外部类的类名访问。

```java
public class OuterClass {
    private static int staticVar;

    public static class StaticNestedClass {
        public void accessStaticVar() {
            System.out.println(staticVar);
        }
    }
}
```

这些内部类的选择取决于不同的设计需求。

成员内部类通常用于与外部类有紧密联系的情况，而局部内部类和匿名内部类通常用于较短寿命的需求，例如实现某个接口的一次性类。

静态嵌套类通常用于与外部类的实例无关的独立功能。

内部类典型的用法和设计

当涉及到内部类时，有一些典型的用例和设计模式。

1. 事件监听器： 内部类常用于实现事件监听器。例如，一个按钮类可能包含一个内部类，该内部类实现了按钮点击的事件监听器接口。

   public class Button {
       public interface OnClickListener {
           void onClick();
       }
   
       private OnClickListener onClickListener;
   
       public void setOnClickListener(OnClickListener listener) {
           this.onClickListener = listener;
       }
   
       // 内部类实现事件监听器
       public class ClickListener implements OnClickListener {
           @Override
           public void onClick() {
               // 处理按钮点击事件的逻辑
           }
       }
   }
   

2. 迭代器模式： 内部类可以用于实现迭代器模式，特别是在集合类中。内部类可以轻松访问外部类的私有成员。

   public class MyCollection<T> {
       private List<T> elements = new ArrayList<>();
   
       // 内部类实现迭代器
       public class MyIterator implements Iterator<T> {
           private int index = 0;
   
           @Override
           public boolean hasNext() {
               return index < elements.size();
           }
   
           @Override
           public T next() {
               return elements.get(index++);
           }
       }
   }
   

3. 工厂模式： 内部类可以用于实现工厂模式，其中工厂类的内部类负责创建特定类型的对象。

   public class ShapeFactory {
       // 内部类实现具体形状的工厂
       public class CircleFactory {
           public Circle createCircle() {
               return new Circle();
           }
       }
   
       // 内部类实现具体形状的工厂
       public class SquareFactory {
           public Square createSquare() {
               return new Square();
           }
       }
   }
   

4. Builder模式： 内部类可以用于实现Builder模式，其中内部类负责构建外部类的实例。

   public class Car {
       private String brand;
       private String model;
       // 其他属性...
   
       // 内部类实现Builder
       public static class Builder {
           private Car car;
   
           public Builder() {
               car = new Car();
           }
   
           public Builder setBrand(String brand) {
               car.brand = brand;
               return this;
           }
   
           public Builder setModel(String model) {
               car.model = model;
               return this;
           }
   
           // 其他设置方法...
   
           public Car build() {
               return car;
           }
       }
   }