移动应用开发的六大设计原则

在移动应用开发中，遵循设计原则能大幅提升代码的可维护性和扩展性。本文以一个简单的学生管理系统为例，解析六大核心设计原则的实践方法。

1. 单一职责原则

优点：

• 提高可维护性：一个类只负责一项职责，代码的功能会更加清晰。当需求发生变化时，只需要修改与该职责相关的类，不会对其他不相关的功能产生影响，从而降低了维护的复杂度。例如在学生管理系统中，Student 类专门负责存储学生信息，StudentManager 类专门负责学生信息的管理操作，若要修改学生信息的存储方式，只需关注 Student 类即可。
• 增强可扩展性：每个类的职责明确，当需要添加新功能时，可以很方便地创建新的类来承担相应的职责，而不会破坏原有的代码结构。比如要添加学生成绩管理功能，可创建一个新的 StudentGradeManager 类，而不影响现有的 Student 和 StudentManager 类。

// 学生类，只负责存储学生信息
class Student {
    private String id;
    private String name;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

// 学生管理类，只负责学生信息的管理
import java.util.ArrayList;
import java.util.List;

class StudentManager {
    private List<Student> students = new ArrayList<>();

    public void addStudent(Student student) {
        students.add(student);
    }

    public void removeStudent(Student student) {
        students.remove(student);
    }

    public Student findStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }

在上述代码中，Student 类只负责存储学生的基本信息，而 StudentManager 类只负责学生信息的管理操作，如添加、删除和查询。这样，每个类的职责都非常明确，当需求发生变化时，只需要修改相应的类即可。

2. 开闭原则

开闭原则要求软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

优点：

• 提高软件的可扩展性：软件实体（类、模块、函数等）可以通过增加新的代码来扩展功能，而不需要修改已有的代码。这使得软件在面对不断变化的需求时，能够更加灵活地进行功能扩展，适应业务的发展和变化。
• 保持软件的稳定性：避免了对原有代码的修改，从而减少了因修改而可能导致的错误和风险，保持了软件系统的稳定性和可靠性。已经经过测试和验证的代码可以继续稳定运行，不会因为新功能的添加而受到影响。

// 学生信息展示接口
interface StudentDisplay {
    void display(Student student);
}

// 控制台展示实现类
class ConsoleStudentDisplay implements StudentDisplay {
    @Override
    public void display(Student student) {
        System.out.println("Student ID: " + student.getId() + ", Name: " + student.getName());
    }
}

// 学生管理类中使用接口
class StudentManager {
    private List<Student> students = new ArrayList<>();

    public void addStudent(Student student) {
        students.add(student);
    }

    public void removeStudent(Student student) {
        students.remove(student);
    }

    public Student findStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }

    public void displayStudent(String id, StudentDisplay display) {
        Student student = findStudentById(id);
        if (student != null) {
            display.display(student);
        }
    }
}

在上述代码中，我们定义了一个 StudentDisplay 接口，用于展示学生信息。ConsoleStudentDisplay 类实现了该接口，提供了在控制台展示学生信息的功能。当需要添加新的展示方式时，如将学生信息展示在文件中，我们只需要实现 StudentDisplay 接口，而不需要修改 StudentManager 类的代码，从而实现了对扩展开放，对修改关闭。

3. 里氏替换原则

里氏替换原则，即子类可以替换其父类并且不会影响程序的正确性。

优点：

• 保证系统的稳定性：子类可以替换父类，使得在使用父类的地方可以透明地使用子类对象，不会影响程序的正确性。这保证了系统在扩展和维护过程中的稳定性，避免了因子类替换父类而导致的程序崩溃或错误。例如在学生管理系统中，NormalStudent 和 ExcellentStudent 类都可以替换 AbstractStudent 类，而不会影响 StudentManager 类的正常运行。
• 促进代码复用：通过继承和多态，父类的代码可以被子类复用，减少了代码的重复编写。子类可以在父类的基础上进行扩展，实现自己的独特功能，提高了代码的复用率和开发效率。
• 便于系统的扩展和维护：遵循里氏替换原则，使得系统的设计更加灵活，当需要添加新的子类时，不会对现有的代码产生影响，便于系统的扩展和维护。

// 抽象类
abstract class AbstractStudent {
    protected String id;
    protected String name;

    public AbstractStudent(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public abstract String getInfo();
}

// 普通学生类
class NormalStudent extends AbstractStudent {
    public NormalStudent(String id, String name) {
        super(id, name);
    }

    @Override
    public String getInfo() {
        return "Normal Student - ID: " + id + ", Name: " + name;
    }
}

// 优秀学生类
class ExcellentStudent extends AbstractStudent {
    public ExcellentStudent(String id, String name) {
        super(id, name);
    }

    @Override
    public String getInfo() {
        return "Excellent Student - ID: " + id + ", Name: " + name;
    }
}

// 学生管理类使用抽象学生类
class StudentManager {
    private List<AbstractStudent> students = new ArrayList<>();

    public void addStudent(AbstractStudent student) {
        students.add(student);
    }

    public void displayStudents() {
        for (AbstractStudent student : students) {
            System.out.println(student.getInfo());
        }
    }
}

在上述代码中，NormalStudent 和 ExcellentStudent 类都继承自 AbstractStudent 类。StudentManager 类使用 AbstractStudent 类来管理学生信息，这样无论是 NormalStudent 还是 ExcellentStudent 对象都可以替换 AbstractStudent 对象，而不会影响程序的正确性。

4. 依赖倒置原则

依赖倒置原则要求高层模块不应该依赖低层模块，二者都应该依赖抽象。

优点：

• 降低模块间的耦合度：高层模块不依赖低层模块，二者都依赖抽象，减少了模块之间的直接依赖关系。当低层模块发生变化时，不会影响到高层模块，提高了系统的独立性和可维护性。例如在学生管理系统中，StudentViewer 类依赖 StudentInfoProvider 接口，而不是具体的 StudentInfoProviderImpl 类，当需要更换学生信息的获取方式时，只需实现新的 StudentInfoProvider 接口实现类，而无需修改 StudentViewer 类。
• 提高系统的可测试性：依赖抽象使得可以更容易地对模块进行单元测试。可以使用模拟对象来替代具体的实现类，对模块进行独立测试，提高了测试的效率和准确性。
• 增强系统的可扩展性：通过依赖抽象，系统可以方便地引入新的实现类，扩展系统的功能。例如在学生管理系统中，当需要添加新的学生信息获取方式时，只需实现 StudentInfoProvider 接口，而无需修改现有的代码。

// 学生信息获取接口
interface StudentInfoProvider {
    Student getStudentById(String id);
}

// 学生信息获取实现类
class StudentInfoProviderImpl implements StudentInfoProvider {
    private List<Student> students = new ArrayList<>();

    public StudentInfoProviderImpl(List<Student> students) {
        this.students = students;
    }

    @Override
    public Student getStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }
}

// 学生信息展示依赖接口
class StudentViewer {
    private StudentInfoProvider provider;

    public StudentViewer(StudentInfoProvider provider) {
        this.provider = provider;
    }

    public void viewStudent(String id) {
        Student student = provider.getStudentById(id);
        if (student != null) {
            System.out.println("Student ID: " + student.getId() + ", Name: " + student.getName());
        }
    }
}

在上述代码中，StudentViewer 类是高层模块，StudentInfoProviderImpl 类是低层模块。StudentViewer 类不直接依赖 StudentInfoProviderImpl 类，而是依赖 StudentInfoProvider 接口。通过依赖注入的方式，将 StudentInfoProvider 接口的实现类注入到 StudentViewer 类中，从而实现了依赖倒置。

5. 接口隔离原则

接口隔离原则强调客户端不应该依赖它不需要的接口。

优点：

• 提高系统的内聚性：每个接口只包含客户端需要的方法，使得接口的职责更加单一，提高了系统的内聚性。内聚性高的系统更容易维护和扩展。
• 增强代码的灵活性：当需求发生变化时，只需要修改相关的接口和实现类，不会影响到其他不相关的接口和类，提高了代码的灵活性和可维护性。

// 学生添加接口
interface StudentAdder {
    void addStudent(Student student);
}

// 学生查询接口
interface StudentFinder {
    Student findStudentById(String id);
}

// 学生管理类实现多个接口
class StudentManager implements StudentAdder, StudentFinder {
    private List<Student> students = new ArrayList<>();

    @Override
    public void addStudent(Student student) {
        students.add(student);
    }

    @Override
    public Student findStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }
}

在上述代码中，我们将学生管理的功能拆分成了 StudentAdder 和 StudentFinder 两个接口。StudentManager 类实现了这两个接口，这样不同的客户端可以根据自己的需求只依赖它们需要的接口，避免了依赖不必要的方法。

6. 迪米特法则

迪米特法则也称为最少知识原则，它要求一个对象应该对其他对象有最少的了解。

优点：

• 降低系统的耦合度：一个对象对其他对象有最少的了解，减少了对象之间的直接交互，降低了系统的耦合度。当一个对象发生变化时，不会对其他对象产生过多的影响，提高了系统的独立性和可维护性。例如在学生管理系统中，StudentViewer 类只和 StudentManager 类进行交互，而不直接和 Student 类进行交互。
• 提高系统的可维护性：由于对象之间的交互减少，系统的结构更加清晰，当需要修改某个对象时，只需要关注该对象及其直接关联的对象，降低了维护的难度。
• 增强系统的安全性：减少对象之间的直接交互，避免了不必要的信息传递，提高了系统的安全性。例如在学生管理系统中，StudentViewer 类只能通过 StudentManager 类获取学生信息，不能直接访问 Student 类的内部信息，保护了学生信息的安全。

// 学生类
class Student {
    private String id;
    private String name;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

// 学生管理类
class StudentManager {
    private List<Student> students = new ArrayList<>();

    public void addStudent(Student student) {
        students.add(student);
    }

    public void removeStudent(Student student) {
        students.remove(student);
    }

    public Student findStudentById(String id) {
        for (Student student : students) {
            if (student.getId().equals(id)) {
                return student;
            }
        }
        return null;
    }
}

// 学生信息页面
class StudentViewer {
    private StudentManager manager;

    public StudentViewer(StudentManager manager) {
        this.manager = manager;
    }

    public void viewStudent(String id) {
        Student student = manager.findStudentById(id);
        if (student != null) {
            System.out.println("Student ID: " + student.getId() + ", Name: " + student.getName());
        }
    }
}

在上述代码中，StudentViewer 类只和 StudentManager 类进行交互，而不直接和 Student 类进行交互。这样，StudentViewer 类对其他对象的了解最少，符合迪米特法则。

总结建议

代码是写给人看的，好的设计让应用既能快速响应需求变化，又能保持代码的优雅整洁。