我试图修改一个所有方法和属性都是静态的类中的一个protected共用方法，是否有解决方案？

Question

public class AllStaticClass {
    protected static void method0(){
        ....
    }
    
    public static void method1(){
        method0();
    }
    
    public static void method2(){
        method0();
    }
}
类似于这样的类，我只是想稍微修改方法method0()中的实现细节，不改动其它方法，是否有好的解决方案？

Answer 1

既然是静态的类和方法，你可以自己写一个静态类（比如NewStaticClass），然后，在这个类里作你自己想做的事。调用的时候，用NewStaticClass调用就可以了：）

Answer 2

利用设计模式中的Decorator模式把AllStaticClass重新封装就能改变method0的输出

Answer 3

静态的很难改了,因为即使你重写了method0,在你调用的时候,它调用的还是父类的method0

Answer 4

我更感兴趣的是，楼主为什么要改写这个方法，并且改写这个方法的内部实现又为什么会影响到其他的调用者（这里也是一组方法）？如果method0内部如同她的名字一样仅仅代表一种概念，那么这个函数被提炼出来就是为了降低她与其他函数之间的实现耦合，改变method0内部的实现并不应该会对其他函数造成影响example:public void aTableTennisMatch() {  Player firstPlayer = getFirstPlayer();
  Player secondPlayer = getSecondPlayer();
  Judgment judgment = getJudgment();  // do something...for match
  
}
====================================>
Player getFirstPlayer() {  Player result = null;  // whatever u do...  return result;}
============================>
Player getSecondPlayer() {
 
  Player result = null;  // whatever u do...  return result;
}
============================>
Judgment getJudgment() {
  
  Judgment result = null;  // whatever u do...  return result;
}所有提炼出的函数必定是一种目的，无论内部如何实现这些方法，他们都必定为他们的接口定义服务，而其他的调用者（比如aTableTennisMatch）依赖的应该仅仅是被调者（比如getJudgment）的接口定义，如果 getJudgment 的内部实现的转变会让 aTableTennisMatch 感到不适应，那一定是当时提炼时出了问题。如果需要修改这个函数，仅仅是因为mehtod0中的某些部分是你想要的，所以你想依靠这个函数为基础打造一个新的函数，那么你应该构造一个 newMehtod，并且提炼出method0中与newMethod共用的交集部分，example:private static void IntersectionPart() { // do something... }
======================================>
protected static void method0() {  // do something before IntersectionPart...  IntersectionPart();  // do something after IntersectionPart...}
=====================================>
static void newMethod() {  // do something before IntersectionPart...  IntersectionPart();  // do something after IntersectionPart...}
更复杂的情况是，如果你的method0是因为某些调用者的需要而进行改变，同时这种改变又会让另一些调用者感到不舒服时，你就应该考虑是不是当时的概念提炼出了问题，一种概念不应该会随内部的实现改变而改变；同时她也不应该使得不同的调用者对其的期望不同，否则你应该考虑这个方法是否具有多重职责？将职责作为一种新的概念重新提炼出去，使得外部调用者面对此被调者时永远保持一个姿态，一改全改，比如 connection.isOpen()，无论数据库链接如何定义何为open，总之所有的调用者当获得返回为true时就必定认为她是打开的，获得false时则认为她必定时关闭的。@.@||~

Answer 5

midthinker(呵呵)，我之所以要改写method0()，是因为method0()提供了一个公共的功能，比如从属性文件中读取属性值，或者从对象中读取属性值，我现在想在method0()中加入某些控制或者允许其从Map中读取key值等等小修改，对于其他method方法而言，method0()提供的功能不变，只是细节有所改动，如此而已

Answer 6

那就要看更改得细节有多细了，如果比较粗，可以提供一个类型，对其进行包装，example:=============== Original class =============
class Orig {static void operator() { // do something... }}=============== Wrappageclass =============
class Wrappage{static void operator() {  
  // do something before really operation...  Orig.operation();  // do something after really operation...
}}如果是控制更细节的东西呵呵呵呵呵呵黔驴技穷
@.@||~

Answer 7

用这个类就用不着改源代码了，就是调用method0()的时候要TranslateMethod.translateMethod("AllStaticClass", "method0")这样调用。
最好是自己再写个ClassLoader，这样就不用这么别扭的调用方式了。
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.NotFoundException;
public class TranslateMethod {
public static void translateMethod(String classname, String methodname)
{
try {
CtClass clazz = ClassPool.getDefault().get(classname);
Impl(clazz, methodname);
} catch (NotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

private static void Impl(CtClass clazz, String methodname)
{
try {
CtMethod method = clazz.getDeclaredMethod(methodname);
StringBuffer code = new StringBuffer();
code.append("{");
code.append("\n System.out.println(\""+methodname+"() has changed!\");\n");
code.append("}");
method.setBody(code.toString());
Method mth = clazz.toClass().getDeclaredMethod(methodname,null);
mth.invoke(clazz);
} catch (NotFoundException e) {
e.printStackTrace();
} catch (CannotCompileException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}

public static void main(String[] args)
{
TranslateMethod.translateMethod("AllStaticClass", "method0");
}}

Answer 8

xstom19(hh)的方案看来不错，是最接近我所想要的方案了。同时也非常感谢midthinker(呵呵)，让我也学到不少东西。之所以要这么做，是有不得已的原因的，原始类不是我的代码，我不能控制的，只能自己写新的类去扩展它，而要扩展只有3种方法，一是我自己重新写个类似的类，二是把它的代码复制过来改一下，三就是在调用它的代码的情况下稍加控制。从设计角度来说，显然第三种方式更可取，不是吗？