Java 使用类型变量泛型调用方法

我有一个场景，我想创建一个名为D的支持类，其中包含一个泛型方法。我已经设置了类型变量的上限

class A{
    void show(){
        System.out.println("Hello A");
    }
}

class B extends A{
    void msg(){
        System.out.println("Hello B");
    }
}

class C extends A{
    void msg(){
        System.out.println("Hello C");
    }
}

class D{
    <T extends A> void display(T ob){
        ob.msg(); //here i want to do some tricks
    }
}

A类{
无效显示（）{
System.out.println（“你好A”）；
}
}
B类扩展了A类{
void msg（）{
System.out.println（“你好B”）；
}
}
C类扩展了{
void msg（）{
System.out.println（“Hello C”）；
}
}
D类{
无效显示（T ob）{
ob.msg（）；//在这里我想做一些技巧
}
}

---

首先，我想分享我的目标。这里，B类和C类的msg（）函数有不同的实现。我想创建一个名为D的支持类，它有一个display方法，我想使用display方法调用依赖于实例化的B类或C类的msg（）函数。您能告诉我如何实现它吗？

您需要在类

A

中使用方法

msg（）

，否则类

D

中的

display（）

方法不知道您传递给它的对象中是否存在此方法。（如果有人创建了一个类

E

，该类扩展了

a

，但没有

msg（）

方法，而您将

E

传递给

D.display（）

？）

如果您不想在类

A

中实现

msg（）

方法，那么可以将其

抽象化（并且还必须将类
抽象化
）

更像是一种架构风格，我会为此使用一个接口，因此您的通用方法将约束为
void display（tob）
，其中If是与抽象方法
msg
的接口

interface If {
    void msg();
}

class A {
    void show() {
        System.out.println("Hello A");
    }
}

class B extends A implements If {
    @Override
    public void msg() {
        System.out.println("Hello B");
    }
}

class C extends A implements If {
    @Override
    public void msg() {
        System.out.println("Hello C");
    }
}

class D {
    <T extends If> void display(T ob) {
        ob.msg(); // here i want to do some tricks
    }
}

接口如果{
void msg（）；
}
甲级{
无效显示（）{
System.out.println（“你好A”）；
}
}
类B扩展了一个{
@凌驾
公共无效消息（）{
System.out.println（“你好B”）；
}
}
类C扩展了一个{
@凌驾
公共无效消息（）{
System.out.println（“Hello C”）；
}
}
D类{
无效显示（T ob）{
ob.msg（）；//在这里我想做一些技巧
}
}
这不需要泛型，Java中有一个称为动态绑定的基本概念

abstract class A{
    void show(){
        System.out.println("Hello A");
    }       
     abstract void msg();    
}

class B extends A{
    @Override
    void msg(){
        System.out.println("Hello B");
    }
}

class C extends A{

       @Override
       void msg(){
             System.out.println("Hello C");
       }
}

class D{
    void display(A ob){
        ob.msg(); 
    }
}

这里提供给方法的适当实例将决定在运行时调用哪个类方法。
仅供参考，这些是方法，而不是函数；你不检查一下B的ob实例是否为C的ob实例吗？或者这可能不是你要问的？？class
A
没有
msg
方法，它只在子类中声明。因此，如果
A
可以是抽象的，则添加一个抽象方法，如果不是，则添加一个空方法（首先不好…）。或者重命名
A
中的
show
，以匹配
B
和
C
中的方法名称（如果它们应该相同的话）。选项之一：引入
接口M{void msg（）；}
，该接口将由
B
和
C
实现，因此不需要泛型。@kan但使用
T扩展A
，
T
将仅“查看”A

的方法，如果该接口仅在

B

和

C

中实现，则这将不起作用。它需要在

A

中实现。它不是在改变方法定义吗？您不能再传递

实例了。但事实上，这是一个干净的解决方案p不需要a对象，OP需要能够实现msg方法的东西我的意思是你不能像
a=new B（）那样使用它；新的D（）显示（a）。原始定义接受的内容。当然，您也失去了使用
A.show（）
的可能性。这不是问题，但需要指出；）
abstract class A{
    void show(){
        System.out.println("Hello A");
    }       
     abstract void msg();    
}

class B extends A{
    @Override
    void msg(){
        System.out.println("Hello B");
    }
}

class C extends A{

       @Override
       void msg(){
             System.out.println("Hello C");
       }
}

class D{
    void display(A ob){
        ob.msg(); 
    }
}