Java面向对象中里式替换原则（Liskov Substitution Principle，LSP）、 开闭原则（OCP）、接口隔离原则（ISP）和依赖倒置原则（DIP）

面向对象的设计原则帮助我们创建更可维护、可扩展和灵活的系统。以下是这些原则的详细解释和示例：

1. 里氏替换原则（Liskov Substitution Principle, LSP）

定义：在使用基类的地方可以使用其子类，且不会影响程序的正确性。

例子：

class Bird {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow is flying");
    }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostriches can't fly!");
    }
}

public class BirdTest {
    public static void main(String[] args) {
        Bird sparrow = new Sparrow();
        Bird ostrich = new Ostrich();

        // 正常的替换关系
        sparrow.fly(); // 输出：Sparrow is flying

        // 违反了LSP，因为父类中fly方法不应该抛出异常
        ostrich.fly(); // 抛出异常
    }
}

分析：在这个例子中，我们把 Ostrich 当作 Bird 使用时，fly 方法不工作，违反了里氏替换原则（LSP）。Ostrich 的设计应该考虑不要继承 Bird 或者重新定义 Bird 类的方法，让所有子类都能正确实现。

2. 开闭原则（Open/Closed Principle, OCP）

定义：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。即可以通过扩展功能来增强类的功能，而不应修改现有代码。

例子：

// 抽象类 Shape 表示形状
abstract class Shape {
    public abstract void draw();
}

// 具体的圆形
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 具体的矩形
class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

// 使用Shape的类
class ShapeDrawer {
    public void drawShapes(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

public class ShapeTest {
    public static void main(String[] args) {
        List<Shape> shapes = Arrays.asList(new Circle(), new Rectangle());
        new ShapeDrawer().drawShapes(shapes);
    }
}

分析：在这个例子中，ShapeDrawer 类并不需要修改就可以支持 Shape 的新子类（如 Triangle），因为 Shape 是可扩展的。这就是开闭原则。

3. 接口隔离原则（Interface Segregation Principle, ISP）

定义：客户端不应该被迫依赖它不使用的方法，即接口应该为客户端定制。

例子：

interface Bird {
    void fly();
    void eat();
}

class Sparrow implements Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow flying");
    }

    @Override
    public void eat() {
        System.out.println("Sparrow eating");
    }
}

class Ostrich implements Bird { // 不符合ISP
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostrich can't fly!");
    }

    @Override
    public void eat() {
        System.out.println("Ostrich eating");
    }
}

改进：使用接口隔离原则：

interface Eatable {
    void eat();
}

interface Flyable {
    void fly();
}

class Sparrow implements Flyable, Eatable {
    @Override
    public void fly() {
        System.out.println("Sparrow flying");
    }

    @Override
    public void eat() {
        System.out.println("Sparrow eating");
    }
}

class Ostrich implements Eatable {
    @Override
    public void eat() {
        System.out.println("Ostrich eating");
    }
}

分析：在这个例子中，将 Bird 接口拆分为 Flyable 和 Eatable 接口，避免了 Ostrich 依赖不需要的 fly 方法，实现了接口隔离原则。

4. 依赖倒置原则（Dependency Inversion Principle, DIP）

定义：高层模块不应该依赖于低层模块，两者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

例子：

// 高层模块
class NotificationService {
    private MessageSender messageSender;

    // 依赖抽象（接口）而不是具体实现
    public NotificationService(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public void sendNotification(String message) {
        messageSender.sendMessage(message);
    }
}

// 抽象接口
interface MessageSender {
    void sendMessage(String message);
}

// 具体实现类 - Email
class EmailSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending Email: " + message);
    }
}

// 具体实现类 - SMS
class SMSSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

public class NotificationTest {
    public static void main(String[] args) {
        // 通过注入不同的发送者实现灵活的依赖倒置
        NotificationService emailNotification = new NotificationService(new EmailSender());
        emailNotification.sendNotification("Hello via Email");

        NotificationService smsNotification = new NotificationService(new SMSSender());
        smsNotification.sendNotification("Hello via SMS");
    }
}

分析：NotificationService 依赖于 MessageSender 接口，而不是具体的实现类。这意味着可以轻松更换 MessageSender 的实现而不修改 NotificationService 类，从而实现了依赖倒置原则。

这些原则有助于创建更好的面向对象设计，提高代码的可维护性和扩展性。