设计模式七大原则03---依赖倒转原则
一、依赖倒转原则(Dependence Inversion Principle)特点
1、依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多.以抽象为基础搭建的架构比以细节为基础的架构要稳定的多.在 java 中,抽象指的是接口或抽象类,细节就是具体的实现类
2、高层模块不应该依赖低层模块,二者都应该依赖其抽象
3、抽象不应该依赖细节,细节应该依赖抽象
4、使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
5、依赖倒转(倒置)的中心思想是面向接口编程
二、案例演示
完成 Person 接收消息的功能
方式一、普通实现
public class DesignPatternPrinciple {
public static void main(String[] args) {
Person person = new Person();
person.receiveMessage(new Email());
}
}
class Person{
public void receiveMessage(Email email){
email.receive();
}
}
class Email {
public void receive(){
System.out.println("接收 email 信息");
}
}
上面的代码已经完成了我们的需求,但是存在一个问题,我们 Person 类里面的 receiveMessage(Email email) 方法参数类型是 Email 类型的,它代表的意思是只能接收 Email 类型的消息,如果我这个时候想接收微信消息、QQ 消息,那么就要继续重写 receiveMessage() 方法,这样就比较麻烦.所以我们需要使用依赖倒置来改进
方式二、依赖倒置
public class DesignPatternPrinciple {
public static void main(String[] args) {
Person person = new Person();
person.receiveMessage(new Email());
person.receiveMessage(new Wechat());
person.receiveMessage(new QQ());
}
}
interface Message {
public abstract void receive();
}
class Person {
public void receiveMessage(Message message) {
message.receive();
}
}
class Email implements Message {
public void receive() {
System.out.println("接收 email 信息");
}
}
class Wechat implements Message {
public void receive() {
System.out.println("接收 wechat 信息");
}
}
class QQ implements Message {
public void receive() {
System.out.println("接收 qq 信息");
}
}
使用依赖倒置改进之后,扩展起来也比较方便了.
三、依赖关系传递的三种方式
依赖是可以传递的,A对象依赖B对象,B对象又依赖C对象,C对象又依赖D对象......生生不息,依赖不止.要记住一点：只要做到抽象依赖,即使多层的依赖传递也无所畏惧.对象的依赖关系主要有三种方式来传递.
1、接口传递
在接口的方法中声明依赖对象,该方法也叫做接口注入.
public class DesignPatternPrinciple {
public static void main(String[] args) {
Idriver idriver = new Driver();
idriver.drive(new Benz());
idriver.drive(new Porsche());
}
}
interface Icar {
public void run();
}
interface Idriver {
public void drive(Icar icar);
}
class Benz implements Icar {
@Override
public void run() {
System.out.println("Benz run...");
}
}
class Porsche implements Icar {
@Override
public void run() {
System.out.println("Porsche run...");
}
}
class Driver implements Idriver {
@Override
public void drive(Icar icar) {
icar.run();
}
}
2、构造方法传递
在类中通过构造函数依赖对象,安装依赖注入的说法,这种方式叫做构造函数注入.
public class DesignPatternPrinciple {
public static void main(String[] args) {
Idriver benz = new Driver(new Benz());
benz.drive();
Idriver porsche = new Driver(new Porsche());
porsche.drive();
}
}
interface Icar {
public void run();
}
interface Idriver {
public void drive();
}
class Benz implements Icar {
@Override
public void run() {
System.out.println("Benz run...");
}
}
class Porsche implements Icar {
@Override
public void run() {
System.out.println("Porsche run...");
}
}
class Driver implements Idriver {
private Icar icar;
public Driver(Icar icar){
this.icar = icar;
}
@Override
public void drive() {
icar.run();
}
}
3、setter 方法传递
在抽象中设置 setter 方法声明依赖关系,依照依赖注入的说法.这个是 setter 依赖注入
public class DesignPatternPrinciple {
public static void main(String[] args) {
Driver benzDriver = new Driver();
benzDriver.setIcar(new Benz());
benzDriver.drive();
Driver PorsDriver = new Driver();
PorsDriver.setIcar(new Porsche());
PorsDriver.drive();
}
}
interface Icar {
public void run();
}
interface Idriver {
public void drive();
}
class Benz implements Icar {
@Override
public void run() {
System.out.println("Benz run...");
}
}
class Porsche implements Icar {
@Override
public void run() {
System.out.println("Porsche run...");
}
}
class Driver implements Idriver {
private Icar icar;
public void setIcar(Icar icar) {
this.icar = icar;
}
@Override
public void drive() {
icar.run();
}
}
四、依赖倒置注意事项
1、低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好
2、变量的声明类型尽量是抽象类或接口,,这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化
3、继承时遵循里氏替换原则
