请教，这样的类该如何设计？

Question

需要写10个类，每个类都是如下的结构：class MyClassA {
    public static int excute() {
        //大约100行程序
    }    public static void process() {
        //也是大约100行程序，其中要调用excute()方法若干次
    }
}这10个类都是这样的结构，每个类的process方法的代码完全相同，每个类的excute方法不同。
现在的问题是：我觉得每个类都要有相同的代码，可能不是一个好的实现，想过用继承的方式，就是有一个基类，其中的excute方法是空的，process方法是正常的代码，
然后这10个类都从基类继承，并实现自己的excute方法，但实验的结果是：
调用子类process方法时，调用的还是基类的excute方法。那位给点提示或建议，感谢。

Answer 1

public abstract class BaseClass {
    public void process() {
        //do something for process
    }    public abstract int excute();
}public class MyClassA {
    public int excute() {
        //do something for excute of MyClassA
    }
}public class MyClassB {
    public int excute() {
        //do something for excute of MyClassB
    }
}...

Answer 2

漏了继承.....下面才是正确的,忽略1楼:
public abstract class BaseClass {
    public void process() {
        //do something for process
    }    public abstract int excute();
}public class MyClassA extends BaseClass {
    public int excute() {
        //do something for excute of MyClassA
    }
}public class MyClassB extends BaseClass {
    public int excute() {
        //do something for excute of MyClassB
    }
}...

Answer 3

关键是这两个方法都是static的，请注意

Answer 4

类中的这两个方法必须是static的，一共有10个这样的类，他们之间没有什么关系，
其中每个类的process会调用自己的excute， 
这10个类的excute方法实现各不相同，但这10个类的process方法实现完全相同，
这就导致了完全相同的代码（process方法）出现在不同的类中，我猜想这可能不是
一个好的实现，所以想问有什么更好的组织代码的方法么？

Answer 5

static不能继承的,你只能写11个方法了...

Answer 6

你用10 static 方法，不如用 10个static 的单例子类。
更直接一点用工厂模式

Answer 7

楼主，我觉得你的这种需求不一定都需要2个静态的吧？？？
你在其中一个方法中加入一个参数，利用多态机制行不？？我给你的一个参考如下：
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝class Tools
{
public static void process(Father sfather)
{
System.out.print(sfather.getClass().getName()+"=");
System.out.println(sfather.execute()); //调用子类的方法
}
}interface Father
{
public int execute();
}class Son1 implements Father
{
public int execute()
{
return 1;
}
}class Son2 implements Father
{
public int execute()
{
return 2;
}
}public class TestMain
{
public static void main(String[] args)
{
Father s1=new Son1();
Tools.process(s1);
Father s2=new Son2();
Tools.process(s2);
}
}

Answer 8

确实是需要两个静态方法，而且这两个方法从逻辑上讲也应该放在一起（一个类中）
你的方案中excute不是静态的

Answer 9

虽然execute不是静态的。。但你的要求“一共有10个这样的类，他们之间没有什么关系， 
其中每个类的process会调用自己的excute， 
这10个类的excute方法实现各不相同，但这10个类的process方法实现完全相同， 
这就导致了完全相同的代码（process方法）出现在不同的类中，我猜想这可能不是 
一个好的实现”我给你的方案中都完全实现了啊

Answer 10

用 10 个 静态的单例 子类。
public static final BaseClass A = new BaseClass {
    public int excute() {
        //do something for excute of MyClassA
    }
}public static final BaseClass B = new MyClassB();或者 建一个 BaseClassFactory
public BaseClass getBaseClass(String name){
if("A".equals(name)){
//return new MyClassA();
return A;
}
}

Answer 11

答:我有一点想法仅供楼主参考:
1)class MyClassA1 { 
    public static int excute() { 
        //大约100行程序 
    } 
}
...
class MyClassA10 { 
    public static int excute() { 
        //大约100行程序 
    } 
}共10个子类,都有自己特定的static  excute() 2)class CommClass
{
 public static void process(Class c)
{
 } }
上述process(...)是通用的共同的process()方法.
如:调用process(MyClassA1.class);...;process(MyClassA10.class);
意图是:这样可在process内部,通过反射技术来自动调用传入的
子类的特定的excute()了.以上仅供楼主参考.

Answer 12

class Tools
{
public static void process(Father sfather)
{
System.out.print(sfather.getClass().getName() + "=");
System.out.println(sfather.execute()); // 调用子类的方法
}
}interface Father
{
public int execute();
}class Son1 implements Father
{
public int execute()
{
return 1;
}
}class Son2 implements Father
{
public int execute()
{
return 2;
}
}public class TestMain
{
public static void main(String[] args)
{
Father s1 = new Son1();
Tools.process(s1);
Father s2 = new Son2();
Tools.process(s2);
}
}

Answer 13

答:paullbm兄弟:楼主要求execute()与process()都必须是static方法啊.你这个execute()不是一个static方法啊.

Answer 14

答:若不是static,问题与设计又不一样了.

Answer 15

确实如此，有时我觉得static方法不能用来实现多态有点可惜，毕竟有些时候是没有必要生成一个对象的。
目前看16楼的方案是比较好的，再等两天，看看有没有更好的实现。

Answer 16

其实这两个方法都是public的，会有其他的类中调用这两个方法，如下：
switch (handler) {
    case 'A':
        if (flag) {
            MyClassA.process();
        } else {
            MyClassA.excute();
        }
        break;
    case 'B':
        if (flag) {
            MyClassB.process();
        } else {
            MyClassB.excute();
        }
        break;
    case 'C':
        if (flag) {
            MyClassC.process();
        } else {
            MyClassC.excute();
        }
        break;
    ...
}
从上面的use case 看，如果两个方法要是能放在一个类里，从逻辑上就更好理解了。

Answer 17

楼主看一下这种行不：abstract class Father 
{ 
public static void process(Father sFather)
{//写公共代码
System.out.println(sFather.excuteAgent());
}

    public int excuteAgent()
    {//仅做RTTI调用，为调子类中的静态excute方法
     return -1;
    }
}class Son1 extends Father
{
public int excuteAgent()
{//直接返回自身的静态excute方法
return excute();
}

public static int excute()
{
return 1;
}
}class Son2 extends Father
{
public int excuteAgent()
{//直接返回自身的静态excute方法
return excute();
}

public static int excute()
{
return 2;
}
}public class MainTest
{
public static void main(String[] args)
{
Father s1=new Son1();
s1.process(s1);
Father s2=new Son2();
s2.process(s2);
}
}

Answer 18

把我上一楼的代码中的
excute
单词全换成
execute
即可

Answer 19

楼主，你可以在我22楼的代码中的main函数中再加入Father.process(new Son1());
Father.process(new Son2());测试

Answer 20

public interface ClassInterface {
public int excute();
public void process();
}
public class ConcreteMyClassA  implements ClassInterface { private MyClassA myclassa = null;
public ConcreteMyClassA(MyClassA myclassa ){
this.myclassa = myclassa;

}
public int excute() {
System.out.println("ConcreteMyClassAaaa...");
return 0;
}

public void process(){
myclassa.process();
}}public class ConcreteMyClassB  implements ClassInterface { private MyClassA myclassa = null;
public ConcreteMyClassB(MyClassA myclassa ){
this.myclassa = myclassa;

}
public int excute() {
System.out.println("ConcreteMyClassBbbbb...");
return 0;
}

public void process(){
myclassa.process();
}}public class MyClassA { public MyClassA(){

}
public void process(){
System.out.println("process执行...");
}
}
public class Test { public static void main(String[] args) {
MyClassA myclassa =new MyClassA();
ClassInterface ins = new ConcreteMyClassA(myclassa);
ins.excute();
ins.process();
ClassInterface ins2 = new ConcreteMyClassB(myclassa);
ins2.excute();
ins2.process(); }}

Answer 21

答:是的.若这样就更好理解了.
如果把上述代码设计成这样如何?仅供楼主参考.
switch (handler) { 
    case 'A': 
        if (flag) { 
          CommClass.process(MyClassA.class);   //MyClassA.process(); 
        } else { 
           CommClass.excute(MyClassA.class);   // MyClassA.excute(); 
        } 
        break; 
    case 'B': 
        if (flag) { 
          CommClass.process(MyClassB.class);     //MyClassB.process(); 
        } else { 
          CommClass.excute(MyClassB.class);     //MyClassB.excute(); 
        } 
        break; 
    case 'C': 
        if (flag) { 
           CommClass.process(MyClassC.class);     //MyClassC.process(); 
        } else { 
           CommClass.process(MyClassC.class);     //MyClassC.excute(); 
        } 
        break; 
    ... 
} 这样把这两个方法都放在同一个类中(CommClass类--能放在一个类里，从逻辑上就更好理解了),这样通过反射技术来调用各自的输入参数中的自己的excute()了.仅供楼主参考.

Answer 22

10个一模一样的static process()方法?
为什么不写成一个?
在static的情况下,组合比继承好用吧( - __ - )y一～ 
public class Bzimage 
{
  public static void process(){}
}public class MyClassA
{
  public static int excute()
  {
    ... ...
    Bzimage.process();
    ... ...
  }
}

Answer 23

父类中的execute()方法定义成抽象的（abstract），然后每个子类再实现这个方法就行了

Answer 24

是process 调用excute，不是excute调用process

Answer 25

楼主，你也可以把我22楼的Father类中的excuteAgent()方法改写为abstract类型的。这样子写子类继承Father的时候就必须去实现它了方便些
22楼的代码应该能符合你的要求了
现在都是静态方法了，并且通过多态解决了你的调用要求！

Answer 26

你的代码确实已经相当不错了，但既然这两个方法都是static的，就是说调用这两个方法时，是不需要生成该类型的对象的，也就是说不需要new了，在你的22楼的例子中还是使用到new了：public class MainTest
{
    public static void main(String[] args)
    {
        Father s1=new Son1();
        s1.process(s1);
        Father s2=new Son2();
        s2.process(s2);
    }
}比如下面是使用这两个方法的一个具体的例子：switch (handler) {
    case 'A':
        if (flag) {
            MyClassA.process();
        } else {
            MyClassA.excute();
        }
        break;
    case 'B':
        if (flag) {
            MyClassB.process();
        } else {
            MyClassB.excute();
        }
        break;
    case 'C':
        if (flag) {
            MyClassC.process();
        } else {
            MyClassC.excute();
        }
        break;
    ...
}
从上面的use case 看，如果两个方法要是能放在一个类里，从逻辑上就更好理解了。