设计模式学习笔记（3）——设计模式常用的七大原则1

设计模式常用的七大原则有:

• 单一职责原则(SRP)
• 开放-封闭原则（OCP）——面向对象设计的终极目标
• 里氏代换原则（LSP）
• 依赖倒转原则(DIP)
• 合成/聚合复用原则(CARP)
• 接口隔离原则（ISP）
• 迪米特法则

一、单一职责原则
方法一：
class Vehicle{
public void run(String vehicle) {
System.out. println(vehicle + “在公路上跑”);} }
public class singleResponsibility {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
vehicle.run(“摩托车”);
vehicle.run(“汽车”);
vehicle.run(“飞机”);}
}
结果：
摩托车在公路上跑
汽车在公路上跑
飞机在公路上跑
分析：
显然，飞机在公路上跑这个结果不是我们想要的。通过分析可以知道，run方法违反了单一职责原则，那么我们可以改成不同运行方式对应的不同的类。
方法2：
class RoadVehicle {
public void run(String vehicle) {
System .out. println(vehicle + “在公路上跑”); }
}
class AirVehicle {
public void run(String vehicle) {
System.out. println(vehicle + “在天空中飞”); }
}
class WaterVehicle {
public void run(String vehicle) {
System.out. println(vehicle + “在水里游”); }
}
public class singleResponsibility {
public static void main(String[] args) {
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run(“摩托车”);
roadVehicle.run(“汽车”);
AirVehicle airVehicle = new AirVehicle();
airVehicle.run(“飞机”);
WaterVehicle waterVehicle = new WaterVehicle();
waterVehicle.run(“轮船”);
} }
结果：
摩托车在公路上跑
汽车在公路上跑
飞机在天空中飞
轮船在水里游
分析：方法2我们可以看到，虽然实现了想要的效果，也符合单一职责原则，但是改动比较大。我们保留并修改Vehicle类，改动的代码会比较少。
方法3：
class Vehicle2 {
public void run(String vehicle) { //不变
System .out. println(vehicle +“在公路上跑”);
}
public void runAir(String vehicle) { //增加
System.out. println(vehicle + “在天空中飞”);
}
public void runWater(String vehicle) { //增加
System.out. println(vehicle + “在水里游”);
}
}public class singleResponsibility {
public static void main(String[] args) {
Vehicle2 Vehicle = new Vehicle2();
Vehicle.run(“摩托车”);
Vehicle.run(“汽车”);
Vehicle.runAir(“飞机”);
Vehicle.runWater(“轮船”);
}
}
结果：
摩托车在公路上跑
汽车在公路上跑
飞机在天空中飞
轮船在水里游
分析：
这种修改方法没有对原来的类做大的修改，只是增加方法；增加的部分不影响原有部分，降低了变更引起的风险；这里在类这个级别上没有遵守单一职责原则，但是在方法级别上，仍然是遵守单一职责。
二、开放-封闭原则
方式1
class Rectangle{
void draw(){ System.out.println(“矩形”); } }
class Circle {
void draw(){ System.out.println(“圆形”); } }
class Triangle { //新增三角形——肯定要改
void draw(){ System.out.println(“三角形”); } }
public class graphDraw {
public static void main(String[] args) {
GraphicDraw graphicdraw=new GraphicDraw();
graphicdraw.drawgraph(2); //客户端肯定要改
}
}
分析：违反了开闭原则，增加图形种类时修改多。
方式2：
//Shape类，基类
abstract class Shape {
public abstract void draw(); //抽象方法
}
class GraphicDraw { //新增绘制图形不需修改此类
void drawgraph(Shape s){
s.draw();
}
}
class Rectangle extends Shape {
void draw(){ System.out.println(“矩形”); } }
class Circle extends Shape {
void draw(){ System.out.println(“圆形”); } }
class Triangle extends Shape { //新增三角形
void draw(){ System.out.println(“三角形”); } }
public class graphDraw {
public static void main(String[] args) {
GraphicDraw graphicdraw=new GraphicDraw();
graphicdraw.drawgraph(new Circle());
graphicdraw.drawgraph(new Rectangle());
graphicdraw.drawgraph(new Triangle());
} }
分析：画图类GraphicDraw不出现具体的类，
用抽象类Shape。这样使用方的代码就不需要修改，满足开
闭原则。
三、里氏代换原则
一个软件使用的是一个父类的话，一定适用于其子类，而察觉不出父类对象和子类对象的区别。也即是说，在软件里面，把父类替换成它的子类，程序不会有变化，简单地说，子类型必须能够替换掉它们的父类型。
例如：
package liskov;
//创建-个更加基础的基类
class Base {
//把更加基础的方法和成员写到Base类
}
// A类
class A extends Base {
//返回两个数的差
public int func1(int num1, int num2) {
return num1 - num2; }
}
class B extends Base{
A a=new A();
public int func1(int a,int b){
return a+b; }
public int func2(int a, int b){
return func1(a,b)+9; }
public int func3(int a, int b){
return this.a.func1(a,b); }
}

public class Liskov {
public static void main(String[] args) {
A a = new A();
System.out.println(“11-3=” +a.func1(11,3));
System.out.println(“1-8=”+a.func1(1,8));
System.out.println ("-------");
B b= new B();
//因为B类不再继承A类，因此调用者，不会再func1是求减法
//调用完成的功能就会很明确
System. out.println(“11+3=” + b. func1(11, 3));//这里本意是求出11+3
System. out.println(“1+8=” + b.func1(1, 8));// 1+8
System. out.println(“11+3+9=” + b.func2(11, 3));
//使用组合仍然可以使用到A类相关方法
System. out.println(“11-3=” + b.func3(11, 3));// 这里本意是求出11-3
}
}
四、依赖倒转原则
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email()); }
}
class Email{
public String getInfo() {
return "电子邮件信息: hello world "; }
}
/* Person 类 接受消息,将Email类 作为参数 产生了依赖

• 如果 参数发生变化,即接受的是微信 或短信 整个方法需要改动 */
  class Person{
  public void receive(Email email) {
  System.out.println(email.getInfo()); }
  }
  分析
  1.如果我们获取的对象是微信,短信等,如果新增类，同时Peronson也要增加相应的接收方法
  2.解决:引入一个抽象的接口IReceiver,表示接收者，这样Person类与接口IReceiver发生依赖因为Emai1, WeiXin等属于接收的范围，它们各自实现IReceiver接口, 这样就符合依赖倒转原则。

/*定义接受的接口 */
interface IReciver{
public String getInfo();
}
class Email implements IReciver{
public String getInfo() {
return "电子邮件信息: hello world "; }
}
class WenXin implements IReciver{
public String getInfo() {
return "微信信息: hello WenXin "; }
}

/* Person 类 接受消息 将IReciver 接口 作为参数 产生了依赖 */
class Person{
public void receive(IReciver reciver) {
System.out.println(reciver.getInfo()); }
}
public class DependecyInversion {
public static void main(String[] args) {
Person person = new Person();
person.receive(new Email());
//传入不同实现类 实现不同的接受
person.receive(new WenXin()); }
}