面向对象设计原则与实践-阿里云开发者社区

面向对象设计原则与实践

2024-06-26 7

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 面向对象设计原则与实践

1. 单一职责原则（SRP）

原则： 每个类应该只有一个引起它变化的原因。换句话说，一个类只负责一个功能。

实例：

public class User {
    private String name;
    private String email;
    // User类只负责用户信息
}
public class UserService {
    public void saveUser(User user) {
        // 保存用户信息
    }
    public void deleteUser(User user) {
        // 删除用户信息
    }
    // UserService类只负责用户操作
}
public class EmailService {
    public void sendEmail(String email, String message) {
        // 发送邮件
    }
    // EmailService类只负责邮件操作
}

通过遵循单一职责原则，我们将用户信息、用户操作和邮件操作分离到不同的类中，使代码更易于维护和扩展。

2. 开放封闭原则（OCP）

原则： 软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。即在不修改现有代码的情况下，能够实现对软件实体的功能扩展。

实例：

public interface Shape {
    double area();
}
public class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
public class Rectangle implements Shape {
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    public double area() {
        return length * width;
    }
}
public class AreaCalculator {
    public double calculateArea(Shape shape) {
        return shape.area();
    }
}

在这个实例中，通过定义Shape接口并实现具体的形状类（如Circle和Rectangle），我们可以在不修改AreaCalculator类的情况下添加新的形状。

3. 里氏替换原则（LSP）

原则： 子类对象必须能够替换父类对象，并且程序行为保持一致。

实例：

public class Bird {
    public void fly() {
        System.out.println("Flying");
    }
}
public class Sparrow extends Bird {
    @Override
    public void fly() {
        System.out.println("Sparrow flying");
    }
}
public class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostrich cannot fly");
    }
}

在这个例子中，Ostrich类违背了里氏替换原则，因为它不能完全替换Bird类的行为。一个解决方法是通过组合而不是继承来实现：

public class Bird {
    private FlyBehavior flyBehavior;
    public Bird(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }
    public void performFly() {
        flyBehavior.fly();
    }
}
public interface FlyBehavior {
    void fly();
}
public class CanFly implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("Flying");
    }
}
public class CannotFly implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("Cannot fly");
    }
}
public class Sparrow extends Bird {
    public Sparrow() {
        super(new CanFly());
    }
}
public class Ostrich extends Bird {
    public Ostrich() {
        super(new CannotFly());
    }
}

4. 接口隔离原则（ISP）

原则： 客户端不应该被迫依赖于它们不使用的方法。即接口应该尽量小而专一。

实例：

public interface Printer {
    void print();
    void scan();
    void fax();
}
public class MultiFunctionPrinter implements Printer {
    @Override
    public void print() {
        System.out.println("Printing");
    }
    @Override
    public void scan() {
        System.out.println("Scanning");
    }
    @Override
    public void fax() {
        System.out.println("Faxing");
    }
}
public class SimplePrinter implements Printer {
    @Override
    public void print() {
        System.out.println("Printing");
    }
    @Override
    public void scan() {
        throw new UnsupportedOperationException("Scan not supported");
    }
    @Override
    public void fax() {
        throw new UnsupportedOperationException("Fax not supported");
    }
}

在这个例子中，SimplePrinter类被迫实现了scan和fax方法，尽管它不支持这些功能。通过应用接口隔离原则，我们可以将Printer接口拆分为多个小接口：

public interface Printer {
    void print();
}
public interface Scanner {
    void scan();
}
public interface Fax {
    void fax();
}
public class MultiFunctionPrinter implements Printer, Scanner, Fax {
    @Override
    public void print() {
        System.out.println("Printing");
    }
    @Override
    public void scan() {
        System.out.println("Scanning");
    }
    @Override
    public void fax() {
        System.out.println("Faxing");
    }
}
public class SimplePrinter implements Printer {
    @Override
    public void print() {
        System.out.println("Printing");
    }
}

5. 依赖倒置原则（DIP）

原则： 高层模块不应该依赖于低层模块，二者都应该依赖于抽象；抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

实例：

public class Database {
    public void connect() {
        System.out.println("Connecting to database");
    }
}
public class UserService {
    private Database database;
    public UserService(Database database) {
        this.database = database;
    }
    public void performOperation() {
        database.connect();
    }
}

在这个例子中，UserService类依赖于Database类。通过应用依赖倒置原则，我们可以引入一个接口来抽象数据库连接：

public interface Database {
    void connect();
}
public class MySQLDatabase implements Database {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database");
    }
}
public class UserService {
    private Database database;
    public UserService(Database database) {
        this.database = database;
    }
    public void performOperation() {
        database.connect();
    }
}