Question

让我用一个例子来描述我的意图，

class Base {
  public void sayHi() {
    System.out.println("Hi");
  }
}

class ChildOne extends Base {
  public void sayBye() {
    System.out.println("Bye-1");
  }
}

class ChildTwo extends Base {
  public void sayBye() {
    System.out.println("Bye-2");
  }
}

public class MainClass {
  public static <T extends Base> void genericFunction(T child) {
    child.sayBye();
  }

  public static void main(String[] args) {
    ChildOne childOne = new ChildOne();
    ChildTwo childTwo = new ChildTwo();
    genericFunction(childOne);
    genericFunction(childTwo);
  }

}

这段代码错了。但我的意图是子类（项目中已经存在的一些类），它们之间具有相似的属性，它们扩展了基类并具有sayBye（）成员函数。

有没有办法将所有子类作为参数传递给泛型函数并调用成员函数sayBye（）（根据此示例）？

Answer 1

当然，您可以为所有具有sayBye方法的类创建公共基类或公共接口。

然后，您可以更改泛型类型参数的类型范围：

public static <T extends CommonInterface> void genericFunction(T child) {
    child.sayBye();
}

或没有泛型：

public static void nonGenericFunction(CommonInterface child) {
    child.sayBye();
}

Answer 2

通过引入定义它的接口并创建扩展公共对象的空类，可以将通用功能集中在一起，而无需调整层次结构。

class Base {
    public void sayHi() {
        System.out.println("Hi");
    }
}

class ChildOne extends Base {
    public void sayBye() {
        System.out.println("Bye-1");
    }
}

class ChildTwo extends Base {
    public void sayBye() {
        System.out.println("Bye-2");
    }
}

// The common functionality I want to use.
interface Bye {
    public void sayBye();
}

class ChildOneBye extends ChildOne implements Bye {
    // Don't need anything here.
}

class ChildTwoBye extends ChildTwo implements Bye {
    // Don't need anything here.
}

public static <T extends Bye> void genericFunction(T child) {
    child.sayBye();
}

public void test(String[] args) {
    Bye childOne = new ChildOneBye();
    Bye childTwo = new ChildTwoBye();
    genericFunction(childOne);
    genericFunction(childTwo);
}

Answer 3

一种方法是将基类标记为抽象，并具有抽象方法sayBye()。这样，您无需在代码库中进行任何其他更改。

abstract class Base {
    public void sayHi() {
        System.out.println("Hi");
    }

    public abstract void sayBye();
}

另一种方法是使用接口ByeInterface并使用它来调用sayBye()。这是带有所需更改的。

interface ByeInterface {
   void sayBye();
}

class Base {
   public void sayHi() {
   System.out.println("Hi");
  }
}

 class ChildOne extends Base implements ByeInterface {
 public void sayBye() {
     System.out.println("Bye-1");
  }
}

  class ChildTwo extends Base implements ByeInterface {
  public void sayBye() {
     System.out.println("Bye-2");
 }
}

public class MainClass {
    public static <T extends ByeInterface> void genericFunction(T child) {
    child.sayBye();
 }

   public static void main(String[] args) {
       ChildOne childOne = new ChildOne();
       ChildTwo childTwo = new ChildTwo();
       genericFunction(childOne);
       genericFunction(childTwo);
   }

 }

如果无法将基类标记为抽象类，则可以使用此方法。使用接口，甚至可以在不使用泛型的情况下调用它。

public static void nonGenericFunction(ByeInterface child) {
    child.sayBye();
}

Java泛型 - 有界类型参数

3 个答案: