Java 重写对类没有预期效果

我正在测试扩展类和重写函数。使用下面的代码，当我调用JonsClass2.jonsCalcFromClass（2）时，我还没有得到编译错误，我仍然从JonsClass2得到响应，而不是我预期的从JonsClass3得到的重写

另外，我必须使用JonsClass2 JC2=new JonsClass2（）从main进行这些调用；然后JC2.jonsCalcFromClass（2）；否则编译器会抱怨我正在从静态上下文调用非静态

class JonsClass3 extends JonsClass2 {

    @Override
    protected int jonsCalcFromClass(int a) {
        if (a==2) System.out.print("JonsClass3 Called from main using 2 as passed variable  ");
        if (a==1) System.out.print("JonsClass3  from main using 1 as passed variable  ");
        int c = (a + 2);
        return c;
    }

    @Override
    protected double jonsCalcFromClass(double b) {
        System.out.print("This is double line being called in JonsClass3> ");
        double c = (b + 300.10);
        return c;
    }

}

class JonsClass2 {

    protected int jonsCalcFromClass(int a) {
        System.out.print("This is the int line from JonsClass2 being called > ");
        int c = (a + 2);
        return c;
    }

    protected double jonsCalcFromClass(double b) {
        System.out.print("This is double line being called in JonsClass2> ");
        double c = (b + 3.10);
        return c;
    }

}

---

注意你创建的实例

JonsClass2 js2 = new JonsClass2();
JonsClass2 js3 = new JonsClass3();
js2.jonsCalcFromClass(2);   // This is the int line from JonsClass2 being called >
js3.jonsCalcFromClass(2);   //JonsClass3 Called from main using 2 as passed variable 

---

在您的示例中，

onsClass2 JC2=newjonsclass2（）

您创建了

JonsClass2

的实例，因此不会调用

JonsClass3

中的方法。

请注意您创建的实例

JonsClass2 js2 = new JonsClass2();
JonsClass2 js3 = new JonsClass3();
js2.jonsCalcFromClass(2);   // This is the int line from JonsClass2 being called >
js3.jonsCalcFromClass(2);   //JonsClass3 Called from main using 2 as passed variable 

在您的示例中，

onsClass2 JC2=newjonsclass2（）

您创建了

JonsClass2

的实例，因此不会调用

JonsClass3

中的方法

编译器抱怨我正在从静态调用非静态 上下文

我们不能直接从静态方法（如main）调用非静态方法。因为静态方法是类的方法。但是非静态方法是对象方法，所以我们应该在对象上调用它。因此：

public static void main(String[] args) { 
  jonsCalcFromClass(1) // compile error

  JonsClass2 JC2 = new JonsClass3()
  JC2.jonsCalcFromClass(1) // correct
}

如果需要多态性行为，应执行以下操作：

JonsClass2 JC2=新JonsClass3（）

编译器抱怨我正在从静态调用非静态
上下文

我们不能直接从静态方法（如main）调用非静态方法。因为静态方法是类的方法。但是非静态方法是对象方法，所以我们应该在对象上调用它。因此：

public static void main(String[] args) { 
  jonsCalcFromClass(1) // compile error

  JonsClass2 JC2 = new JonsClass3()
  JC2.jonsCalcFromClass(1) // correct
}

如果需要多态性行为，应执行以下操作：
JonsClass2 JC2=新JonsClass3（）
要实现这一点，在实例化JC2时，应该是
JonsClass2 JC2=newjonsclass3（）
如果您重写类
X
中的方法，则该重写仅适用于类
X
的实例（以及
X
的子类，如果它们自己不重写它）。基类的实例当然仍将使用该方法的基版本。这就是所谓的多态性（即，要执行的实际代码取决于调用它的对象的实际类型），这就是重写背后的全部思想。请显示
publicstaticvoidmain（String[]args）
方法的代码。有些人要求我使用的主要方法：publicsclass SandPit{publicstaticvoidmain（字符串[]args）{JonsClass2 jc2=new JonsClass2（）；jc2.jonsCalcFromClass（2）；我所期望的是JonsClass3扩展JonsClass2将强制JonsClass2使用来自JonsClass3的重写方法。如果重写仅适用于JonsClass3的实例，那么我误解了它的应用方式。我认为最好重写一个方法，而不重写其他方法，以便利用t中的方法当实例化JC2时，要实现这一点的父类应该是
JonsClass2 JC2=new JonsClass3（）；
，如果您在类
X
中重写一个方法，该方法只应用于类
X
的实例（以及
X
的子类，如果它们自己不重写的话）。基类的实例当然仍将使用该方法的基本版本。这称为多态性（即，要执行的实际代码取决于调用它的对象的实际类型），这是重写背后的全部思想。请显示
公共静态void main（String[]args）的代码
method。有些人询问我使用的主要方法：公共类SandPit{public static void Main（String[]args）{JonsClass2 jc2=new JonsClass2（）；jc2.jonsCalcFromClass（2）；我所期望的是JonsClass3扩展JonsClass2将强制JonsClass2使用来自JonsClass3的重写方法。如果重写仅适用于JonsClass3的实例，那么我误解了它的应用方式。我认为最好重写一个方法，而不重写其他方法，以便利用t中的方法他是家长班的学生