以下代码应该可以解决您的问题。 Main 类模拟您的主类。 A 类模拟您想要扩展的基类（并且您无法控制）。 B 类是 A 类的派生类。接口C 模拟Java 没有的“函数指针”功能。我们先看代码……
以下是A类，你想扩展但无法控制的类：
/* src/packageA/A.java */
package packageA;
public class A {
public A() {
}
public void doSomething(String s) {
System.out.println("This is from packageA.A: " + s);
}
}
以下是类B，虚拟派生类。请注意，由于它扩展了A，它必须导入packageA.A，并且A 类必须在B 类的编译时可用。带有参数 C 的构造函数是必不可少的，但实现接口 C 是可选的。如果B 实现C，您可以方便地直接调用B 实例上的方法（无需反射）。在B.doSomething() 中，调用super.doSomething() 是可选的，取决于您是否愿意，但调用c.doSomething() 是必不可少的（解释如下）：
/* src/packageB/B.java */
package packageB;
import packageA.A;
import packageC.C;
public class B extends A implements C {
private C c;
public B(C c) {
super();
this.c = c;
}
@Override
public void doSomething(String s) {
super.doSomething(s);
c.doSomething(s);
}
}
以下是棘手的界面C。只需将您要覆盖的所有方法放入此接口即可：
/* src/packageC/C.java */
package packageC;
public interface C {
public void doSomething(String s);
}
以下是主类：
/* src/Main.java */
import packageC.C;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Main {
public static void main(String[] args) {
doSomethingWithB("Hello");
}
public static void doSomethingWithB(final String t) {
Class classB = null;
try {
Class classA = Class.forName("packageA.A");
classB = Class.forName("packageB.B");
} catch (ClassNotFoundException e) {
System.out.println("packageA.A not found. Go without it!");
}
Constructor constructorB = null;
if (classB != null) {
try {
constructorB = classB.getConstructor(C.class);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
C objectB = null;
if (constructorB != null) {
try {
objectB = (C) constructorB.newInstance(new C() {
public void doSomething(String s) {
System.out.println("This is from anonymous inner class: " + t);
}
});
} catch (ClassCastException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
if (objectB != null) {
objectB.doSomething("World");
}
}
}
为什么会编译和运行？
可以看到Main类中只导入了packageC.C，并没有引用packageA.A或packageB.B。如果有，类加载器会在没有packageA.A 的平台上尝试加载其中一个时抛出异常。
它是如何工作的？
在第一个Class.forName() 中，它检查类A 在平台上是否可用。如果是，请让类加载器加载类B，并将生成的Class 对象存储在classB 中。否则，ClassNotFoundException 会被Class.forName() 抛出，并且程序将没有类A。
然后，如果classB 不为空，则获取类B 的构造函数，该构造函数接受单个C 对象作为参数。将Constructor 对象存储在constructorB 中。
然后，如果constructorB 不为空，则调用constructorB.newInstance() 以创建B 对象。由于有一个C 对象作为参数，您可以创建一个实现接口C 的匿名类并将实例作为参数值传递。这就像您创建匿名 MouseListener 时所做的一样。
（其实上面的try块不用分开，这样做是为了说明我在做什么。）
如果你让B实现C，此时可以将B对象强制转换为C引用，然后就可以直接调用被覆盖的方法（无需反射）。
如果类 A 没有“无参数构造函数”怎么办？
只需将所需的参数添加到类B，如public B(int extraParam, C c)，并调用super(extraParam) 而不是super()。在创建constructorB时，还要添加额外的参数，如classB.getConstructor(Integer.TYPE, C.class)。
String s 和 String t 会发生什么情况？
t 被匿名类直接使用。当调用objectB.doSomething("World"); 时，"World" 是提供给类B 的s。由于super不能在匿名类中使用（原因很明显），所有使用super的代码都放在B类中。
如果我想多次引用 super 怎么办？
只需在B.doSomething() 中编写一个模板，如下所示：
@Override
public void doSomething(String s) {
super.doSomething1(s);
c.doSomethingAfter1(s);
super.doSomething2(s);
c.doSomethingAfter2(s);
}
当然，您必须修改接口C 以包含doSomethingAfter1() 和doSomethingAfter2()。
如何编译运行代码？
$ mkdir 类
$
$
$
$ javac -cp src -d 类 src/Main.java
$ java -cp 类主要
未找到 packageA.A。没有它！
$
$
$
$ javac -cp src -d 类 src/packageB/B.java
$ java -cp 类主要
这是来自 packageA.A: World
这是来自匿名内部类：你好
在第一次运行中，类packageB.B 没有被编译（因为Main.java 没有任何对它的引用）。在第二次运行中，该类被显式编译，因此您得到了预期的结果。
为了帮助您适应我的解决方案来解决您的问题，这里是设置 Nimbus 外观和感觉的正确方法的链接：
Nimbus Look and Feel