java - 什么是前端类和后端类？

Question

伙计们，我正在搜索组合和继承之间的区别，然后我在某处找到了这篇文章。

根据帖子的说法，在代码重用方面，组合比继承更好。

class Fruit {

    // Return int number of pieces of peel that
    // resulted from the peeling activity.
    public int peel() {

        System.out.println("Peeling is appealing.");
        return 1;
    }
}

class Apple {

    private Fruit fruit = new Fruit();

    public int peel() {
        return fruit.peel();
    }
}

class Example2 {

    public static void main(String[] args) {

        Apple apple = new Apple();
        int pieces = apple.peel();
    }
}

更改后端类

class Peel {

    private int peelCount;

    public Peel(int peelCount) {
        this.peelCount = peelCount;
    }

    public int getPeelCount() {

        return peelCount;
    }
    //...
}

class Fruit {

    // Return int number of pieces of peel that
    // resulted from the peeling activity.
    public Peel peel() {

        System.out.println("Peeling is appealing.");
        return new Peel(1);
    }
}

//Apple必须更改以适应//更改为 Fruit

class Apple {

    private Fruit fruit = new Fruit();

    public int peel() {

        Peel peel = fruit.peel();
        return peel.getPeelCount();
    }
}

//Example2 的旧实现//仍然可以正常工作。

class Example1 {

    public static void main(String[] args) {

        Apple apple = new Apple();
        int pieces = apple.peel();
    }
}

这是我没有得到的，根据帖子所说的“如果后端类的接口(interface)发生变化，前端类的实现也会发生变化，但其接口(interface)不会发生变化”。

这里的接口(interface)是什么，实现是什么？

这只是我的假设，如果我错了请告诉我？(也许一切都是错的)。

后端类是接口(interface)吗，因为前端类依赖于它？
前端类的实现就是前端类内部的实现代码吗？
前端类也是一个接口(interface)吗，因为示例中的代码依赖于它？

它们是否耦合不良，因为对后端接口(interface)的更改没有对前端接口(interface)进行更改？所以依赖前端接口(interface)的代码仍然可以工作。

如果我使用继承，子类是否与父类(super class)紧密耦合？因为对父类(super class)的更改也会对子类进行更改，因此依赖于子类的代码可能无法工作。

Wny继承是弱封装。

Answer 1

This是 Apple 和 Fruit 之间应该的直观继承关系。然而，这不是上面的例子所做的。

上面的示例使用组合，这意味着 Fruit 是Apple 的一部分(参见 uml here )。这是相当违反直觉的!在本例中，Fruit 和 Apple 都有单独的 Peel 实现。 Apple 中 peel() 的实现使用 Fruit.peel()。

我认为重点是，如果 Apple 使用与 Fruit 的组合关系，那么它的实现可以独立于 Fruit。例如，我可以使用其他实现，而不是使用 Fruit.peel() 来获取 Apple.peel() 的计数。但是，如果 Apple 继承了 Fruit，那么 Fruit 的更改也会更改 Apple。因此Apple并不独立于Fruit，所以我们说它是紧耦合的。

从几个方面来看，这是一个糟糕的例子，1)我们都知道苹果是一种水果，因此继承似乎是最正确的实现。 2) 继承似乎是最干燥的实现方式，因为使用组合需要您更正 Apple 类以执行与 Fruit 相同的操作code> 当对 Fruit.peel() 进行更改时。

编辑:读完这篇文章后，我觉得重点是概述使用继承的陷阱。适本地使用继承并没有什么问题。如果子类没有真正从父类(super class)继承行为，仅仅为了代码重用而使用它可能会导致问题。

回答您的问题!

Is the back-end class the interface because front-end class depends on it?

足够接近了。所有类都有一个“接口(interface)”。这并不意味着它们的类声明中确实有 implements IFruit，它只是指对象的形状 - 对象具有哪些方法，无论这些方法如何工作。

Is the implementation of front-end class the implementation code inside the front-end class?

粗略地说，是的。构成类中方法主体的代码的实际逻辑是该类的实现。

Is front-end class also an interface because the code inside Example depends on it?

差不多了。 Apple 隐式地有一个接口(interface)，就像任何其他类一样。如果 Example 使用 Apple 类，那么它只能通过使用属于接口(interface)一部分的方法来实现。

Are they lousely coupled because change to back-end interface didnt make change to front-end interface?

是的，这是使用“松散耦合”一词的一种方式。

If I use inheritance instead is subclass tightly coupled in superclass? Because change to superclass will also change to subclass so code that depends on subclass will may not work.

是的，没错。这两个类紧密耦合，因为它们的行为并未完全封装在每个单独的类中。这并不总是错误的，这取决于具体情况。

Wny inheritance is weak encapsulation.[sic]

因为行为是在父类(super class)和子类之间共享的。