单一职责原则

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

• 降低复杂度
• 提高可读性，维护性
• 降低变更引起的风险
  例子
  DemoTest这个例子是正确的单一职责原则

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

例子
错误的单一职责原则

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

开闭原则

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

优势:

1. 保持产品的稳定性；
2. 不影响原有代码测试运行；
3. 使代码更具模块化，方便维护；
4. 提高开发效率；

示例:

	/**
	 *顶层定义一个接口，获取家具信息的接口方法
	 */
	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());
    }
}

里氏代换原则

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

优点

1. 提高代码的重用性，子类拥有父类的方法和属性；
2. 提高了代码的扩展性，保留了自己的特性；

例子：

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

依赖注入原则

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

优点：

1. 关注点分离；
2. 应用程序类中的样板代码减少，因为所有用于初始化依赖性的工作都由注入器组件处理；
3. 配件组件使应用易扩展
4. 通过模拟对象来单元测试会很简单

缺点：

1. 过度使用会导致很难维护；

不使用依赖注入

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("这个市各消息","这个市各标题");
    }
}

使用依赖注入

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标题");

    }
 
}

最后

以上就是勤恳玉米为你收集整理的Java设计模式的六大设计原则以及他们的关系？单一职责原则开闭原则里氏代换原则依赖注入原则的全部内容，希望文章能够帮你解决Java设计模式的六大设计原则以及他们的关系？单一职责原则开闭原则里氏代换原则依赖注入原则所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。