Java 6大设计原则(三)---依赖倒置原则

x33g5p2x  于2021-03-13 发布在 Java  
字(2.2k)|赞(0)|评价(0)|浏览(183)

英文名称(Dependence Inversion Principle ,DIP)

定义:高层模块不应该依赖低层模块,应该依赖其抽象,抽象不应该依赖其细节,细节应该依赖其抽象。

这句话在java中的理解

低层模块:具体细化的java类

高层模块:是由多个低层模块组成的。

抽象:指的是接口或者抽象类

依赖:存在类A的一个方法S,S传入的参数是另一个类B的实例,那么类A依赖于类B 我的理解---在项目开发中尽量将相同模块细化,类与类之间减少依赖关系,应该依赖其抽象类或者接口。

一个反面的例子:
----一个司机开宝马车。
按照常规的思维:定义一个司机类(Driver)有个void drive(BMW bmw)方法。该方法需要传入宝马车实例,

定义一个宝马车类(BMW) 有一个run方法。

public class DIPTest {
	public static void main(String[] args) {
		new Driver().drive(new BMW());
	}
}
class Driver{
	public void drive(BMW bmw){
		System.out.println("司机开车...");
		bmw.run();
	}
}
class BMW{
	public void run(){
		System.out.println("宝马车开动了....");
	}
}

更改需求,司机现在改开奔驰了,那么如果在这个类的基础上更改,我们需要给司机提供一个drive(Benz b)的方法。

同时再提供一个Benz类,提供一个run方法。那么就存在类之间的依赖性太大,不利于类的拓展。

----解决方案

让细节类依赖其抽象,宝马车、奔驰车都具有run()方法,司机都具有drive(Car car)的方法。可以将共同的方法和类抽象成接口。

这样设计的好处,可以将司机和车分为两个模块进行开发,两者之间的依赖关系存在于接口,而具体实现类依赖于接口。这样在分工协作时,只需要各自定义好接口的操作方法就可以了。并且类的扩展性也大大提高。

package hpu.lzl.dip;

public class DIPTest2 {
    public static void main(String[] args) {
		IDriver d = new Driver2();
		ICar ic = new BenzCar();
		d.Driver(ic);
		System.out.println("----------------");
		d.Driver(new BMWCar());
	}
}
interface IDriver{
	public void Driver(ICar car); 
}
interface ICar{
	public void run();
}
class Driver2 implements IDriver{
	@Override
	public void Driver(ICar car) {
		System.out.println("司机开车.....");
		car.run();
	}
}
class BMWCar implements ICar{

	@Override
	public void run() {
		System.out.println("宝马车开动了....");
	}
	
}
class BenzCar implements ICar{

	@Override
	public void run() {
		System.out.println("奔驰车开动了....");
	}
	
}

依赖的三种写法

1、构造函数传递依赖

interface IDriver{
	public void drive(); 
}

class Driver2 implements IDriver{
	private ICar car;
	public Driver2(ICar car){
		this.car = car;
	}
	@Override
	public void drive() {
		System.out.println("司机发动车了...");
		car.run();
	}
}

2、setter方法传递依赖

interface IDriver{
	public void drive(); 
	public void setCar(ICar car);
}

class Driver2 implements IDriver{
	private ICar car;
	@Override
	public void drive() {
		System.out.println("司机开车.....");
		car.run();
	}

	@Override
	public void setCar(ICar car) {
		// TODO Auto-generated method stub
		this.car = car;
	}
}

3、接口传递依赖

interface IDriver{
	public void drive(ICar car); 
}

class Driver2 implements IDriver{
	@Override
	public void drive(ICar car) {
		System.out.println("司机发动车了...");
		car.run();
	}
}

我对依赖倒置的理解

依赖倒置首先要求类之间具有联系,将其联系抽象成接口或者抽象类,这样降低类之间的依赖。从而产生抽象类或接口之间的依赖,将具体事物时间的依赖转化成抽象接口的依赖。

相关文章