Ne pas comprendre les sept principes de conception équivaut à apprendre le développement logiciel pour rien

Introduction

Le développement logiciel, qu'il soit front-end ou back-end, que vous utilisiez springboot ou django, uniapp ou mpvue, même la plateforme de connexion à la base de données redis, mabits, hibernate, tous utilisent plus ou moins des principes de conception.
Il est déraisonnable pour vous de dire que vous ne le ferez pas.

Ensuite, je vais vous présenter mes idées après la pratique.提示：代码注释比较有用哦。

Principe de responsabilité unique

Voici le code :

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+"在公路上运行");
    }
}

Amélioré

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+"在公路上运行");
    }
}

Amélioré deux

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+"在水中运行");
    }
}

Principe d'ouverture et de fermeture

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("画矩");
    }
}

Principe de substitution de Liskov

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);
    }
}

Principe de séparation des interfaces

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功能是相同的使用这种方式比较少代码

}

Principe d'inversion de dépendance

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());
    }
}

Amélioré

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());
    }
}

Loi de Déméter

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");
    }
}

Principes de réutilisation synthétique

package compositereuse;

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

Résumer

Comment améliorer le modèle de conception :

• Les éléments de modification indépendants de la classe, en tant que dépendance, n'héritent pas ;
• orienté interface ;
• faible couplage