网站导航
> 文章列表 > 设计模式-设计原则

设计模式-设计原则

网友: 文章列表 2024-03-21 16:53:56

设计模式-设计原则

设计原则

1.依赖倒置

高层不应该依赖低层，两者应该都依赖于抽象

抽象不应该依赖具体实现，具体应该依赖于抽象

设计模式-设计原则

自动驾驶系统公司是高层，汽车生产商是底层，自动驾驶系统不应该依赖于各种车型系统底层进行实现，因为这是耦合度高，车型多样。而应该依赖于抽象的自动驾驶行业标准，汽车厂商也应该依赖于自动驾驶标准，可以配置各种自动驾驶系统

2.开放封闭

一个类对扩展，也就是组合和继承开放，对修改关闭

3.面向接口

客户程序面对一个未知的系统，不应该知道里面的数据流动，而应该面向该系统的接口即可

从而减少系统各部分依赖关系

4. 单一职责

一个方法尽可能只做一件事，一个类应该仅有一个引起它变化的原因

不遵循单一原则


package com.study.singleResponsibilty;public class SingleResponsibility1 {public static void main(String[] args) {// 类实例化Vehicle v1 = new Vehicle("汽车");Vehicle v2 = new Vehicle("飞机");Vehicle v3 = new Vehicle("轮船");// 调用行驶方法v1.mov();v2.mov();v3.mov();}
}// 交通工具类
class Vehicle{private final String vehicleType ;// 构造方法public Vehicle(String vehicleType) {this.vehicleType = vehicleType;}//方法: 行驶public void mov(){System.out.println(this.vehicleType + "在马路上行驶");}
}

设计模式-设计原则

严格遵循单一原则

package com.study.singleResponsibilty;public class SingleResponsibility3 {public static void main(String[] args) {// 类实例化RoadVehicle rv = new RoadVehicle("汽车");AirVehicle av = new AirVehicle("飞机");SeaVehicle sv = new SeaVehicle("轮船");// 调用方法rv.mov();av.mov();sv.mov();}
}// 陆地交通工具类
class RoadVehicle {private final String vehicleType;// 构造方法public RoadVehicle(String vehicleType) {this.vehicleType = vehicleType;}// 方法: 行驶public void mov(){System.out.println(this.vehicleType + "在公路行驶");}
}// 空中交通工具类
class AirVehicle {private final String vehicleType;// 构造方法public AirVehicle(String vehicleType) {this.vehicleType = vehicleType;}// 方法: 行驶public void mov(){System.out.println(this.vehicleType + "在空中行驶");}
}// 海上交通工具类
class SeaVehicle {private final String vehicleType;// 构造方法public SeaVehicle(String vehicleType) {this.vehicleType = vehicleType;}// 方法: 行驶public void mov(){System.out.println(this.vehicleType + "在海上行驶");}
}

设计模式-设计原则

5. 里式替换

子类型必须能够替换掉它的父类型;主要出现在子类覆盖父类实现，原来使用父类型的程序可能出 现错误;覆盖了父类方法却没有实现父类方法的职责;

  1. 子类必须完全实现父类的抽象方法，且不可重写父类非抽象方法
  2. 子类可以实现特有方法
  3. 子类可透明访问父类的所有方法

不遵循里氏原则

package com.study.liskov;public class Liskov1 {public static void main(String[] args) {A a = new A();ExtendA ea = new ExtendA();System.out.print("输入A: ");a.info();System.out.print("再输出A: ");ea.info();}
}class A{public void info() {System.out.println("我是A");}public void baseMethod1(){System.out.println("基础方法1");}public void baseMethod2() {System.out.println("基础方法2");}
}class ExtendA extends A{public void info() {System.out.println("我是extendA");}
}

设计模式-设计原则

父类的info被破坏

遵循里氏原则

package com.study.liskov;public class Liskov2 {public static void main(String[] args) {A1 a = new A1();ExtendA1 ea = new ExtendA1();System.out.print("输出A: ");a.info();System.out.print("再输出A: ");ea.info();System.out.print("ExtendA 中使用 A: ");ea.UseA(a);System.out.print("参数为BaseA, 传入A: ");ea.UseBaseA(a);}
}abstract class BaseA {// A类 的基础方法public void info() {System.out.println("我是A");}public void baseMethod1() {System.out.println("基础方法1");}public void baseMethod2() {System.out.println("基础方法2");}abstract public void run();
}class A1 extends BaseA {public void uniqueA() {System.out.println("A 特有方法");}@Overridepublic void run() {System.out.println("A -> running......");}
}class ExtendA1 extends BaseA {A1 a = new A1();@Overridepublic void run() {System.out.println("ExtendA -> running......");}public void UseA(A1 a){a.uniqueA();}public void UseBaseA(BaseA ba) {ba.baseMethod1();}}

设计模式-设计原则

  1. 将所有基础方法写入BaseA中，在写A和ExtendA时放置了子类重写父类的问题
  2. 在ExtendA 中使用A， 使用组合的方式
  3. 由于子类能够透明的完全访问父类， 当需要一个BaseA参数时，可以传入一个A

6.接口隔离

不应该强迫客户依赖于它们不用的方法，比如一个类需要实现A B方法，这时候继承一个接口里面有ABC方法，就不满足接口隔离原则

不遵守接口隔离原则的代码

设计模式-设计原则

// IHouseWork 做饭、扫地、洗衣服
// CleanHouseWork : 扫地、洗衣服
// OtherHouseWork : 做饭
// Nanny : 扫地、洗衣服
// Chef : 做饭package com.study.interfaceIsolation;public class interfaceIsolation1 {public static void main(String[] args) {}
}interface IHouseWork{void cooking();void sweepFloor();void wishClothes();
}class CleanHouseWork implements IHouseWork{@Overridepublic void cooking() {System.out.println("CleanHouseWork 实现了 IHouseWork.cooking");}@Overridepublic void sweepFloor() {System.out.println("CleanHouseWork 实现了 IHouseWork.sweepFloor");}@Overridepublic void wishClothes() {System.out.println("CleanHouseWork 实现了 IHouseWork.wishClothes");}
}class OtherHouseWork implements IHouseWork{@Overridepublic void cooking() {System.out.println("OtherHouseWork 实现了 IHouseWork.cooking");}@Overridepublic void sweepFloor() {System.out.println("OtherHouseWork 实现了 IHouseWork.sweepFloor");}@Overridepublic void wishClothes() {System.out.println("OtherHouseWork 实现了 IHouseWork.wishClothes");}
}// Nanny类， 通过IHouseWork接口依赖CleanHouseWork类
class Nanny{public void dependSweepFloor(IHouseWork i){i.sweepFloor();}public void dependWishClothes(IHouseWork i){i.wishClothes();}
}// Chef类， 通过IHouseWork接口依赖OthterHouseWork类
class Chef{public void dependCooking(IHouseWork i){i.cooking();}
}

遵守接口隔离的代码

设计模式-设计原则

// ICleanHouseWork 扫地、洗衣服
// IOtherHouseWork 做饭
// CleanHouseWork : 扫地、洗衣服
// OtherHouseWork : 做饭
// Nanny : 扫地、洗衣服
// Chef : 做饭package com.study.interfaceIsolation;public class InterfaceIsolation2 {public static void main(String[] args) {Nanny1 n = new Nanny1();Chef1 c = new Chef1();n.dependSweepFloor(new CleanHouseWork1());n.dependWishClothes(new CleanHouseWork1());c.dependCooking(new OtherHouseWork1());}
}interface ICleanHouseWork {void sweepFloor();void wishClothes();
}interface IOtherHouseWork {void cooking();
}class CleanHouseWork1 implements ICleanHouseWork{@Overridepublic void sweepFloor() {System.out.println("CleanHouseWork1 实现了 sweepFloor方法");}@Overridepublic void wishClothes() {System.out.println("CleanHouseWork1 实现了 wishClothes方法");}
}class OtherHouseWork1 implements IOtherHouseWork{@Overridepublic void cooking() {System.out.println("OtherHouseWork1 实现了 cooking方法");}
}class Nanny1{public void dependSweepFloor(ICleanHouseWork i){i.sweepFloor();}public void dependWishClothes(ICleanHouseWork i){i.wishClothes();}
}class Chef1{public void dependCooking(IOtherHouseWork i){i.cooking();}
}

组合优于继承

组合耦合度低，继承耦合度高

网络标签：

相关问题