本来我接受各种参数来构造一个对象，现在只接受一个参数——已经实例化的对象
可以参考知乎的回答：https://www.zhihu.com/question/32108444

大白话来讲，就是当类A需要用到类B的实例对象b的时，不需要在类A自己主动new一个对象b，而是通过参数传递的方式，也就叫做依赖注入的方式获得。

举例

1.没有使用依赖注入

类TaxCalculate：计算应该上缴多少税
类TaxReport：显示上缴多少税
类Main：程序入口

public class TaxCalculate {
  private double income;
  public TaxCalculate(int income) {
    this.income = income;
  }
  public double calculateTax (){
    return income * 0.3;
  }
}

public class TaxReport {
  private TaxCalculate calculator;
  public TaxReport (double income) {
    calculator = new TaxCalculate( income );
  }
  public show(){
  double tax = calculator.calculateTax();
  System.out.println("税是" + tax);
  }
}

public Main{
  public static void main( String args[ ]) {
     TaxReport tax = new TaxReport(1000);
      tax.show();
  }
}

2.使用依赖注入

四个类
主类Main
类TaxReport
类TaxCalculate
接口类ITaxCalculator

public interface ITaxCalculator {
    double taxCalculate();
}

package Hello;

public class TaxCalculate implements ITaxCalculator{
    private double income;

    public TaxCalculate(double income) {
        this.income = income;
    }

    @Override
    public double taxCalculate() {
        return income * 0.3;
    }
}


public class TaxReport {
    public void show(ITaxCalculator taxCalculator){
        var tax = taxCalculator.taxCalculate();
//依赖注入设置
        System.out.println("应该上缴的费用是" + tax);
    }
}


public class Main {
    public static void main(String args[]){
        var taxReport = new TaxReport();
        taxReport.show(new TaxCalculate(1000));
//依赖注入
    }
}

相比较原来的方式，方式二使用了接口，降低了类与类之间的耦合性，利用依赖注入的方式，结构清晰。方式二中是依赖于抽象的类而不是具体的类，面向接口而不是面向具体的实现，这才是依赖注入的精髓所在。