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

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

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 {@Overridepublic 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);}@Overridepublic String getInfo() {return "Normal Student - ID: " + id + ", Name: " + name;}
}// 优秀学生类
class ExcellentStudent extends AbstractStudent {public ExcellentStudent(String id, String name) {super(id, name);}@Overridepublic 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;}@Overridepublic 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<>();@Overridepublic void addStudent(Student student) {students.add(student);}@Overridepublic 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 类对其他对象的了解最少，符合迪米特法则。

总结建议

---

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