Question

我是Java新手。当我学习Java的接口概念和实现时，我注意到示例代码有两种方法，这使我有些困惑。因为讲师说的是依赖注入（构造函数注入方法）的主要目的是在原始TaxReport.java 中的this.calculator = new TaxCalculator2020(100000);上的实现和实例化之间插入一个层。关于此示例代码，我有两个问题。 1.在我的Main.java 中，不使用界面，则首选哪种方法，为什么？ 2.我注意到接口TaxReport.java 和 Taxreport.java 在代码方面非常相似，因此我很难理解使用接口的概念。我真的很感激有人可以在此示例代码中为界面提供实际帮助的情况。

原始Main.java：

public class Main{
    public static void main(String[] args){

        var report1 = new TaxReport();

        report1.show();
    }
}

原始TaxCalculator2020.java：

public class TaxCalculator2020 implements TaxCalculator {
    private double taxableIncome;

    public TaxCalculator2020(double taxableIncome) {
        this.taxableIncome = taxableIncome;
    }

    public double calculateTax(){
        return taxableIncome*0.3;
    }
}

原始TaxReport.java：

public class TaxReport {
    private TaxCalculator2020 calculator;

    public TaxReport(){
        this.calculator = new TaxCalculator2020(100000);
    }
    public void show(){
        var tax = calculator.calculateTax();
        System.out.println(tax);
    }
}

接口Main.java：

public class Main{
    public static void main(String[] args){
        var calculator = new TaxCalculator2020(100000);
        var report1 = new TaxReport(calculator);

        report1.show();
    }
}

接口TaxReport.java：

public class TaxReport {
    private TaxCalculator calculator;

    public TaxReport(TaxCalculator calculator){
        this.calculator = calculator;
    }
    public void show(){
        var tax = calculator.calculateTax();
        System.out.println(tax);
    }
}

最后是接口TaxCalculator.java

public interface TaxCalculator {
    double calculateTax();
}

我认为示例代码有点尴尬，因为我难以理解与之的接口。因此，以下是我的代码版本，其中包含两种不使用接口的方法：

我的Main.java：

public class Main{
    public static void main(String[] args){
        var calculator = new TaxCalculator2020(100000);

        var report1 = new TaxReport(calculator);         //instantiate within main()
        var report2 = new TaxReport(100000);             //instantiate within constructor

        report1.show();
        report2.show();
    }
}

TaxReport.java由我：

public class TaxReport {
    private TaxCalculator2020 calculator;

    public TaxReport(TaxCalculator2020 calculator){
        this.calculator = calculator;
    }
    public TaxReport(double taxableIncome){
        this.calculator = new TaxCalculator2020(taxableIncome);
    }
    public void show(){
        var tax = calculator.calculateTax();
        System.out.println(tax);
    }
}

Answer 1

对于第一个问题，在您所参考的教程中给出的示例中，使用接口是不合理的。界面提供了一种定义模板并将其用于为不同类提供不同实现的方法。例如：

 public interface TaxCalculator{
     double calculateTax();
 }

 public class Tax2020 implements TaxCalculator{
     double calculateTax()
     {
        ------ logic
     }
 }

 public class Tax2021 implements TaxCalculator{
     double calculateTax()
     {
         -------- other logic
     }
 }

此外，我们使用接口在Java中实现多重继承。

关于第二个问题，依赖注入的含义是将依赖转移到其他对象。
```
 public SomeClass() {
   myObject = Factory.getObject();
 }
```

在上述情况下，要对SomeClass进行一些测试，如果我需要具有复杂逻辑的myObject类，则需要为其模拟功能，但是可以通过使用基于构造函数的依赖项注入或基于setter的注入来避免这种情况。

    public SomeClass (MyClass myObject) {
    this.myObject = myObject;
    }

因此，最好具有基于构造函数的依赖项。

main（）中的对象实例化或构造函数中的对象实例化。哪个更好，为什么？

1 个答案: