在尝试编写测试用例时会出现这个问题。Foo 是框架库中的一个类，我没有源代码访问权限。
public class Foo{
public final Object getX(){
...
}
}
我的申请将
public class Bar extends Foo{
public int process(){
Object value = getX();
...
}
}
由于其他依赖关系，我无法创建 Foo 对象，因此单元测试用例无法初始化。BarTest 抛出一个空指针，因为值为空。
public class BarTest extends TestCase{
public testProcess(){
Bar bar = new Bar();
int result = bar.process();
...
}
}
有没有办法可以使用反射 api 将 getX() 设置为非最终的？或者我应该如何进行测试？
因为这是谷歌中“覆盖最终方法 java”的最佳结果之一。我想我会留下我的解决方案。此类显示了一个使用示例“Bagel”类和免费使用的 javassist 库的简单解决方案：
/**
* This class shows how you can override a final method of a super class using the Javassist's bytecode toolkit
* The library can be found here: http://jboss-javassist.github.io/javassist/
*
* The basic idea is that you get the super class and reset the modifiers so the modifiers of the method don't include final.
* Then you add in a new method to the sub class which overrides the now non final method of the super class.
*
* The only "catch" is you have to do the class manipulation before any calls to the class happen in your code. So put the
* manipulation as early in your code as you can otherwise you will get exceptions.
*/
package packagename;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.Modifier;
/**
* A simple class to show how to use the library
*/
public class TestCt {
/**
* The starting point for the application
*/
public static void main(String[] args) {
// in order for us to override the final method we must manipulate the class using the Javassist library.
// we need to do this FIRST because once we initialize the class it will no longer be editable.
try
{
// get the super class
CtClass bagel = ClassPool.getDefault().get("packagename.TestCt$Bagel");
// get the method you want to override
CtMethod originalMethod = bagel.getDeclaredMethod("getDescription");
// set the modifier. This will remove the 'final' modifier from the method.
// If for whatever reason you needed more than one modifier just add them together
originalMethod.setModifiers(Modifier.PUBLIC);
// save the changes to the super class
bagel.toClass();
// get the subclass
CtClass bagelsolver = ClassPool.getDefault().get("packagename.TestCt$BagelWithOptions");
// create the method that will override the super class's method and include the options in the output
CtMethod overrideMethod = CtNewMethod.make("public String getDescription() { return super.getDescription() + \" with \" + getOptions(); }", bagelsolver);
// add the new method to the sub class
bagelsolver.addMethod(overrideMethod);
// save the changes to the sub class
bagelsolver.toClass();
}
catch (Exception e)
{
e.printStackTrace();
}
// now that we have edited the classes with the new methods, we can create an instance and see if it worked
// create a new instance of BagelWithOptions
BagelWithOptions myBagel = new BagelWithOptions();
// give it some options
myBagel.setOptions("cheese, bacon and eggs");
// print the description of the bagel to the console.
// This should now use our new code when calling getDescription() which will include the options in the output.
System.out.println("My bagel is: " + myBagel.getDescription());
// The output should be:
// **My bagel is: a plain bagel with cheese, bacon and eggs**
}
/**
* A plain bagel class which has a final method which we want to override
*/
public static class Bagel {
/**
* return a description for this bagel
*/
public final String getDescription() {
return "a plain bagel";
}
}
/**
* A sub class of bagel which adds some extra options for the bagel.
*/
public static class BagelWithOptions extends Bagel {
/**
* A string that will contain any extra options for the bagel
*/
String options;
/**
* Initiate the bagel with no extra options
*/
public BagelWithOptions() {
options = "nothing else";
}
/**
* Set the options for the bagel
* @param options - a string with the new options for this bagel
*/
public void setOptions(String options) {
this.options = options;
}
/**
* return the current options for this bagel
*/
public String getOptions() {
return options;
}
}
}
您可以创建另一个可以在测试中覆盖的方法：
public class Bar extends Foo {
protected Object doGetX() {
return getX();
}
public int process(){
Object value = doGetX();
...
}
}
然后，您可以在 BarTest 中覆盖 doGetX。
Seb 是正确的，只是为了确保您得到问题的答案，而不是在本机代码中做某事（我很确定这不会起作用）或在运行时修改类的字节码，并创建类在运行时覆盖该方法，我看不到改变方法“最终性”的方法。反思在这里对你没有帮助。
如果您的单元测试用例由于其他依赖项而无法创建 Foo，这可能表明您一开始就没有正确进行单元测试。
单元测试旨在在生产代码运行的相同环境下进行测试，因此我建议在您的测试中重新创建相同的生产环境。否则，您的测试将不完整。
如果返回的变量getX()不是final，您可以使用单元测试私有方法的最佳方法是什么？用于通过 改变private变量的值Reflection。
public class Bar extends Foo{
public int process(){
Object value = getX();
return process2(value);
}
public int process2(Object value){
...
}
}
public class BarTest extends TestCase{
public testProcess(){
Bar bar = new Bar();
Mockobj mo = new Mockobj();
int result = bar.process2(mo);
...
}
}
我最终所做的是上述。这有点难看......詹姆斯的解决方案肯定比这好得多......