依赖注入(Dependence Inversion)的简单介绍

介绍

在面向对象开发时，经过会碰到对象A调用对象B，所谓的依赖，举个例子说明，一个类Person，另一个类Car，如果Person的某个方法比如说drive，需要引用Car，则称Person类依赖于 Car类，延伸到对象，这种依赖关系依然成立，比如说Person类的对象boy依赖于Car类的对象toyota。

Car的工厂模式

首先使用工厂模式来实现Car

步骤1

创建一个接口:

public interface Car {
    void run();
    void stop();
}

步骤2

创建实现接口的实体类。

Bmw.java

public class Bmw implements Car {

    public void run() {
        System.out.println("Bmw is running.");
    }

    public void stop() {
        System.out.println("Bmw is stop.");
    }
}

Audi.java

 public void run() {
        System.out.println("Audi is running.");
    }

    public void stop() {
        System.out.println("Audi is stop.");
    }

Toyota.java

public class Toyota implements Car {

    public void run() {
        System.out.println("Toyota is running.");
    }

    public void stop() {
        System.out.println("Toyota is stop.");
    }
}

步骤3

创建一个工厂，生成基于给定信息的实体类的对象。
CarFactory.java

public Car getCar(String carName){

        if(carName == null){
            return null;
        }

        if(carName.equalsIgnoreCase("TOYOTA")){
            return new Toyota();
        }else if(carName.equalsIgnoreCase("AUDI")){
            return new Audi();
        }else if(carName.equalsIgnoreCase("BMW")){
            return new Bmw();
        }else{
            return null;
        }
    }
}

原始调用

假定代码如下：

package di;

import factory.Car;
import factory.CarFactory;

/**
 * @Author: qiaog[qiaog@kayak.com]
 * @Date: 2019-02-20 17:12
 * @Description:
 * @Modified By:
 */
public class Person {

    private String name;
    
    private String sex;

    /**
     * 原始的对象调用方式
     */
    
    public void drive(){
        CarFactory carFactory = new CarFactory();

        Car toyota = carFactory.getCar("TOYOTA");
        
        toyota.run();
        
        toyota.stop();
    }
}

这其中的依赖关系，就导致了Person的对象boy需要负责对象toyota的创建，甚至是整个生命周期的管理，而这样显然会带来耦合度高，不易维护等缺点，比如说要让这个男孩驾驶一辆Audi，则还需要修改类Person的代码。