共计 9244 个字符，预计需要花费 24 分钟才能阅读完成。
软件设计七大准则
开闭准则
- 定义：一个软件实体如类、模块和函数应该对扩大凋谢，对批改敞开。
- 用形象构建框架，用实现扩大细节。
- 长处：进步软件系统的可复用性及可维护性。
代码示例
接口：
public interface ICourse {Integer getId();
String getName();
Double getPrice();}基类：
public class JavaCourse implements ICourse{
private Integer id;
private String name;
private Double price;
public JavaCourse(Integer id, String name, Double price) {
this.id = id;
this.name = name;
this.price = price;
}
@Override
public Integer getId() {return this.id;}
@Override
public String getName() {return this.name;}
@Override
public Double getPrice() {return this.price;}
@Override
public String toString() {
return "JavaCourse{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}扩大类（子类）：
public class JavaDiscountCourse extends JavaCourse{public JavaDiscountCourse(Integer id, String name, Double price) {super(id, name, price);
}
public Double getOriginPrice(){return super.getPrice();
}
@Override
public Double getPrice() {return super.getPrice()*0.8;
}
}测试：
public class OpenCloseTest {
@Test
public void openCloseTest(){ICourse iCourse = new JavaDiscountCourse(99, "Java 从零到企业级开发", 348d);
JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
System.out.println("课程 ID:"+javaDiscountCourse.getId()+"课程名称:"+javaDiscountCourse.getName()+
"价格:"+javaDiscountCourse.getPrice() + "初始价格:"+javaDiscountCourse.getOriginPrice());
}
}准则剖析
利用场景：打折销售
需要：须要减少网站的网课打折 性能。
实现：间接在“应用层”上扩大（继承）了基类，而不是间接对“底层”的接口或者基类进行批改。
起因：如果接口的办法较多，基类实现的逻辑比较复杂，对其进行间接批改会存在 危险扩散，容易引起 Bug。越低层次的模块（或越根底的模块）的批改，影响的范畴越大；相同越高层次的模块的批改，影响的范畴越小。
举例：如果 Dao 层中的一个模块被多个 Service 层模块应用，对 Dao 层的该模块进行批改会影响到多个 Service 层模块，甚至影响到 Controller 层。
依赖倒置准则
- 定义：高层模块不应该依赖低层模块，二者都应该依赖其形象。
- 形象不应该依赖细节；细节应该依赖形象。
- 针对接口编程，不要针对实现编程。
- 长处：能够缩小类间的耦合性、进步零碎稳定性，进步代码可读性和可维护性，可升高批改程序所造成的危险。
代码示例
实体类：
public class Feyl {
private ICourse icourse;
public void setICourse(ICourse icourse) {this.icourse = icourse;}
public void studyCourse(){icourse.studyCourse();
}
}接口：
public interface ICourse {void studyCourse();
}实现类:
public class ArithmeticCourse implements ICourse{
@Override
public void studyCourse() {System.out.println("Feyl is learning Arithmetic course!");
}
}public class JavaCourse implements ICourse{
@Override
public void studyCourse() {System.out.println("Feyl is learning Java course!");
}
}public class FECourse implements ICourse{
@Override
public void studyCourse() {System.out.println("Feyl is learning FECourse!");
}
}测试类：
public class DependencyInversionTest {
@Test
public void DependencyInversionTest(){Feyl feyl = new Feyl();
feyl.setICourse(new ArithmeticCourse());
feyl.studyCourse();
feyl.setICourse(new JavaCourse());
feyl.studyCourse();
feyl.setICourse(new FECourse());
feyl.studyCourse();}
}准则剖析
利用场景：减少学习的课程
需要：减少实体类（人）学习的课程 性能。
实现：通过 ICourse 接口将实体类（人）与具体学习的课程相分割。减少具体课程时，让减少的课程间接实现接口，此过程不须要对具体的实体类（人）进行批改。
繁多职责准则
- 定义：不要存在多于一个导致类变更的起因
- 一个类 / 接口 / 办法只负责一项职责
- 长处：升高类的复杂度、进步类的可读性、进步零碎的可维护性、升高变更引起的危险
代码示例
类的繁多职责：
public class ICourse {}public interface ICourseManager {void studyCourse();
void refundCourse();}public interface ICourseContent {String courseName();
byte[] courseVideo();
}public class ICourseImpl implements ICourseManager,ICourseContent{
@Override
public String courseName() {return null;}
@Override
public byte[] courseVideo() {return new byte[0];
}
@Override
public void studyCourse() {}
@Override
public void refundCourse() {}
}办法的繁多职责：
public class Method {public void updateUserInfo(String username, String address){
username = "Feyl";
address = "HeNan";
}
public void updateUserInfo(String username, String... properties){
username = "Feyl";
// properties = ;
}
public void updateUsername(String username){username = "Feyl";}
public void updateAddress(String address){address = "HeNan";}
}接口隔离准则
- 定义：用多个专门的接口，而不应用繁多的总接口，客户端不应该依赖它不须要的接口
- 一个类对一个类的依赖应该建设在最小的接口上
- 建设繁多接口，不要建设宏大臃肿的接口
- 尽量细化接口，接口中的办法尽量少
- 留神适度准则，肯定要适度
- 长处：合乎咱们常说的高内聚低耦合的设计思维，从而使得类具备很好的可读性、可扩展性和可维护性。
代码示例
反例：
public interface IAnimalAction {void eat();
void fly();
void swim();}public class Bird implements IAnimalAction{
@Override
public void eat() {}
@Override
public void fly() {}
@Override
public void swim() {}
}范例：
public interface IEatAnimalAction {void eat();
}public interface IFlyAnimalAction {void fly();
}public interface ISwimAnimalAction {void swim();
}public class Dog implements ISwimAnimalAction,IEatAnimalAction{
@Override
public void eat() {}
@Override
public void swim() {}
}迪米特准则
- 定义：一个对象应该对其余对象放弃起码的理解。又叫起码晓得准则
- 尽量升高类与类之间的耦合
- 长处：升高类之间的耦合
- 强调只和敌人交换, 不和陌生人谈话
- 敌人：呈现在成员变量、办法的输出、输入参数中的类称为成员敌人类，而呈现在办法体外部的类不属于敌人类。
代码示例
反例：
public class Course {}public class TeamLeader {public void checkNumberOfCourse(List<Course> courses){System.out.println("在线课程的数量："+courses.size());
}
}public class Boss {void commandCheckNumber(TeamLeader teamLeader) {List<Course> list = new ArrayList<Course>();
for (int i = 0; i < 20; i++) {list.add(new Course());
}
teamLeader.checkNumberOfCourse(list);
}
}测试类：
public class DemeterTest {
@Test
public void demeterTest() {new Boss().commandCheckNumber(new TeamLeader());
}
}范例：
public class TeamLeader {public void checkNumberOfCourse(){List<Course> courses = new ArrayList<Course>();
for (int i = 0; i < 20; i++) {courses.add(new Course());
}
System.out.println("在线课程的数量："+courses.size());
}
}public class Boss {public void commandCheckNumber(TeamLeader teamLeader) {teamLeader.checkNumberOfCourse();
}
}里氏替换准则
定义：如果对每一个类型为 T1 的对象 o1，都有类型为 T2 的对象 o2，使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。
定义扩大：一个软件实体如果实用一个父类的话，那肯定实用于其子类，所有援用父类的中央必须能通明地应用其子类的对象，子类对象可能替换父类对象，而程序逻辑不变。
引申意义：子类能够扩大父类的性能，但不能扭转父类原有的性能。
含意 1：子类能够实现父类的形象办法，但不能笼罩父类的非形象办法。
含意 2：子类中能够减少本人特有的办法。
含意 3：当子类的办法重载父类的办法时，办法的前置条件（即办法的输出 / 入参）要比父类办法的输出参数更宽松。
含意 4：当子类的办法实现父类的办法时（重写 / 重载或实现形象办法），办法的后置条件（即办法的输入 / 返回值）要比父类更严格或相等。
长处 1：束缚继承泛滥，开闭准则的一种体现。
长处 2：增强程序的健壮性，同时变更时也能够做到十分好的兼容性，进步程序的维护性、扩展性。升高需要变更时引入的危险。
对开闭准则代码批改使其符和里氏替换准则：
// ICourse 接口、JavaCourse 类放弃不变public class JavaDiscountCourse extends JavaCourse{public JavaDiscountCourse(Integer id, String name, Double price) {super(id, name, price);
}
public Double getDiscountPrice(){return super.getPrice()*0.8;
}
}测试类：
public class OpenCloseTest {
@Test
public void openCloseTest(){ICourse iCourse = new JavaDiscountCourse(99, "Java 从零到企业级开发", 348d);
JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
System.out.println("课程 ID:"+javaDiscountCourse.getId()+"课程名称:"+javaDiscountCourse.getName()+
"价格:"+javaDiscountCourse.getDiscountPrice() + "初始价格:"+javaDiscountCourse.getPrice());
}
}代码示例
反例：
public class Rectangle {
private long length;
public long getLength() {return length;}
public void setLength(long length) {this.length = length;}
public long getWidth() {return width;}
public void setWidth(long width) {this.width = width;}
private long width;
}public class Square extends Rectangle{
private long sideLength;
public long getSideLength() {return sideLength;}
public void setSideLength(long sideLength) {this.sideLength = sideLength;}
@Override
public long getLength() {return getSideLength();
}
@Override
public void setLength(long length) {setSideLength(length);
}
@Override
public long getWidth() {return getSideLength();
}
@Override
public void setWidth(long width) {setSideLength(width);
}
}测试类：
public class Test {public static void resize(Rectangle rectangle){while(rectangle.getWidth() <= rectangle.getLength()){rectangle.setWidth(rectangle.getWidth()+1);
System.out.println("Width:" + rectangle.getWidth()+"\t Length:"+rectangle.getLength());
}
System.out.println("resize 办法完结: Width:"+rectangle.getWidth()+"\tLength:"+rectangle.getLength());
}
public static void main(String[] args) {/*Rectangle rectangle = new Rectangle();
rectangle.setWidth(10);
rectangle.setLength(20);
resize(rectangle);*/
Square square = new Square();
square.setLength(10);
resize(square);
}
}范例：
public interface Quadrangle {long getWidth();
long getLength();}public class Rectangle implements Quadrangle{
private long width;
private long length;
@Override
public long getWidth() {return 0;}
@Override
public long getLength() {return 0;}
public void setWidth(long width) {this.width = width;}
public void setLength(long length) {this.length = length;}
}public class Square implements Quadrangle{
private long sideLength;
@Override
public long getWidth() {return sideLength;}
@Override
public long getLength() {return sideLength;}
public long getSideLength() {return sideLength;}
public void setSideLength(long sideLength) {this.sideLength = sideLength;}
}Test 测试类中的
// square.setLength(10);
// resize(square);
会抛异样。若将 resize(Rectangle rectangle) 改为 resize(Quadrangle quadrangle)，办法中的 set 办法也不能满足要求。由此看来，反例中的继承关系违反了里氏替换准则。办法重载（入参）：
public class Base {public void method(HashMap map){System.out.println("父类的 HashMap 办法被执行。");
}
}public class Child extends Base {
/* @Override
public void method(HashMap map) {System.out.println("子类的 HashMap 入参办法被调用了!");
}*/
public void method(Map map){System.out.println("子类的 Map 入参办法被调用了!");
}
}办法重载（返回值）：
public abstract class Base {public abstract Map method();
}public class Child extends Base{
@Override
public HashMap method() {HashMap<String,String> hashMap = new HashMap<>();
System.out.println("子类的 HashMap 被调用!");
hashMap.put("msg","子类的 HashMap 被调用!");
return hashMap;
}
}合成(组合)/ 聚合复用准则
- 定义：尽量应用对象组合 / 聚合，而不是继承关系达到软件复用的目标
- 聚合 has- A 和组合 contains-A
- 长处：能够使零碎更加灵便, 升高类与类之间的耦合度，一个类的变动对其余类造成的影响绝对较少
- 何时应用合成 / 聚合、继承
- 聚合 has-A、组合 contains-A 继承 is-A
代码示例
public abstract class DBConnection {/*public String getConnection(){return "Mysql 数据库连贯";}*/
public abstract String getDBConnection();}public class MySQLConnection extends DBConnection{
@Override
public String getDBConnection() {return "MySQL 数据库连贯";}
}public class PostgreSQLConnection extends DBConnection{
@Override
public String getDBConnection() {return "PostgreSQL 数据库连贯";}
}public class ProductDao{
private DBConnection dbConnection;
public void setDbConnection(DBConnection dbConnection) {this.dbConnection = dbConnection;}
public void addProduct(){String conn = dbConnection.getDBConnection();
System.out.println("应用"+conn+"减少产品");
}
}测试代码：
public class CompositionAggregationTest {
@Test
public void compositionAggregationTest(){ProductDao productDao = new ProductDao();
// productDao.setDbConnection(new MySQLConnection());
productDao.setDbConnection(new PostgreSQLConnection());
productDao.addProduct();}
}正文完