java 代码设计原则

Java代码设计原则主要包括以下几个重要方面：

## 1. SOLID原则（核心设计原则）

### S - 单一职责原则 (Single Responsibility Principle)
**一个类应该只有一个引起它变化的原因**

```java
// ❌ 违反单一职责原则
class User {
    private String name;
    private String email;
    
    // 用户数据管理
    public void setName(String name) { this.name = name; }
    public void setEmail(String email) { this.email = email; }
    
    // 数据库操作 - 不应该在这里
    public void saveToDatabase() { /* 保存到数据库 */ }
    
    // 邮件发送 - 不应该在这里
    public void sendEmail() { /* 发送邮件 */ }
}

// ✅ 遵循单一职责原则
class User {
    private String name;
    private String email;
    // 只负责用户数据管理
}

class UserRepository {
    public void save(User user) { /* 数据库操作 */ }
}

class EmailService {
    public void sendEmail(User user) { /* 邮件发送 */ }
}
```

### O - 开闭原则 (Open-Closed Principle)
**对扩展开放，对修改关闭**

```java
// ❌ 违反开闭原则
class AreaCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Rectangle) {
            Rectangle rect = (Rectangle) shape;
            return rect.width * rect.height;
        } else if (shape instanceof Circle) {
            Circle circle = (Circle) shape;
            return Math.PI * circle.radius * circle.radius;
        }
        // 添加新形状需要修改这个方法
        return 0;
    }
}

// ✅ 遵循开闭原则
interface Shape {
    double calculateArea();
}

class Rectangle implements Shape {
    private double width, height;
    
    @Override
    public double calculateArea() {
        return width * height;
    }
}

class Circle implements Shape {
    private double radius;
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea(); // 无需修改，可扩展
    }
}
```

### L - 里氏替换原则 (Liskov Substitution Principle)
**子类应该能够替换父类并且不影响程序的正确性**

```java
// ❌ 违反里氏替换原则
class Bird {
    public void fly() {
        System.out.println("鸟在飞");
    }
}

class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("企鹅不能飞");
    }
}

// ✅ 遵循里氏替换原则
abstract class Bird {
    abstract void move();
}

class FlyingBird extends Bird {
    @Override
    void move() {
        fly();
    }
    
    public void fly() {
        System.out.println("鸟在飞");
    }
}

class Penguin extends Bird {
    @Override
    void move() {
        swim();
    }
    
    public void swim() {
        System.out.println("企鹅在游泳");
    }
}
```

### I - 接口隔离原则 (Interface Segregation Principle)
**不应该强迫客户端依赖它们不使用的方法**

```java
// ❌ 违反接口隔离原则
interface Worker {
    void work();
    void eat();
    void sleep();
}

class Robot implements Worker {
    @Override
    public void work() { /* 工作 */ }
    
    @Override
    public void eat() { 
        throw new UnsupportedOperationException("机器人不需要吃饭");
    }
    
    @Override
    public void sleep() { 
        throw new UnsupportedOperationException("机器人不需要睡觉");
    }
}

// ✅ 遵循接口隔离原则
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

interface Sleepable {
    void sleep();
}

class Human implements Workable, Eatable, Sleepable {
    @Override
    public void work() { /* 工作 */ }
    @Override
    public void eat() { /* 吃饭 */ }
    @Override
    public void sleep() { /* 睡觉 */ }
}

class Robot implements Workable {
    @Override
    public void work() { /* 工作 */ }
}
```

### D - 依赖倒置原则 (Dependency Inversion Principle)
**高层模块不应该依赖低层模块，两者都应该依赖抽象**

```java
// ❌ 违反依赖倒置原则
class MySQLDatabase {
    public void save(String data) {
        System.out.println("保存到MySQL: " + data);
    }
}

class UserService {
    private MySQLDatabase database = new MySQLDatabase(); // 直接依赖具体实现
    
    public void saveUser(String userData) {
        database.save(userData);
    }
}

// ✅ 遵循依赖倒置原则
interface Database {
    void save(String data);
}

class MySQLDatabase implements Database {
    @Override
    public void save(String data) {
        System.out.println("保存到MySQL: " + data);
    }
}

class UserService {
    private Database database; // 依赖抽象
    
    public UserService(Database database) {
        this.database = database;
    }
    
    public void saveUser(String userData) {
        database.save(userData);
    }
}
```

## 2. 其他重要设计原则

### DRY原则 (Don't Repeat Yourself)
**避免代码重复**

```java
// ❌ 代码重复
class OrderService {
    public void processOnlineOrder(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
        // 在线订单特殊处理
        sendConfirmationEmail(order);
    }
    
    public void processStoreOrder(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
        // 店内订单特殊处理
        printReceipt(order);
    }
}

// ✅ 消除重复
class OrderService {
    public void processOnlineOrder(Order order) {
        processCommonSteps(order);
        sendConfirmationEmail(order);
    }
    
    public void processStoreOrder(Order order) {
        processCommonSteps(order);
        printReceipt(order);
    }
    
    private void processCommonSteps(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
    }
}
```

### KISS原则 (Keep It Simple, Stupid)
**保持简单**

```java
// ❌ 过度复杂
class NumberProcessor {
    public boolean isEven(int number) {
        return Arrays.stream(IntStream.range(0, number)
            .filter(i -> i % 2 == 0)
            .toArray())
            .anyMatch(i -> i == number - 1);
    }
}

// ✅ 保持简单
class NumberProcessor {
    public boolean isEven(int number) {
        return number % 2 == 0;
    }
}
```

### YAGNI原则 (You Aren't Gonna Need It)
**不要过度设计，只实现当前需要的功能**

```java
// ❌ 过度设计
class User {
    private String name;
    private String email;
    private String phone;
    private String address;
    private String occupation;
    private String hobby;
    private String favoriteColor;
    // ... 很多可能永远不会用到的字段
}

// ✅ 只实现当前需要的
class User {
    private String name;
    private String email;
    // 需要时再添加其他字段
}
```

## 3. Java特有的设计原则和最佳实践

### 优先使用组合而非继承

```java
// ❌ 过度使用继承
class Car extends Engine {
    // Car "是一个" Engine？不合理
}

// ✅ 使用组合
class Car {
    private Engine engine; // Car "有一个" Engine
    
    public Car(Engine engine) {
        this.engine = engine;
    }
    
    public void start() {
        engine.start();
    }
}
```

### 针对接口编程，而非实现

```java
// ❌ 依赖具体实现
ArrayList<String> list = new ArrayList<>();

// ✅ 依赖接口
List<String> list = new ArrayList<>();
```

### 使用不可变对象

```java
// ✅ 不可变类设计
public final class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    
    // 没有setter方法，对象创建后不可修改
}
Java代码设计原则主要包括以下几个重要方面：

## 1. SOLID原则（核心设计原则）

### S - 单一职责原则 (Single Responsibility Principle)
**一个类应该只有一个引起它变化的原因**

```java
// ❌ 违反单一职责原则
class User {
    private String name;
    private String email;
    
    // 用户数据管理
    public void setName(String name) { this.name = name; }
    public void setEmail(String email) { this.email = email; }
    
    // 数据库操作 - 不应该在这里
    public void saveToDatabase() { /* 保存到数据库 */ }
    
    // 邮件发送 - 不应该在这里
    public void sendEmail() { /* 发送邮件 */ }
}

// ✅ 遵循单一职责原则
class User {
    private String name;
    private String email;
    // 只负责用户数据管理
}

class UserRepository {
    public void save(User user) { /* 数据库操作 */ }
}

class EmailService {
    public void sendEmail(User user) { /* 邮件发送 */ }
}
```

### O - 开闭原则 (Open-Closed Principle)
**对扩展开放，对修改关闭**

```java
// ❌ 违反开闭原则
class AreaCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Rectangle) {
            Rectangle rect = (Rectangle) shape;
            return rect.width * rect.height;
        } else if (shape instanceof Circle) {
            Circle circle = (Circle) shape;
            return Math.PI * circle.radius * circle.radius;
        }
        // 添加新形状需要修改这个方法
        return 0;
    }
}

// ✅ 遵循开闭原则
interface Shape {
    double calculateArea();
}

class Rectangle implements Shape {
    private double width, height;
    
    @Override
    public double calculateArea() {
        return width * height;
    }
}

class Circle implements Shape {
    private double radius;
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.calculateArea(); // 无需修改，可扩展
    }
}
```

### L - 里氏替换原则 (Liskov Substitution Principle)
**子类应该能够替换父类并且不影响程序的正确性**

```java
// ❌ 违反里氏替换原则
class Bird {
    public void fly() {
        System.out.println("鸟在飞");
    }
}

class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("企鹅不能飞");
    }
}

// ✅ 遵循里氏替换原则
abstract class Bird {
    abstract void move();
}

class FlyingBird extends Bird {
    @Override
    void move() {
        fly();
    }
    
    public void fly() {
        System.out.println("鸟在飞");
    }
}

class Penguin extends Bird {
    @Override
    void move() {
        swim();
    }
    
    public void swim() {
        System.out.println("企鹅在游泳");
    }
}
```

### I - 接口隔离原则 (Interface Segregation Principle)
**不应该强迫客户端依赖它们不使用的方法**

```java
// ❌ 违反接口隔离原则
interface Worker {
    void work();
    void eat();
    void sleep();
}

class Robot implements Worker {
    @Override
    public void work() { /* 工作 */ }
    
    @Override
    public void eat() { 
        throw new UnsupportedOperationException("机器人不需要吃饭");
    }
    
    @Override
    public void sleep() { 
        throw new UnsupportedOperationException("机器人不需要睡觉");
    }
}

// ✅ 遵循接口隔离原则
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

interface Sleepable {
    void sleep();
}

class Human implements Workable, Eatable, Sleepable {
    @Override
    public void work() { /* 工作 */ }
    @Override
    public void eat() { /* 吃饭 */ }
    @Override
    public void sleep() { /* 睡觉 */ }
}

class Robot implements Workable {
    @Override
    public void work() { /* 工作 */ }
}
```

### D - 依赖倒置原则 (Dependency Inversion Principle)
**高层模块不应该依赖低层模块，两者都应该依赖抽象**

```java
// ❌ 违反依赖倒置原则
class MySQLDatabase {
    public void save(String data) {
        System.out.println("保存到MySQL: " + data);
    }
}

class UserService {
    private MySQLDatabase database = new MySQLDatabase(); // 直接依赖具体实现
    
    public void saveUser(String userData) {
        database.save(userData);
    }
}

// ✅ 遵循依赖倒置原则
interface Database {
    void save(String data);
}

class MySQLDatabase implements Database {
    @Override
    public void save(String data) {
        System.out.println("保存到MySQL: " + data);
    }
}

class UserService {
    private Database database; // 依赖抽象
    
    public UserService(Database database) {
        this.database = database;
    }
    
    public void saveUser(String userData) {
        database.save(userData);
    }
}
```

## 2. 其他重要设计原则

### DRY原则 (Don't Repeat Yourself)
**避免代码重复**

```java
// ❌ 代码重复
class OrderService {
    public void processOnlineOrder(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
        // 在线订单特殊处理
        sendConfirmationEmail(order);
    }
    
    public void processStoreOrder(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
        // 店内订单特殊处理
        printReceipt(order);
    }
}

// ✅ 消除重复
class OrderService {
    public void processOnlineOrder(Order order) {
        processCommonSteps(order);
        sendConfirmationEmail(order);
    }
    
    public void processStoreOrder(Order order) {
        processCommonSteps(order);
        printReceipt(order);
    }
    
    private void processCommonSteps(Order order) {
        validateOrder(order);
        calculateTax(order);
        applyDiscount(order);
    }
}
```

### KISS原则 (Keep It Simple, Stupid)
**保持简单**

```java
// ❌ 过度复杂
class NumberProcessor {
    public boolean isEven(int number) {
        return Arrays.stream(IntStream.range(0, number)
            .filter(i -> i % 2 == 0)
            .toArray())
            .anyMatch(i -> i == number - 1);
    }
}

// ✅ 保持简单
class NumberProcessor {
    public boolean isEven(int number) {
        return number % 2 == 0;
    }
}
```

### YAGNI原则 (You Aren't Gonna Need It)
**不要过度设计，只实现当前需要的功能**

```java
// ❌ 过度设计
class User {
    private String name;
    private String email;
    private String phone;
    private String address;
    private String occupation;
    private String hobby;
    private String favoriteColor;
    // ... 很多可能永远不会用到的字段
}

// ✅ 只实现当前需要的
class User {
    private String name;
    private String email;
    // 需要时再添加其他字段
}
```

## 3. Java特有的设计原则和最佳实践

### 优先使用组合而非继承

```java
// ❌ 过度使用继承
class Car extends Engine {
    // Car "是一个" Engine？不合理
}

// ✅ 使用组合
class Car {
    private Engine engine; // Car "有一个" Engine
    
    public Car(Engine engine) {
        this.engine = engine;
    }
    
    public void start() {
        engine.start();
    }
}
```

### 针对接口编程，而非实现

```java
// ❌ 依赖具体实现
ArrayList<String> list = new ArrayList<>();

// ✅ 依赖接口
List<String> list = new ArrayList<>();
```

### 使用不可变对象

```java
// ✅ 不可变类设计
public final class Person {
    private final String name;
    private final int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
    
    // 没有setter方法，对象创建后不可修改
}