oop中子类的超类访问方法

我想知道，是否有可能一个超类访问一个继承的子类的方法，比如在Java中

我知道，对于抽象类，子类可以重写甚至实现超类的方法，但是上面提到的问题是可能的吗

---

谢谢

c.中的示例。。在超类中生成抽象方法，该方法在派生类中实现

public abstract class SuperCLass
{
    public void CallSubMethod()
    {
        Test(); // calls method in derived class
    }
    public abstract void Test();
}

public class SubClas : SuperCLass
{
    public override void Test()
    {
        // code here 
    }
}

---

Java、PHP、Ruby、Python、C等方法始终是虚拟的，因此，无论怎样，当您重写子类中的方法时，此版本将被调用：

public class SuperClass {
    public void someMethod() {
        otherMethod();
    }

    public void otherMethod() {
        System.out.println("Super");
    }
}

public class SubClass extends SuperClass {
    public void otherMethod() {
        System.out.println("Sub");
    }
}

SubClass o1 = new SubClass();
o1.someMethod(); // Outputs: Sub 

SuperClass o2 = new SubClass();
o2.someMethod(); // Also outputs: Sub

因此，您不仅可以访问子类方法，还必须访问

---

只是为了比较，例如C++中的事情不同。如果你不将一个方法声明为虚拟的，你就不能重写它。

在Java中，这是不可能的，我认为你所要求的将与OOP背道而驰。

我将尝试按照他们在大学里向我解释的那样解释

你有一个推荐人：

Object o = new Object()

他的静态类型是Object：这是他自己的类型，从不更改

在这种情况下，他的动态typeDT也是object：指向object类型的对象的引用点，但它可以更改

例如，如果我写：

也就是说：

---

始终允许上行：考虑两个引用S和R。赋值s=r总是编译并执行，如果你是说向下转换一个对象？是的，你可以。当然，在某些情况下。是的，我认为这是正确的，你能举个例子@riskio吗？我给出了一个完整的答案。如果你不明白，问我。

Object o = new String("abc") // now his ST == Object but the DT == String

class A { }
class B extends A { }
...
A a = new A(); B b = new B();
a = b  // OK, upcast

class A { }
class B extends A { }
class C extends A { }
...
A a = new A(); B b = new B();
C c = new C();
...
b = c // ILLEGAL
b = (B)a // OK at compile-time but maybe at run-time it is not!

// I suggest to write the hierarchy in a piece of paper and 
// try the rules before coding.

class A { }
class B extends A { }
class C extends A { }
class D extends B { }
...

A a = new A(); B b = new B();
C c = new C(); D d = new D();
A r = new B();
A s = new D();
a = b; // OK, upcast
a = d; // OK, upcast
/* b = c; */ // ILLEGAL
b = (B)r; // OK, downcast
d = (D)r; // downcast: it compiles, but fails at run-time
d = (D)s; // OK, downcast
/* b = s; */ // ILLEGAL
/* d = (D)c; */ // ILLEGAL
b = (B)s; // OK, downcast
b = (D)s; // OK, downcast