¿Los seis principios de diseño de los patrones de diseño de Java y su relación?

Nombre del patrón	definición
Principio de responsabilidad única	Una clase solo es responsable de las responsabilidades correspondientes de un área
Principio de apertura y cierre.	La entidad de software está abierta a la expansión y cerrada a la modificación.
Sustitución de Richter	Todas las referencias a la clase base se pueden llamar de forma transparente a sus subclases.
Inyección de dependencia	La abstracción no debe depender de los detalles y los detalles deben depender de la abstracción.
Aislamiento de interfaz	Use múltiples interfaces dedicadas, no use una interfaz general
Principio de reutilización sintético	No use herencia al reutilizar, intente usar composición / relación compuesta
Principios de Miditra	Una experiencia de software que reduce la interacción con otras entidades.

Principio de responsabilidad única

单一职责原则，一个类、模块、方法承担一个区域的相应职责，避免多个职责相互交叉，导致修改其中一个职责的时候，影响其他职责。
__单一职责优点：__

• Reducir la complejidad
• Mejorar la legibilidad y la facilidad de mantenimiento
• Reducir el riesgo causado por el
  ejemplo de cambio
  DemoTest Este ejemplo es el principio de responsabilidad única correcto

public class DemoTest{
    
    
   public static void main(String[] args){
    
    
   	Demo d =new Demo();
   	d.run("大侠”)；
   	d.run("汉堡");
   	
   }
}
class Demo{
    
    
   public void run(String active){
    
    
   	System.out.println(active)
   }
}

Ejemplo de
principio de responsabilidad única incorrecto

public class ErrorTest{
    
    
	public static void main(String[] args){
    
    
		Errord =new Error();
		d.superMan("大侠”)；
		d.hanburger("汉堡");
		
	}
}
class Error{
    
    
	public void superMan(String active){
    
    
		System.out.println(active)
	}
	public void hamburger(String active){
    
    
		System.out.println(active)
	}
}

Principio de apertura y cierre.

开闭原则是指一个实体如类、方法、模块应该只提供扩展，不提供修改。

Ventaja:

1. Mantener la estabilidad del producto;
2. No afecta la operación de prueba del código original;
3. Haga que el código sea más modular y fácil de mantener;
4. Mejorar la eficiencia del desarrollo;

Ejemplo:

	/**
	 *顶层定义一个接口，获取家具信息的接口方法
	 */
	public interface Furniture{
    
    
		public String getName();
		public double getPrice();
		public String getBrand();
		public double getDiscounts();
		public String getMaterials();
		public String getColor();
	}

public class Desk implements Furniture{
    
    
    private double price;
    private String brand;
    private String materials;
    private String color;
    private double width;
    private double height;

    public Desk( double price, String brand, String materials, String color, double width, double height) {
    
    
        this.price = price;
        this.brand = brand;
        this.materials = materials;
        this.color = color;
        this.width = width;
        this.height = height;
    }


    @Override
    public double getPrice() {
    
    
        return price;
    }

    @Override
    public String getBrand() {
    
    
        return brand;
    }

    @Override
    public String getMaterials() {
    
    
        return materials;
    }

    @Override
    public String getColor() {
    
    
        return color;
    }

    @Override
    public double getWidth() {
    
    
        return width;
    }

    @Override
    public double getHeight() {
    
    
        return height;
    }
}

class BSPHDesk extends Desk {
    
    
    private double discount;
    public BSPHDesk(double discount, double price, String brand, String materials, String color, double width, double height) {
    
    
        super(price, brand, materials, color, width, height);
        this.discount = discount;
    }


    public double getDiscountPrice() {
    
    
        return getPrice() * discount;
    }
}

public class ExampleUnitTest {
    
    
    @Test
    public void addition_isCorrect() throws Exception {
    
    
        BSPHDesk desk = new BSPHDesk(0.5,5000,"BSPH","实木","白色",500,600);
        desk.getDiscountPrice();
        System.out.println("原有价格:"+desk.getPrice()+","+"折扣价格:"+desk.getDiscountPrice());
    }
}

Principio de sustitución de Richter

里氏代换原则 是指 一个实体如果使用父类，那么一定适用于子类，如果使用子类，那么他不能够使用父类。

ventaja

1. Mejore la reutilización del código, la subclase tiene los métodos y atributos de la clase padre;
2. Mejorar la escalabilidad del código y conservar sus propias características;

ejemplo:

public class LSPBase {
    
    
    /**
     * 父类方法运行
     */
    public void parentRun(){
    
    
        System.out.println("这个是里氏代换 父类方法 ");
    }
}
public class LSPChild extends LSPBase{
    
    

    @Override
    public void parentRun() {
    
    
        System.out.println("里氏代换覆盖");
    }

    public void childRun(String content){
    
    
        System.out.println("childRun里氏代换覆盖"+content);
    }
}

public class ExampleUnitTest {
    
    
    @Test
    public void addition_isCorrect() throws Exception {
    
    
        LSPBase base = new LSPBase();
        run(base);//错误
        LSPChild child = new LSPChild();
        baseRun(child);//非错误
    }
    private void baseRun(LSPBase base){
    
    
        base.parentRun();
    }
    private void run(LSPChild child) {
    
    
        child.parentRun();
    }
}

Principio de inyección de dependencia

依赖注入原则 不要依赖于具体实现，要依赖于抽象。
1）高层模块不应该依赖底层模块，两者应该都依赖于抽象（抽象类和接口）；
2）抽象（类或接口）不应该依赖于具体细节(实现类)；
3）细节（具体类或接口）应该依赖于抽象

ventaja:

1. Separación de intereses;
2. El código repetitivo en la clase de aplicación se reduce, porque todo el trabajo para inicializar dependencias lo maneja el componente inyector;
3. Los componentes accesorios facilitan la expansión de la aplicación
4. Es fácil realizar pruebas unitarias a través de objetos simulados

Desventajas:

1. El uso excesivo dificultará su mantenimiento;

No use la inyección de dependencia

public class NonDependency {
    
    
    public void send(String message, String title) {
    
    
        System.out.println("这个消息内容:" + message + ",标题:" + title);
    }
}

public class NonDependencyApplication {
    
    
    NonDependency dependency = new NonDependency();

    public void receive(String message, String title) {
    
    
        dependency.send(message, title);
    }
}

public class ExampleUnitTest {
    
    
    @Test
    public void addition_isCorrect() throws Exception {
    
    
        NonDependencyApplication application = new NonDependencyApplication();
        application.receive("这个市各消息","这个市各标题");
    }
}

Usar inyección de dependencia

public interface Dependency {
    
    
    void send(String message, String title);
}
class EmailDependency implements Dependency {
    
    
    @Override
    public void send(String message, String title) {
    
    
        System.out.println("Email sent to "+message+ " with title="+title);
    }
}
public class SMSSDependency implements Dependency{
    
    
    @Override
    public void send(String message, String title) {
    
    
        System.out.println("Email sent to "+message+ " with title="+title);
    }
}
public class ExampleUnitTest {
    
    
    @Test
    public void addition_isCorrect() throws Exception {
    
    
        EmailDependency email= new EmailDependency();
        email.send("这个是一个邮箱内容 ","这个是一个邮箱标题");
        SMSSDependency smss = new SMSSDependency();
        email.send("这个是一个smss内容 ","这个是一个smss标题");

    }
 
}