不懂七大设计原则等于白学软件开发篇

前置介绍

软件开发，不管是前端还是后端，不管你用的是springboot还是django,uniapp还是mpvue，哪怕是数据库连接平台redis、mabits、hibernate,都或多或少用了设计原则。
你说你不会，不合理呀。

接下来给大家介绍一下我练习后的感悟。 提示：代码注释提到了原则的含义哦。

单一职责原则

代码奉上：

package singleresponsbility;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName singleresponsbility ：一个类只能有一种职责 =》一个方法只能有一个职责。
 * @data 2020-09-06 09:
 */
public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("飞机");
        vehicle.run("汽车");
    }
}
/*违反了单一职责原则。    
* 解决：
* 根据不同交通方法，分解成不同类
* */
class Vehicle{
    public void run(String args) {
        System.out.println(args+"在公路上运行");
    }
}

改良一

package singleresponsbility;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName singleresponsbility
 * @data 2020-09-06 09:
 */
public class SingleResponsibility2 {
    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.run("汽车");
        Aircle2 aircle2 = new Aircle2();
        aircle2.run("飞机");

    }
}

/*遵守单一职责原则，但是需要改动测试和执行类。
* 解决：
* 直接改动Vehicle类
* */
class Vehicle2{
    public void run(String args) {
        System.out.println(args+"在公路上运行");
    }
}

class Aircle2{
    public void run(String args) {
        System.out.println(args+"在公路上运行");
    }
}

改良二

package singleresponsbility;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName singleresponsbility
 * @data 2020-09-06 09:
 */
public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle3 vehicle = new Vehicle3();
        vehicle.airRun("飞机");
        vehicle.run("汽车");
    }
}

/*在类上没有遵守单一职责原则，但是在方法上遵守单一职责原则
* 优点：
* 改变代码不大，对增加开发，对修改关闭
* */
class Vehicle3{
    public void run(String args) {
        System.out.println(args+"在公路上运行");
    }
    public void airRun(String args) {
        System.out.println(args+"在天空运行");
    }
    public void waterRun(String args) {
        System.out.println(args+"在水中运行");
    }
}

开闭原则

package opencloseeprinciple;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName opencloseeprinciple
 * @described 对拓展开放，对修改关闭 =>将共有方法抽象出接口。
 * @data 2020-09-06 14:07
 */
public class OpenClosed1 {
    public static void main(String[] args) {
        Shape1 circle = new Circle();
        Shape1 rectangle = new Rectangle();
        new GraphicCreate().drawShape(circle);
        new GraphicCreate().drawShape(rectangle);
        //添加新的shape对象不改变其他实现类
    }
}

class GraphicCreate{
    public void drawShape(Shape1 s){
        s.drawShape();
    }
}

interface Shape1{
    public void drawShape();
}

class Circle implements Shape1{
    public void drawShape(){
        System.out.println("画圆");
    }
}

class Rectangle implements Shape1{
    public void drawShape(){
        System.out.println("画矩");
    }
}

里氏置换原则

package liskovsubstitution;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName liskovsubstitution：
 * @describe（子类不要随意修改父类；继承造成程序有侵入性，可移植性降低，尤其不能修改父类。）
 * @describe  =》所有引用父子类的都使用相同的基类对象，适当用聚合、组合、依赖解决问题；子类不要重写父类方法。
 * @data 2020-09-06 13:
 */
public class Substitution {
    public static void main(String[] args) {
        Sus sus = new Sus();
        System.out.println(sus.add(2,3));
    }
}

//采用聚合等方式避免重写
class Add {
    public int add(int a,int b)
    {
        return a+b;
    }
}
class Sus{

    private Add a = new Add();
    //不继承不会重写A
    public int add(int a,int b){
        //使用组合完成功能实现
        return this.a.add(a,b);
    }
}

接口隔离原则

package interfacesegregation;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName interfacesegregation 一个雷对另一个类的依赖建立在最小的程度上
 * @data 2020-09-06 10:
 */
public class segregation {
    public static void main(String[] args) {
        A a = new A();
        a.operation1();
        a.operation4();

        C c = new C();
        c.operation2();
        c.operation3();
    }
}

//接口1
interface Interface1{
    void operation1();
}


//接口2
interface Interface2{
    void operation2();
    void operation3();
}


//接口3
interface Interface3{
    void operation4();
    void operation5();
}

class B implements Interface1,Interface3{

    @Override
    public void operation1() {
        System.out.println("B实现1");
    }

    @Override
    public void operation4() {
        System.out.println("B实现4");
    }

    @Override
    public void operation5() {
        System.out.println("B实现50");
    }
}

class C implements Interface2,Interface1{

    @Override
    public void operation1() {
        System.out.println("C 实现 1");
    }

    @Override
    public void operation2() {
        System.out.println("C 实现 2");
    }

    @Override
    public void operation3() {
        System.out.println("C 实现 3");
    }
}

class A extends B{//如果AB功能是相同的使用这种方式比较少代码

}

依赖倒置原则

package dependenceinversion;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName dependenceinversion: 细节依赖抽象；具体类实现抽象；高层与底层模块依赖抽象；中心思想=》依赖接口编程。
 * @data 2020-09-06 11:
 */
public class Inversion1 {
    public static void main(String[] args) {
        /*该方式只能接受邮箱信息，不能接受其他类比如微信、qq信息
        * 优化：
        * 对接受信息抽象储接口
        * */
        Persion1 persion = new Persion1();
        Email1 email1 = new Email1();
        persion.receive(email1);
    }
}


class Email1{
    public String getInfo(){
        return "电子邮件信息";
    }
}

class Persion1{
    public void receive(Email1 email1){
        System.out.println("接收到："+email1.getInfo());
    }
}

改良一

package dependenceinversion;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName dependenceinversion: 细节依赖抽象；具体类实现抽象；高层与底层模块依赖抽象；中心思想=》依赖接口编程。
 * @data 2020-09-06 11:
 */
public class Inversion2 {
    public static void main(String[] args) {
        /*该方式能接受邮箱信息及其他类比如微信、qq信息
        * 优点：
        * 对信息进行抽象实现任意组装
        * */
        //接口方式
        Persion2 persion = new Persion2();
        EInfo email1 = new Email2();
        EInfo wchat = new Wechat();
        persion.receive(email1);
        persion.receive(wchat);

        //构造方法方式
        EInfo3 info3 = new Email3();
        Persion3 persion3 = new Persion3(info3);
        persion3.receive();

        //set方式
        EInfo4 info4 = new Wechat4();
        Persion4 persion4 = new Persion4();
        persion4.setInfo(info4);
        persion4.receive();
    }
}


//抽象接口方式
class Email2 implements EInfo{
    public String getInfo(){
        return "电子邮件信息";
    }
}

class Wechat implements EInfo{
    public String getInfo(){
        return "微信信息";
    }
}

interface EInfo{
    String getInfo();
}
class Persion2{
    public void receive(EInfo info){
        System.out.println("接收到："+info.getInfo());
    }
}




//构造方法方式
class Email3 implements EInfo3{
    public String getInfo(){
        return "电子邮件信息";
    }
}

class Wechat3 implements EInfo3{
    public String getInfo(){
        return "微信信息";
    }
}
interface EInfo3{
    String getInfo();
}

class Persion3{
    private EInfo3 info;

    public Persion3(EInfo3 info){
        this.info =info;
    }
    public void receive(){
        System.out.println("接受到："+this.info.getInfo());
    }
}



//set方式
class Email4 implements EInfo4{
    public String getInfo(){
        return "电子邮件信息";
    }
}

class Wechat4 implements EInfo4{
    public String getInfo(){
        return "微信信息";
    }
}
interface EInfo4{
    String getInfo();
}

class Persion4{
    private EInfo4 info;

    public void setInfo(EInfo4 info) {
        this.info = info;
    }

    public void receive(){
        System.out.println("接受到："+this.info.getInfo());
    }
}

迪米特法则

package demeterprinciple;

import java.util.ArrayList;
import java.util.List;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName demeterprinciple
 * @describe 对象之间应保持最少了解，即减少耦合=》只与有耦合的对象通信，陌生的类不要以局部变量出现(成员变量，方法参数，方法返回值)，耦合方式：依赖（弱关联，局域变量，方法形参）、关联（成员变量）、组合（has a）、聚合（强关联）、
 * @data 2020-09-06 14:
 */
public class demeter1 {
    public static void main(String[] args) {

        Depatrment allDep = new AllDep();
        Depatrment schDep = new SchDep();
        School school = new School();
        school.setDepatrment(allDep);
        school.setDepatrment(schDep);
        school.findDep();
    }
}

class School{
    private List<Depatrment> depatrment = new ArrayList<Depatrment>();

    public void setDepatrment(Depatrment depatrment) {
        this.depatrment.add(depatrment);
    }

    public void findDep(){
        for (Depatrment de :this.depatrment){
            de.getID();
        }
    }
}

interface Depatrment{
    public  void  getID();
}

class AllDep implements Depatrment{

    @Override
    public void getID() {
        System.out.println("总部ID");
    }
}

class SchDep implements Depatrment{


    @Override
    public void getID() {
        System.out.println("学院ID");
    }
}

合成复用原则

package compositereuse;

/**
 * @author yzq
 * @projectName designdemo
 * @packageName compositereuse
 * @describe 尽量使用合成/聚成，不使用继承
 * @data 2020-09-06 16:05
 */
public class Reuse1 {
}

总结

设计模式怎么搞更好：

• 类独立出变化项，作为依赖，不要继承；
• 面向接口；
• 低耦合