【设计模式七大原则及Java示例】 _原则

设计模式七大原则及Java示例
CSDN博客地址
项目下载地址
设计模式七大原则
UML图中，绿线标识继承或者实现，白线表示依赖关系
原则并不是孤立存在的，它们相互依赖，相互补充。
单一职能原则
单一职责原则() SRP
单一职责原则好处
代码这里不再做过多的演示
接口隔离原则
客户端不应该依赖它不需要的接口
类间的依赖关系应该建立在最小的接口上
利用马，和鱼的例子还说名。
马需要吃饭和走路
鱼需要吃饭和游动
设计的实现接口如下

文章插图

/*** @Author mabo* @Description接口隔离原则*/public class InterfaceIsolation {//吃interface Eat{public void eat();}//走路interface Walk{public void walk();}//游动interface Swim {public void swim();}//马在吃和走路class Horse implements Eat , Walk{@Overridepublic void eat() {System.out.println("马在吃");}@Overridepublic void walk() {System.out.println("马在走");}}//鱼在吃和游class Fish implements Eat ,Swim{@Overridepublic void eat() {System.out.println("鱼在吃");}@Overridepublic void swim() {System.out.println("鱼在游");}}}

倒转置换原则
依赖倒转（倒置）的中心思想是面向接口编程
依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
使用接口或抽象类的目的是：制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。
倒转置换可以有三种写法
这里用小猫小狗跑来做示例
1.接口作为方法参数

/*** @Author mabo* @Description 依赖倒转* @Description 方法接口作为参数*/public class DependencyInversion1 {private interface Animal {public void run();}private static class Action {public void go(Animal animal) {animal.run();}}private static class Dog implements Animal {@Overridepublic void run() {System.out.println("小狗在跑");}}private static class Cat implements Animal {@Overridepublic void run() {System.out.println("猫在跑");}}public static void main(String[] args) {Action action = new Action();action.go(new Dog());action.go(new Cat());}}

2.接口作为属性，利用构造方法初始化接口

/*** @Author mabo* @Description依赖倒转* @Description类参数为接口*/public class DependencyInversion2 {private interface Animal{public void run();}private static class Action{private Animal animal;/*** @Author mabo* @Description通过构造方法传入接口*/public Action(Animal animal) {this.animal=animal;}public void go() {animal.run();}}private static class Dog implements Animal {@Overridepublic void run() {System.out.println("小狗在跑");}}private static class Cat implements Animal {@Overridepublic void run() {System.out.println("猫在跑");}}public static void main(String[] args) {Action dogAction=new Action(new Dog());dogAction.go();Action catAction=new Action(new Cat());catAction.go();}}

3.接口作为属性，利用set方法初始化接口

/*** @Author mabo* @Description依赖倒转* @Descriptionsetter方法传入接口*/public class DependencyInversion3 {private interface Animal{public void run();}private static class Action{private Animal animal;public void setAnimal(Animal animal) {this.animal = animal;}//通过构造方法传入接口public void go() {animal.run();}}private static class Dog implements Animal {@Overridepublic void run() {System.out.println("小狗在跑");}}private static class Cat implements Animal {@Overridepublic void run() {System.out.println("猫在跑");}}public static void main(String[] args) {Action dogAction=new Action();dogAction.setAnimal(new Dog());dogAction.go();Action catAction=new Action();catAction.setAnimal(new Cat());catAction.go();}}

里氏替换原则

文章插图
里氏替换原则的主要作用
里氏替换原则的定义可以总结如下：

/*** @Author mabo* @Description里氏置换原则*/public class RichterSubstitutionPrinciple {public static void main(String[] args) {Bird bird1 = new Swallow();Bird bird2 = new Sparrow();bird1.setSpeed(120);bird2.setSpeed(120);System.out.println("如果飞行300公里：");try {System.out.println("燕子将飞行" + bird1.getFlyTime(300) + "小时.");System.out.println("几维鸟将飞行" + bird2.getFlyTime(300) + "小时 。");} catch (Exception err) {System.out.println("发生错误了!");}}//鸟类public static class Bird {double flySpeed;public void setSpeed(double speed) {flySpeed = speed;}public double getFlyTime(double distance) {return (distance / flySpeed);}}//燕子类public static class Swallow extends Bird {}//麻雀public static class Sparrow extends Bird {//不应该重写父类方法//public void setSpeed(double speed) {//flySpeed = 0;//}publicvoid getFar(double distance){System.out.println(distance);}}}

合成/聚合复用原则
合成复用原则（ Reuse，CRP）又叫组合/聚合复用原则（/ Reuse ，CARP）
简单理解合成复用就是将现有对象作为当前类的成员变量，开发中很常见
开闭原则
开闭原则
这里用三角形和圆继承图像来说明

/*** @Author mabo* @Description开闭原则*/public class OpenClosePrinciple {static abstract class Sharp{public abstract void paint();}static class DrawingEditor{public void draw(Sharp sharp){sharp.paint();}}static class Rectangle extends Sharp{@Overridepublic void paint() {System.out.println("画一个矩形");}}static class Circle extends Sharp{@Overridepublic void paint() {System.out.println("画一个圆形");}}public static void main(String[] args) {DrawingEditor drawingEditor=new DrawingEditor();drawingEditor.draw(new Circle());drawingEditor.draw(new Rectangle());}}

迪米特法则
迪米特法则又叫做最少知道原则，就是说一个对象应当对其它对象有尽可能少的了解，不要和陌生人说话。
强调只和朋友说话，不和陌生人说话。这里的朋友指的是:出现在成员变量，方法输入，输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。
迪米特法则初衷在于降低类之间的耦合。由于每个类尽量减少对其它类的依赖，因此。很容易使得系统的功能模块独立，相互之间不存在(或很少有)依赖关系。
错误的例子

/*** @Author mabo* @Description迪米特法则* @Description直接朋友 要求依赖的类是成员变量，方法参数，方法返回值* @Description最好将自己依赖的类作为成员变量，叫做类之间是朋友关系* @Description对自己依赖的类，最好直接调用类的方法，而不是将类作为局部变量*/public class DemeterBadExample {private static class Student{private List list=new ArrayList();public List getList() {return list;}public void setList(List list) {this.list = list;}public void addList(){list.add(1);}}public static void main(String[] args) {Student student=new Student();student.addList();List list = student.getList();int size = list.size();System.out.println(size);}}

正确写法
【【设计模式七大原则及Java示例】】

/*** @Author mabo* @Description迪米特法则* @Description直接朋友 要求依赖的类是成员变量，方法参数，方法返回值* @Description最好将自己依赖的类作为成员变量 ， 叫做类之间是朋友关系* @Description对自己依赖的类，最好直接调用类的方法，而不是将类作为局部变量*/public class DemeterPrinciple {//将需要依赖的类作为成员变量private static Student student=new Student();private static class Student{private List list=new ArrayList();public List getList() {return list;}public void setList(List list) {this.list = list;}public void addList(){list.add(1);}public int size(){return list.size();}}public static void main(String[] args) {student.addList();//List list = student.getList();//int size = list.size();int size = student.size();System.out.println(size);}}