Java 中不同类型的类详解

---

一、基础类类型

1. 普通类（Concrete Class）

• 定义：使用 class 声明，可直接实例化的类。

• 特点：

  • 包含属性、方法、构造方法。
  • 默认可被继承（除非用 final 修饰）。

• 示例：

  public class Animal {
      private String name;
      public Animal(String name) { this.name = name; }
      public void eat() { System.out.println(name + " is eating."); }
  }
  

• 场景：具体业务逻辑的实现。

---

2. 抽象类（Abstract Class）

• 定义：用 abstract 修饰，不可直接实例化。
• 特点：
  • 可包含抽象方法（无实现）和具体方法。
  • 子类必须实现所有抽象方法（除非子类也是抽象类）。
• 示例：

  public abstract class Shape {
      public abstract double calculateArea();
      public void printInfo() { System.out.println("This is a shape."); }
  }
  

• 场景：定义通用模板，强制子类实现特定逻辑。

---

3. 接口（Interface）

• 定义：用 interface 声明，定义行为规范。
• 特点：
  • Java 8+ 支持默认方法（default）、静态方法（static）。
  • Java 9+ 支持私有方法。
  • 类通过 implements 实现接口（支持多继承）。
• 示例：

  public interface Drawable {
      void draw();
      default void setColor(String color) { System.out.println("Color: " + color); }
  }
  

• 场景：多继承行为规范（如 Comparable、Runnable）。

---

4. 枚举类（Enum Class）

• 定义：用 enum 声明，表示固定常量集合。
• 特点：
  • 每个常量是枚举类的实例。
  • 可包含属性、方法、构造方法（必须 private）。
• 示例：

  public enum Day {
      MONDAY("星期一"), TUESDAY("星期二");
      private String chineseName;
      private Day(String name) { this.chineseName = name; }
      public String getChineseName() { return chineseName; }
  }
  

• 场景：状态、类型等固定常量定义。

---

二、嵌套类与特殊类

5. 内部类（Inner Class）

• 定义：定义在另一个类内部的类，分为四种类型：
  • 成员内部类（非静态）：

    public class Outer {
        private int value = 10;
        public class Inner { public void printValue() { System.out.println(value); } }
    }
    

  • 静态内部类：

    public class Outer {
        private static int count = 5;
        public static class StaticInner { public void printCount() { System.out.println(count); } }
    }
    

  • 局部内部类（定义在方法内）：

    public void someMethod() {
        class LocalClass { /* ... */ }
    }
    

  • 匿名内部类（无类名，直接实现接口或继承类）：

    Runnable task = new Runnable() { @Override public void run() { System.out.println("Running!"); } };
    

• 场景：封装仅外部类使用的逻辑，或简化回调。

---

6. 单例类（Singleton Class）

• 定义：确保全局唯一实例的类。
• 实现方式：
  • 私有构造方法 + 静态实例 + 静态获取方法。
  • 枚举实现（推荐，线程安全且防反射）。
• 示例：

  public class Singleton {
      private static Singleton instance;
      private Singleton() {}
      public static synchronized Singleton getInstance() {
          if (instance == null) { instance = new Singleton(); }
          return instance;
      }
  }
  

• 场景：配置管理、数据库连接池等需全局唯一实例的场景。

---

7. 记录类（Record Class）（Java 14+）

• 定义：用 record 声明，不可变数据载体。
• 特点：
  • 自动生成 equals()、hashCode()、toString()。
  • 所有字段默认为 final。
• 示例：

  public record Person(String name, int age) {}
  

• 场景：简化 DTO（数据传输对象）、不可变数据模型。

---

三、高级类与设计模式相关类

8. 密封类（Sealed Class）（Java 17+）

• 定义：用 sealed 声明，限制继承范围。
• 特点：
  • 使用 permits 指定允许的子类。
  • 子类必须为 final、sealed 或 non-sealed。
• 示例：

  public abstract sealed class Shape permits Circle, Square {}
  public final class Circle extends Shape {}
  public non-sealed class Square extends Shape {}
  

• 场景：固定类型层次结构（如表达式树节点）。

---

9. 功能接口（Functional Interface）

• 定义：用 @FunctionalInterface 标记的接口，仅含一个抽象方法。
• 特点：
  • 支持 Lambda 表达式和方法引用。
  • 可包含默认方法和静态方法。
• 示例：

  @FunctionalInterface
  public interface Calculator { int calculate(int a, int b); }
  Calculator add = (a, b) -> a + b;
  

• 场景：函数式编程（如 Runnable、Comparator）。

---

10. 工具类（Utility Class）

• 定义：通过私有构造方法 + 静态方法实现。
• 特点：
  • 禁止实例化（私有构造方法）。
  • 所有方法为 static，无状态。
• 示例：

  public final class StringUtils {
      private StringUtils() {}
      public static boolean isEmpty(String str) { return str == null || str.trim().isEmpty(); }
  }
  

• 场景：通用工具方法（如 Math、Collections）。

---

11. 不可变类（Immutable Class）

• 定义：对象状态创建后不可修改。
• 实现：
  • 所有字段 private final。
  • 不提供 setter，返回深拷贝对象。
• 示例：

  public final class ImmutablePoint {
      private final int x, y;
      public ImmutablePoint(int x, int y) { this.x = x; this.y = y; }
      public int getX() { return x; }
      public int getY() { return y; }
  }
  

• 场景：线程安全数据对象（如 String、LocalDate）。

---

12. 代理类（Proxy Class）

• 定义：通过 Proxy 动态生成的类，拦截方法调用。
• 特点：
  • 基于接口动态创建。
  • 常用于 AOP（日志、事务管理）。
• 示例：

  Service proxy = (Service) Proxy.newProxyInstance(
      Service.class.getClassLoader(),
      new Class[] { Service.class },
      (proxy, method, args) -> {
          System.out.println("Before method");
          return method.invoke(target, args);
      }
  );
  

• 场景：动态代理、远程方法调用（RMI）。

---

四、其他重要概念

13. POJO/Java Bean

• 定义：普通类的子集，用于数据模型。
• 特点：
  • 包含无参构造方法 + getter/setter。
  • 无业务逻辑，仅用于数据传输。
• 示例：

  public class User {
      private String name;
      public User() {}
      public String getName() { return name; }
      public void setName(String name) { this.name = name; }
  }
  

---

14. 注解类型（Annotation Type）

• 定义：用 @interface 声明，标记元数据。
• 示例：

  public @interface MyAnnotation {
      String value() default "";
      int priority() default 0;
  }
  

• 场景：框架标记（如 @Override、@SpringBootApplication）。

---

总结表格：类类型对比

类型	核心特点	典型应用场景
普通类	直接实例化，完整实现	具体业务逻辑
抽象类	部分实现，强制子类扩展	通用模板设计
接口	多继承行为规范，支持默认方法	跨类共享行为（如排序、线程）
枚举类	固定常量集合，实例化控制	状态、类型定义
内部类	封装外部类相关逻辑	回调、事件处理
单例类	全局唯一实例	资源管理（如配置、连接池）
记录类（Java 14+）	不可变数据载体，自动生成方法	DTO、简化数据模型
密封类（Java 17+）	限制继承范围	固定类型层次结构
功能接口	单一抽象方法，支持 Lambda	函数式编程
工具类	静态方法集合，禁止实例化	通用工具方法
不可变类	线程安全，状态不可变	共享数据对象
代理类	动态生成，拦截方法调用	AOP、远程调用

---