主页 / 问题 / 1367502
Accepted
Charismatic
Asked:2022-05-31 15:46:12 +0000 UTC2022-05-31 15:46:12 +0000 UTC

将接口对象传递给 JAVA 构造函数

  • 772
public class CalculatorWithAutoAggregationSetup1  implements ICalculator {
    ICalculator ic;
    CalculatorWithOperator cwo;
    public CalculatorWithAutoAggregationSetup1(ICalculator ic) {
        this.ic = ic;

    }
    private int counter;
    private long memory;

    public CalculatorWithAutoAggregationSetup1() {

    }


    public double divide(double a, double b) {
        counter++;
        return ic.divide(a,b);
    }

    public double multiplication(double a, double b) {
        counter++;
        return a * b;
    }

    public double plus(double a, double b) {
        counter++;
        return a + b;
    }

    public double minus(double a, double b) {
        counter++;
        return a - b;
    }

    public double square(double a, int b) {
        double square = 1;
        for (int i = 0; i < b; i++) {
            square *= a;
        }
        counter++;
        return square;
    }

    public double module(double a) {
        if (a < 0) {
            a = -(a);
        }
        counter++;
        return a;
    }

    public double root(double a) {
        double x;
        if (a<0) {
            a = -(a);
        }
        double half = a / 2;
        do {
            x = half;
            half = (x + (a / x)) / 2;
        } while ((x - half) != 0);
        counter++;
        return half;
    }
    public long getCounter() {
        return  counter;
    }

我无法理解如果我们传递一个 ICalculator 类型的对象，那么我们将不得不在 main 中创建它（据我了解），但是如果不实现其方法就无法创建接口对象。另外，您需要在没有自己数学的情况下委托方法，但据我了解，没有其他类（包括接口）我无法委托（因为它没有实现）。问题是我应该将什么传递给构造函数，或者更确切地说如何（必须传递 ICalculator），以便我可以委托方法并运行 main。

java

1 个回答

  1. Best Answer

    听说过多态性吗？一个接口 - 许多实现？

    简而言之，接口是保证我们将具有某种行为的契约，即 我们 100% 确定任何实现该接口的类都会有正确的方法。

    interface Speakable {
    void speak();
}

    并创建三个类，每个类都有自己的 speak 方法

    class Cat implements Speakable {
    @Override
    public void speak() {
        System.out.println("мяу");
    }
}

class Dog implements Speakable {
    @Override
    public void speak() {
        System.out.println("гав");
    }
}

class Developer implements Speakable {
    @Override
    public void speak() {
        System.out.println("учу джаву");
    }
}

    主要我们可以通过接口创建一个对象

    Speakable speakable = new Developer();
Speakable speakableCat = new Cat();
Speakable speakableDog = new Dog();

    我们可以创建一个接受任何 Speakable 对象的方法，因为 我们知道它将有一个 speak 方法，并且将来我们将能够创建和添加任何实现，而无需重写当前代码。

    void test(Speakable speakable) {
        speakable.speak();
    }

    集合也是通过接口创建的。

    public static void main(String[] args) {
        //лист обьектов реализующих контракт Speakable
        List<Speakable> list = new ArrayList<>();
        list.add(new Cat()); 
        list.add(new Dog());  
        list.add(new Developer());

        for (Speakable speakable : list) {
            speakable.speak();
        }
    }

    结论

    мяу
гав
учу джаву

    如果您不创建对象，则将匿名类或 lambda 传递给该方法。它必须是具有一个抽象方法的功能接口。

    public class Test {

    static void test(Speakable speakable) {
        speakable.speak();
    }

    public static void main(String[] args) {
        test(new Speakable() {
            @Override
            public void speak() {
                System.out.println("через анонимный класс");
            }
        });

        test(() -> System.out.println("через лямбду"));

    }
}
    • 3

相关问题