对派生类中的成员变量使用派生类型

Question

我目前有一个 A 类，它有一些我想在 B 中使用的功能。A 有一个 Button 类型的成员变量，而在 B 中我想使用 IconButton 类型（派生自 Button）。

类是这样的：

public class A {

    protected Button x = new Button();

    A() {
        x.xx();
    }

    public void doFirstThing() {
        x.xx();
    }

    Button getButton() {
        return x;
    }
}

public class B extends A {

    B() {
        x = new IconButton();

        getButton().yy();
    }

    public void doSecondThing() {
        getButton().zz();
    }

    IconButton getButton() {
        return (IconButton) x;
    }
}

public class Button {

    public void xx() {

    }   
}

public class IconButton extends Button {

    public void yy() {

    }

    public void zz() {

    }
}

如您所见，方法yy() 和zz() 仅在IconButton 中可用，因此我需要通过提供方法getButton 在B 中执行“解决方法”。

是的，通常我们在 A 中也有一个 getButton() 方法，所以这并不是对 B 的牵强附会。

但我想知道，这真的是正确的做法还是我做错了？

我也想过创建一个抽象类，例如A0，它将包含来自 A 的当前代码。然后我会做：

class A extends A0<Button> {
 // mostly empty, code taken from A0
}

class B extends A0<IconButton> {
// custom things here
}

或者还有其他方法可以更好地解决这个问题吗？

这是我的 GWT 应用程序中的一个组件。所以，如果我像@king_nak 所说的那样声明，那么我的组件中将有两个按钮。或者，如果我可以接受另一种解决方法，我可以删除 B 中的原始按钮，例如x.removeFromParent() 或类似的东西，但它会成为一个全新的不良做法。

Answer 1

您的解决方法是个坏主意。你失去了很多类型安全。你可以例如将 B 的构造函数更改为 x = new Button(); 并忘记演员表。您的程序仍然可以编译，但在运行时会失败。

我认为你在使用通用通用超类的道路上是正确的。您可以使用成员 T x 将 A0 定义为 A0<T extends Button>。可能有更好的解决方案，但如果没有大局就很难判断。

Answer 2

一种简单（和多态）的方法是覆盖 B 类中的 getButton 并返回 IconButton 的实例，而不是在类中完全引用，例如：

public class A {
    public Button getButton(){
        Button b = new Button();
        b.xx();
        return b;
    }
}

public class B extends A {

    @Override
    public Button getButton(){
        IconButton b = new IconButton();
        b.yy();
        b.zz();
        return b;
    }
}

Answer 3

1. 提取按钮界面 公共接口按钮{ 无效初始化（）； }
2. 创建 PlainButton（您的前 Button）类： 公共类 PlainButton 实现 Button { 公共无效初始化（）{ xx(); } 私人无效xx（）{ } }
3. 创建 IconButton 类： 公共类 IconButton 实现 Button { 公共无效初始化（）{ yy(); Z Z（）; } 私人无效yy（）{ } 私人无效zz（）{ } }
4. 创建 ButtonWrapper 类（您的前 A 和/或 B 类）： 公共类 ButtonWrapper { 私人最终 T 按钮； 公共ButtonWrapper（T按钮）{ this.button = 按钮； this.button.init(); } 公共T getButton（）{ 返回按钮； } }

5. 用途：

   ButtonWrapper A = new ButtonWrapper(new PlainButton()); ButtonWrapper B = new ButtonWrapper(new IconButton());

Answer 4

如果您唯一关心的是B 应该有一个IconButton 而不是它的基础Button，为什么不在B 中为它创建一个单独的成员，让A 使用它？

class A {
    protected Button b;
    public A() {
      // By default, I use a Button
      b = new Button();
    }

    // Subclasses can override which button I use
    protected A(Button b) {
       this.b = b;
    }

}

class B extends A {
    private IconButton ib;
    public B() {
      super(new IconButton());
      ib = (IconButton) super.b;
    }

    // B can access it's IconButton through ib
    // Users of A will see a Button
}

不需要抽象基类、泛型、包装器。让 B 拥有它的 IconButton，并有 2 个对它的引用（B.ib 并继承 A.b）

Answer 5

如果您不想使用泛型： 这种方法与best practices 背道而驰，但我发现它完全没问题，只要你不在B 的构造函数中使用按钮做任何事情：

public static class A {

    protected Button x = null;

    public A() {
        x = createButton();
    }

    public Button getButton() {
        return x;
    }

    protected Button createButton(){
        Button result = new Button();
        result.xx();
        return result;
    }
}

public static class B extends A{

    public IconButton getButton() {
        return (IconButton)x;
    }

    protected Button createButton(){
        IconButton iconButton = new IconButton();
        iconButton.yy();
        iconButton.zz();
        return iconButton;
    }
}

现在，如果您想避免演员表，您可以使用这种我自己很可能不会使用的疯狂方法。 警告使用风险自负：

public static class A {

        protected Button x = null;

        public A() {
            x = createButton();
        }

        public Button getButton() {
            return x;
        }

        protected Button createButton(){
            Button result = new Button();
            result.xx();
            return result;
        }
    }

    public static class B extends A{

        //leave uninitialized so that when B gets constructed iconButton wont be reinitialized because it has been initialized by A's constructor call
        private IconButton iconButton; 

        public IconButton getButton() {
            return iconButton;
        }

        protected Button createButton(){
            iconButton = new IconButton();
            iconButton.yy();
            iconButton.zz();
            return iconButton;
        }
    }

更新：

如前所述，首选方法是在此处避免继承，并在需要时使用组合。但是由于示例代码没有太多细节以便能够显示组合方法，因此我添加了另一种仍然使用继承的方法，避免了强制转换和构造初始化。 我认为在使用 Swing 或 GWT 等非并发框架时最好使用惰性初始化，而不是构造初始化：

public static class A {

        private Button x = null;

        protected Button getButton() {
            if (x == null) x = createButton();
            return x;
        }

        private Button createButton(){
            Button result = new Button();
            result.xx();
            return result;
        }
    }

    public static class B extends A{

        private IconButton iconButton; 

        public Button getButton() {
            if (iconButton == null) iconButton = createButton();
            return iconButton;
        }

        public IconButton getIconButton(){
            getButton();
            return iconButton;
        }

        private IconButton createButton(){
            IconButton iconButton = new IconButton();
            iconButton.yy();
            iconButton.zz();
            return iconButton;
        }
    }