Java类与对象：核心概念与设计实践

1. Java类与对象基础概念

在Java编程中，类和对象是最核心的两个概念。简单来说，类就像是一个蓝图或模具，而对象则是根据这个蓝图创建出来的具体实例。举个例子，如果把"汽车"看作一个类，那么"一辆红色的宝马X5"就是这个类的一个具体对象。

1.1 类的本质特征

类作为面向对象编程的基本单元，具有以下关键特征：

1. 抽象性：类是对现实世界中一组具有相同特征和行为的事物的抽象描述。比如"学生"类抽象了所有学生的共同特征（姓名、学号等）和行为（学习、考试等）。

2. 封装性：类将数据（属性）和对数据的操作（方法）封装在一起，对外只暴露必要的接口。这就像汽车的仪表盘，驾驶员不需要知道发动机如何工作，只需要知道如何操作方向盘和踏板。

3. 模板作用：类定义了创建对象所需的全部信息，包括：

   • 对象应包含的属性（成员变量）
   • 对象能执行的操作（成员方法）
   • 对象的初始状态（构造方法）

1.2 对象的核心特性

对象作为类的实例，具有以下重要特性：

1. 唯一性：每个对象在内存中都有独立的存储空间，即使属性值完全相同，它们也是不同的对象。就像两辆同型号同颜色的汽车，仍然是两辆不同的车。

2. 状态和行为：

   • 状态由成员变量的当前值决定
   • 行为由成员方法定义

3. 生命周期：

   • 通过new关键字创建
   • 通过垃圾回收机制自动销毁

2. 类的定义详解

2.1 类的基本语法结构

一个完整的Java类定义包含以下几个部分：

java复制[修饰符] class 类名 [extends 父类名] [implements 接口列表] {
    // 成员变量声明
    [修饰符] 数据类型 变量名 [= 初始值];
    
    // 构造方法定义
    [修饰符] 类名([参数列表]) {
        // 构造方法体
    }
    
    // 成员方法定义
    [修饰符] 返回值类型 方法名([参数列表]) [throws 异常列表] {
        // 方法体
    }
}

2.1.1 类定义示例

java复制public class Student {
    // 成员变量
    private String name;
    private int age;
    private static String school = "XX大学";  // 静态变量
    
    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 成员方法
    public void study(String course) {
        System.out.println(name + "正在学习" + course);
    }
    
    // 静态方法
    public static void changeSchool(String newSchool) {
        school = newSchool;
    }
}

2.2 类修饰符深度解析

类的修饰符控制着类的访问权限和特性，主要分为两大类：

2.2.1 访问控制修饰符

重要规则：

• 一个Java源文件只能有一个public类
• public类的名称必须与文件名一致

2.2.2 类型修饰符

组合使用示例：

java复制public final class MathUtils {  // 不可继承的工具类
    // 工具方法...
}

public abstract class Animal {  // 抽象基类
    public abstract void makeSound();
}

2.3 继承与接口实现

2.3.1 继承(extends)

Java采用单继承机制，一个类只能直接继承一个父类：

java复制class Animal {
    protected String name;
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

继承特点：

1. 子类继承父类所有非私有成员
2. 如果没有显式继承，默认继承Object类
3. 构造方法不能被继承

2.3.2 接口实现(implements)

一个类可以实现多个接口：

java复制interface Swimmable {
    void swim();
}

interface Flyable {
    void fly();
}

class Duck implements Swimmable, Flyable {
    @Override
    public void swim() {
        System.out.println("鸭子在游泳");
    }
    
    @Override
    public void fly() {
        System.out.println("鸭子在飞翔");
    }
}

2.4 类体组成要素

2.4.1 成员变量

成员变量声明语法：

java复制[修饰符] 数据类型 变量名 [= 初始值];

成员变量修饰符：

示例：

java复制public class Circle {
    private double radius;          // 私有实例变量
    public static final double PI = 3.14159;  // 公有静态常量
    protected transient int temp;   // 受保护的不序列化变量
}

2.4.2 成员方法

成员方法定义语法：

java复制[修饰符] 返回值类型 方法名([参数列表]) [throws 异常列表] {
    // 方法体
    [return 返回值;]
}

成员方法修饰符：

示例：

java复制public class Calculator {
    // 实例方法
    public int add(int a, int b) {
        return a + b;
    }
    
    // 静态方法
    public static double squareRoot(double num) {
        return Math.sqrt(num);
    }
    
    // 同步方法
    public synchronized void increment() {
        // 线程安全操作
    }
}

3. 对象的创建与使用

3.1 对象创建过程

3.1.1 基本创建语法

java复制类名 引用变量 = new 构造方法([参数]);

示例：

java复制Student stu = new Student("张三", 20);

3.1.2 对象创建的JVM内部过程

1. 类加载检查：检查类是否已加载
2. 内存分配：在堆中分配对象内存空间
3. 初始化零值：为成员变量赋默认值
4. 设置对象头：存储对象的元数据
5. 执行构造方法：进行显式初始化

3.2 成员访问与控制

3.2.1 成员变量访问

java复制对象引用.成员变量名

示例：

java复制Student stu = new Student();
stu.name = "李四";  // 访问公有成员变量

3.2.2 成员方法调用

java复制对象引用.方法名([参数])

示例：

java复制Student stu = new Student();
stu.study("Java编程");  // 调用成员方法

3.3 对象生命周期管理

3.3.1 对象创建时机

• 显式创建：通过new关键字
• 隐式创建：通过反射、反序列化等方式

3.3.2 对象销毁机制

Java采用自动垃圾回收机制管理对象生命周期：

1. 引用计数：记录对象被引用的次数
2. 可达性分析：从GC Roots开始追踪引用链
3. 垃圾回收：回收不可达对象占用的内存

影响对象生命周期的因素：

• 强引用：普通对象引用，会阻止垃圾回收
• 软引用：内存不足时会被回收
• 弱引用：下次GC时会被回收
• 虚引用：无法通过它获取对象，主要用于跟踪对象被回收的状态

4. 对象初始化机制

4.1 初始化方式比较

Java提供了三种对象初始化方式：

4.2 初始化代码块详解

4.2.1 实例初始化块

每次创建对象时都会执行：

java复制class Example {
    private int x;
    
    // 实例初始化块
    {
        x = 10;
        System.out.println("实例初始化块执行");
    }
}

4.2.2 静态初始化块

类加载时执行一次：

java复制class Example {
    static int count;
    
    // 静态初始化块
    static {
        count = 0;
        System.out.println("静态初始化块执行");
    }
}

4.3 构造方法高级特性

4.3.1 构造方法重载

一个类可以有多个构造方法，通过参数列表区分：

java复制public class Point {
    private int x, y;
    
    public Point() {
        this(0, 0);  // 调用另一个构造方法
    }
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

4.3.2 构造方法链

构造方法之间可以相互调用，但必须遵守以下规则：

1. 使用this()调用其他构造方法
2. 必须作为构造方法的第一条语句
3. 不能形成循环调用

5. this关键字深度解析

5.1 this的三种核心用法

5.1.1 区分成员变量和局部变量

java复制public class Student {
    private String name;
    
    public void setName(String name) {
        this.name = name;  // this.name指成员变量，name指参数
    }
}

5.1.2 调用当前对象的其他方法

java复制public class Calculator {
    private int result;
    
    public Calculator add(int value) {
        this.result += value;
        this.displayResult();  // 调用当前对象的方法
        return this;
    }
    
    private void displayResult() {
        System.out.println("当前结果：" + result);
    }
}

5.1.3 调用其他构造方法

java复制public class Rectangle {
    private int width, height;
    
    public Rectangle() {
        this(1, 1);  // 调用两个参数的构造方法
    }
    
    public Rectangle(int side) {
        this(side, side);
    }
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

5.2 this的底层原理

在JVM层面，this实际上是作为方法的第一个隐式参数传递的。例如：

java复制// 源代码
public void setName(String name) {
    this.name = name;
}

// 编译后等价于
public void setName(Student this, String name) {
    this.name = name;
}

这种设计解释了：

1. 为什么实例方法可以直接访问成员变量（实际上是通过隐式的this参数）
2. 为什么静态方法不能使用this（因为没有隐式的this参数传递）
3. 方法调用时如何确定操作的是哪个对象的成员

5.3 常见this使用误区

1. 在静态方法中使用this：

   java复制public static void print() {
       System.out.println(this);  // 编译错误
   }
   

2. 尝试修改this引用：

   java复制public void method() {
       this = new MyClass();  // 编译错误
   }
   

3. 构造方法中循环调用：

   java复制public MyClass() {
       this();  // 编译错误，循环调用
   }
   

6. 面向对象设计实践技巧

6.1 类设计原则

1. 单一职责原则：一个类只负责一个功能领域
2. 开闭原则：对扩展开放，对修改关闭
3. 里氏替换原则：子类可以替换父类
4. 接口隔离原则：使用多个专用接口
5. 依赖倒置原则：依赖抽象而非具体实现

6.2 成员访问控制策略

最佳实践：

• 成员变量尽量私有化，通过方法控制访问
• 只将需要被外部调用的方法设为public
• 谨慎使用protected，避免破坏封装性

6.3 构造方法设计建议

1. 提供无参构造方法：方便框架和工具使用
2. 构造方法应尽量简单：避免复杂逻辑
3. 使用构造方法链：减少代码重复
4. 考虑不可变对象：final字段只能在构造方法中赋值

6.4 对象初始化最佳实践

1. 优先使用构造方法初始化：最灵活可控
2. 初始化块用于复杂初始化逻辑：

   java复制{
       // 从配置文件读取初始值
       Properties props = loadConfig();
       this.timeout = Integer.parseInt(props.getProperty("timeout"));
   }
   

3. 静态final常量使用定义时初始化：

   java复制public static final int MAX_SIZE = 100;
   

4. 避免构造方法中调用可被重写的方法：

   java复制public class Parent {
       public Parent() {
           init();  // 危险！如果子类重写了init()
       }
       
       protected void init() {
           // 初始化代码
       }
   }
   

7. 常见问题与解决方案

7.1 对象创建相关问题

问题1：NullPointerException

java复制Student stu = null;
stu.getName();  // 抛出NullPointerException

解决方案：

• 创建对象后再调用方法
• 进行null检查：

  java复制if (stu != null) {
      stu.getName();
  }
  

问题2：构造方法循环调用

java复制public class Circle {
    public Circle() {
        this(1.0);  // 调用另一个构造方法
    }
    
    public Circle(double radius) {
        this();     // 又调回无参构造，形成循环
        this.radius = radius;
    }
}

解决方案：

• 确保构造方法调用链有明确的终点
• 避免直接或间接的循环调用

7.2 成员访问问题

问题1：访问权限不足

java复制public class Test {
    private int secret;
}

Test t = new Test();
t.secret = 123;  // 编译错误，private成员不能外部访问

解决方案：

• 通过public方法访问私有成员
• 或调整访问修饰符（需谨慎）

问题2：静态成员误用

java复制public class Counter {
    public static int count;
    
    public Counter() {
        count++;
    }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(c1.count);  // 输出2，可能不符合预期

解决方案：

• 明确区分实例成员和静态成员的使用场景
• 实例相关的数据不要使用static修饰

7.3 this关键字常见错误

问题1：静态方法中使用this

java复制public class Util {
    public static void print() {
        System.out.println(this);  // 编译错误
    }
}

解决方案：

• 静态方法没有this引用
• 如果需要访问实例成员，改为实例方法

问题2：构造方法中过早使用this

java复制public class Point {
    private int x, y;
    
    public Point(int x, int y) {
        System.out.println(this);  // 可以使用
        this.x = x;               // 可以使用
        this.y = y;
    }
    
    public Point() {
        this.x = 10;             // 可以使用
        this(0, 0);              // 编译错误，必须作为第一条语句
    }
}

解决方案：

• 确保this()调用是构造方法的第一条语句
• 其他初始化逻辑放在this()调用之后

8. 高级主题与扩展知识

8.1 对象的内存布局

在JVM中，对象在堆内存中的存储布局可分为三个部分：

1. 对象头(Header)：

   • Mark Word：哈希码、GC分代年龄、锁状态等
   • 类型指针：指向类元数据的指针
   • 数组长度（仅数组对象有）

2. 实例数据(Instance Data)：

   • 所有实例字段数据
   • 包括从父类继承的字段

3. 对齐填充(Padding)：

   • 确保对象大小是8字节的整数倍

8.2 方法调用的底层机制

Java方法调用主要分为两种：

1. 解析调用：

   • 静态方法、私有方法、构造方法等
   • 在编译期确定具体调用版本
   • 不涉及多态性

2. 分派调用：

   • 静态分派：重载方法，编译期确定
   • 动态分派：重写方法，运行期确定

虚方法表：JVM通过虚方法表(vtable)实现多态方法调用，每个类都有一个虚方法表，存储了方法的实际入口地址。

8.3 对象克隆与序列化

对象克隆：

java复制public class Person implements Cloneable {
    private String name;
    
    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();  // 不会发生
        }
    }
}

对象序列化：

java复制public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    // 其他字段和方法...
}

// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.dat"))) {
    oos.writeObject(student);
}

// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.dat"))) {
    Student s = (Student) ois.readObject();
}

8.4 记录类(Record) - Java 14+

Java 14引入了记录类(Record)，简化了纯数据载体的类的定义：

java复制public record Point(int x, int y) {
    // 编译器自动生成：
    // 1. final字段x,y
    // 2. 全参数构造方法
    // 3. equals()/hashCode()/toString()
}

// 使用
Point p = new Point(10, 20);
System.out.println(p.x());  // 自动生成的访问方法

记录类适合用于主要目的是保存数据的简单类，不可变且自动实现了很多标准方法。

9. 性能优化建议

9.1 对象创建优化

1. 避免不必要的对象创建：

   java复制// 不好 - 每次调用都创建新对象
   public String createString() {
       return new String("hello");
   }
   
   // 好 - 复用字符串常量
   public String createString() {
       return "hello";
   }
   

2. 使用对象池：对于创建成本高的对象（如数据库连接）

3. 考虑使用不可变对象：减少同步开销

9.2 内存使用优化

1. 及时解除引用：不再使用的对象设为null

   java复制BigObject big = new BigObject();
   // 使用big...
   big = null;  // 帮助GC
   

2. 谨慎使用静态集合：可能导致内存泄漏

3. 优化对象大小：

   • 使用基本类型而非包装类
   • 考虑字段排列顺序（JVM内存对齐）

9.3 方法调用优化

1. 将高频访问的方法设为final：有助于JIT优化

2. 减少虚方法调用：对于性能关键代码

3. 考虑使用方法句柄(MethodHandle)：Java 7+

10. 实际应用案例分析

10.1 电商系统中的用户管理

java复制public class User {
    private final String userId;  // 不可变
    private String username;
    private String email;
    private Address address;  // 复合对象
    
    // 构造方法
    public User(String userId, String username) {
        this.userId = userId;
        this.username = username;
    }
    
    // 业务方法
    public void changeEmail(String newEmail) {
        validateEmail(newEmail);
        this.email = newEmail;
    }
    
    private void validateEmail(String email) {
        // 验证逻辑...
    }
    
    // 嵌套类
    public static class Address {
        private String street;
        private String city;
        // 其他字段和方法...
    }
}

设计要点：

1. 关键ID设为final确保不可变
2. 将地址信息设计为嵌套类
3. 公共方法封装业务逻辑和验证
4. 私有方法辅助实现细节

10.2 游戏开发中的角色系统

java复制public abstract class GameCharacter {
    protected String name;
    protected int health;
    protected Position position;
    
    public GameCharacter(String name, int health) {
        this.name = name;
        this.health = health;
        this.position = new Position(0, 0);
    }
    
    public abstract void attack();
    
    public void move(int dx, int dy) {
        position.x += dx;
        position.y += dy;
        System.out.println(name + "移动到(" + position.x + "," + position.y + ")");
    }
    
    protected static class Position {
        int x, y;
        Position(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

public class Warrior extends GameCharacter {
    public Warrior(String name) {
        super(name, 100);
    }
    
    @Override
    public void attack() {
        System.out.println(name + "使用剑攻击！");
    }
}

设计要点：

1. 抽象基类定义通用属性和行为
2. 具体子类实现特有行为
3. 使用protected控制子类访问
4. 位置信息使用嵌套类封装

10.3 工具类设计示例

java复制public final class StringUtils {
    // 私有构造方法防止实例化
    private StringUtils() {}
    
    // 静态工具方法
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }
    
    public static String reverse(String str) {
        if (str == null) {
            return null;
        }
        return new StringBuilder(str).reverse().toString();
    }
    
    // 更多工具方法...
}

设计要点：

1. final类防止被继承
2. 私有构造方法防止实例化
3. 所有方法都是静态的
4. 完善的null检查

11. 最新语言特性与类设计

11.1 Java 16的记录类(Record)

java复制public record Product(
    String id,
    String name,
    BigDecimal price,
    LocalDate createDate
) {
    // 可以添加自定义方法
    public String displayInfo() {
        return name + " - ￥" + price;
    }
    
    // 可以重写自动生成的方法
    @Override
    public String toString() {
        return "产品[" + id + "]：" + name;
    }
}

特点：

1. 自动生成final字段、全参构造方法
2. 自动实现equals()、hashCode()、toString()
3. 不可变（所有字段都是final）
4. 可以添加自定义方法和重写自动生成的方法

11.2 Java 17的密封类(Sealed Class)

java复制public sealed class Shape 
    permits Circle, Rectangle, Triangle {
    // 基类定义...
}

public final class Circle extends Shape {
    private double radius;
    // 实现...
}

public non-sealed class Rectangle extends Shape {
    private double width, height;
    // 实现...
}

public final class Triangle extends Shape {
    private double a, b, c;
    // 实现...
}

特点：

1. 使用sealed关键字声明密封类
2. 使用permits指定允许的子类
3. 子类必须是final、sealed或non-sealed
4. 提供更安全的继承控制

11.3 Java 21的未命名类和实例main方法

java复制// 未命名类 - 简化小型程序
void main() {
    System.out.println("Hello, Java 21!");
    
    // 未命名模式变量
    var point = new Point(10, 20);
    if (point instanceof Point(var x, _)) {
        System.out.println("x坐标是：" + x);
    }
}

特点：

1. 简化入门程序编写
2. 使用未命名模式变量(_)忽略不需要的部分
3. 保持代码简洁性

12. 最佳实践总结

12.1 类设计黄金法则

1. 单一职责：一个类只做一件事
2. 高内聚低耦合：内部紧密相关，外部依赖最少
3. 优先使用组合而非继承：更灵活的设计
4. 面向接口编程：依赖抽象而非具体实现
5. 合理控制访问权限：最小化公开API

12.2 对象使用建议

1. 避免创建不必要的对象：特别是循环中
2. 及时释放引用：帮助垃圾回收
3. 合理使用不可变对象：线程安全且易于理解
4. 注意对象生命周期：特别是缓存中的对象

12.3 代码风格指南

1. 命名规范：

   • 类名：大驼峰，名词
   • 方法名：小驼峰，动词开头
   • 变量名：小驼峰，有意义

2. 注释要求：

   • 公共API必须有文档注释
   • 复杂逻辑必须有行内注释
   • 避免无意义的注释

3. 格式规范：

   • 一致的缩进和花括号风格
   • 合理的空行分隔逻辑块
   • 每行代码不超过120字符

12.4 调试与优化技巧

1. 使用IDE调试工具：

   • 断点调试
   • 表达式求值
   • 对象内存查看

2. 性能分析工具：

   • JVisualVM
   • JProfiler
   • Arthas

3. 内存分析工具：

   • Eclipse MAT
   • YourKit
   • JMap + Jhat

13. 常见面试问题解析

13.1 基础概念问题

问题1：类和对象有什么区别？

类是一个模板或蓝图，定义了对象的属性和行为。对象是类的具体实例，具有实际的状态和行为。例如，"汽车"是一个类，描述所有汽车共有的特征；而"一辆红色的特斯拉Model 3"是这个类的一个具体对象。

问题2：构造方法有什么特点？

1. 名称必须与类名完全相同
2. 没有返回值类型（连void也没有）
3. 主要作用是初始化对象
4. 可以重载（多个构造方法）
5. 如果没有定义构造方法，编译器会提供默认无参构造方法

13.2 深入原理问题

问题1：JVM中对象是如何创建的？

1. 类加载检查
2. 分配内存（指针碰撞或空闲列表）
3. 初始化零值
4. 设置对象头（Mark Word和类型指针）
5. 执行构造方法（程序员编写的初始化代码）

问题2：this关键字在JVM层面是如何实现的？

this实际上是作为实例方法的第一个隐式参数传递的。在字节码层面，实例方法的调用会隐式传入当前对象的引用作为第一个参数，这就是this的由来。这也是为什么静态方法没有this - 因为它们不需要对象实例来调用。

13.3 设计模式问题

问题1：如何设计一个不可变类？

1. 所有字段设为final
2. 不提供setter方法
3. 类本身声明为final防止子类修改
4. 如果字段是可变对象，需要进行防御性拷贝
5. 构造方法完全初始化所有字段

示例：

java复制public final class ImmutablePoint {
    private final int x;
    private final int y;
    private final Date createDate;  // 可变对象
    
    public ImmutablePoint(int x, int y, Date date) {
        this.x = x;
        this.y = y;
        this.createDate = new Date(date.getTime());  // 防御性拷贝
    }
    
    public Date getCreateDate() {
        return new Date(createDate.getTime());  // 返回拷贝
    }
}

问题2：单例模式有哪些实现方式？

1. 饿汉式：

java复制public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

2. 懒汉式（双重检查锁定）：

java复制public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

3. 静态内部类式：

java复制public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

4. 枚举式（最安全）：

java复制public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        // 方法实现
    }
}

14. 学习资源与进阶方向

14.1 推荐书籍

1. 《Java核心技术 卷I》 - Cay S. Horstmann

   • 全面系统的Java基础，包括类与对象的深入讲解

2. 《Effective Java》 - Joshua Bloch

   • Java最佳实践，包含大量类设计建议

3. 《深入理解Java虚拟机》 - 周志明

   • 理解Java对象内存模型和运行机制

14.2 在线资源

1. Oracle官方Java教程：
   https://docs.oracle.com/javase/tutorial/

2. Java语言规范：
   https://docs.oracle.com/javase/specs/

3. Stack Overflow：
   https://stackoverflow.com/questions/tagged/java

14.3 进阶学习方向

1. JVM底层机制：

   • 对象内存布局
   • 方法调用机制
   • 垃圾回收原理

2. 设计模式：

   • 创建型模式（工厂、单例等）
   • 结构型模式（适配器、装饰器等）
   • 行为型模式（策略、观察者等）

3. 框架源码分析：

   • Spring框架的Bean管理
   • Hibernate的实体映射
   • JDK集合框架实现

4. 性能优化：

   • 对象创建优化
   • 内存使用优化
   • 方法调用优化

15. 个人经验分享

在实际开发中，良好的类设计可以显著提高代码质量。以下是我总结的一些实践经验：

1. 保持类的小而专：如果一个类超过500行代码，很可能做了太多事情，应该考虑拆分。

2. 优先使用组合：除非有明显的"is-a"关系，否则优先使用组合而非继承。继承关系一旦建立就很难修改。

3. 合理使用构造方法：

   • 构造方法应该保持简单，只做必要的初始化
   • 复杂的初始化逻辑可以使用工厂方法
   • 考虑使用Builder模式构建复杂对象

4. 防御性编程：

   • 对输入参数进行验证
   • 对可变对象进行防御性拷贝
   • 在文档中明确说明方法的先决条件和后置条件

5. 测试驱动开发：

   • 先写测试用例，再实现类
   • 确保每个类都有明确的职责和可测试性
   • 使用Mock对象测试类之间的交互

6. 持续重构：

   • 随着需求变化不断调整类设计
   • 使用IDE的重构工具安全地修改代码结构
   • 定期检查代码的"坏味道"，如过大的类、过长的参数列表等

记住，好的类设计不是一蹴而就的，而是通过不断实践和反思逐渐形成的。每次写代码时都思考如何改进设计，长期积累下来，你的面向对象设计能力一定会大幅提升。