通过避免在特定场景中覆盖超类方法java来重新使用超类方法答案

【问题标题】：Re using super class methods by avoiding overriding of super class methods java in a specific scenario通过避免在特定场景中覆盖超类方法java来重新使用超类方法
【发布时间】：2018-01-31 05:21:00
【问题描述】：

我有两节课甲类：具有4个不同数据类型的成员变量和3种方法（m1()、m2()和m3()）

例如：

class ClassA
       {
           String a;
           String b;
           Double c;
           UserDefinedTypeA d;
         public m1(){
            //All the 4 variables are used here.
           }
         public m2(){
             //All the variables are used here.
           }
         public m3(){
            //All the variables are used here.
           }

B 类：具有 4 个成员变量和 3 个方法（m1()、m2() 和 m3()）。其中三个成员变量与 ClassA 类型相同，只有第四个变量类型不同。

例如：

class ClassB
       {
           String a;
           String b;
           Double c;
           UserDefinedTypeB d;
         public m1(){
            //All the 4 variables are used here.
           }
         public m2(){
             //All the variables are used here.
           }
         public m3(){
            //All the variables are used here.
           }

现在我想避免在子类中覆盖 m1、m2 和 m3，因为类型 4 的成员变量不同。作为一种解决方案，我计划在超类中创建另一个成员变量，其类型为：UserDefinedTypeB，并从子类构造函数初始化此变量。检查 UserDefinedTypeB 是否为 null 的所有方法。如果它不为 null，则 i 将执行子类特定逻辑，否则将继续使用支持 UserDefinedTypeB 的超类逻辑。

但是感觉这会降低性能。有关提出更好方法的任何建议。

【问题讨论】：

什么是子类，什么是超类？从你的问题中真的不清楚。在我看来，正确的解决方案可能涉及泛型——所以你可能有一个泛型超类SuperClass<T>，其中ClassA extends SuperClass<UserDefineTypeA> 和ClassB extends SuperClass<UserDefinedTypeB> 包含所有常见功能。但我不能肯定地说，因为我不明白你想要达到什么目的。

标签： java overriding

【解决方案1】：

更好的方法是在超类 SuperClass 中引入并为 m1() 、 m2() 和 m3() 移动 3 个公共变量和逻辑。

public abstract class SuperClass {
    String a;
    String b;
    Double c;

    public void m1(){
        //All the 4 variables are used here.
        m1logic();
    }

    public void  m2(){
        //All the variables are used here.
        m2logic();
    }

    public void  m3(){
        //All the variables are used here.
        m3logic();
    }

    public abstract void  m1logic();

    public abstract void  m2logic();

    public abstract void  m3logic();
}

public class ClassA extends SuperClass {

    UserDefinedTypeA d;

    public void m1logic(){
        // UserDefinedTypeA logic
    }

    public void m2logic(){
        // UserDefinedTypeA logic
    }

    public void m3logic(){
        // UserDefinedTypeA logic
    }           
}

public class ClassB extends SuperClass {

    UserDefinedTypeB d;

    public void m1logic(){
        // UserDefinedTypeB logic
    }

    public void m2logic(){
        // UserDefinedTypeB logic
    }

    public void m3logic(){
        // UserDefinedTypeB logic
    }           
}

【讨论】：

【解决方案2】：

您可以考虑使用泛型：

public abstract class SuperClass<T> {
    String a;
    String b;
    Double c;
    T d;

    public void m1(){
        //All the 4 variables are used here.
        m1logic();
    }

    public void  m2(){
        //All the variables are used here.
        m2logic();
    }

    public void  m3(){
        //All the variables are used here.
        m3logic();
    }

    public abstract void  m1logic();
    public abstract void  m2logic();
    public abstract void  m3logic();
}

public class ClassA extends SuperClass<UserDefinedTypeA> {
    public void m1logic(){
        // UserDefinedTypeA logic
    }

    public void m2logic(){
        // UserDefinedTypeA logic
    }

    public void m3logic(){
        // UserDefinedTypeA logic
    }           
}

public class ClassB extends SuperClass<UserDefinedTypeB> {
    public void m1logic(){
        // UserDefinedTypeB logic
    }

    public void m2logic(){
        // UserDefinedTypeB logic
    }

    public void m3logic(){
        // UserDefinedTypeB logic
    }           
}

我也会使用double 而不是Double，除非你有非常好的理由。

【讨论】：