Question

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

我知道子类可以覆盖甚至实现，在抽象类的情况下，超类的方法，但上面提到的问题是可能的吗？

由于

Answer 1

在超类中的c＃..中的示例make abstract方法，它在派生类

中实现

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 
    }
}

Answer 2

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 ++中，事情的工作方式不同。如果您未将方法声明为虚拟方法，则无法覆盖它。

Answer 3

我会在他们在大学时向我解释时试着解释一下。

你有一个参考：

Object o = new Object()

他的静态类型（ST）是对象：这是他自己的类型，永远不会改变。
他的动态类型（DT）也是Object（在本例中）：指向Object类型的对象的引用，但它可以更改。

例如，如果我写：
```
Object o = new String("abc") // now his ST == Object but the DT == String
```

话虽如此：

始终允许向上转换：考虑两个引用 s 和 r 。赋值s = r总是编译并执行ST(r) <= ST(s)（ r 的静态类型，在层次结构中，小于或等于 static输入 s 的

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

向下转发：在编译时，如果 X 类型转发到 Y 类型总是合法的> X 和 Y 属于层次结构。考虑参考 s 。我想将 s 强制转换为类型 C ，所以如果C＆lt; = TS（s），如果我执行强制转换，它将始终编译为：C r = (C)s

例如：

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!

当我们运行我们的应用程序时，如果downcast失败，Java会引发异常。否则就会成功。

正确地向下倾斜： 考虑引用 ref ，我们想要转换为 C 类型。如果DT(ref) <= C <= ST(ref)，那么贬低就会成功而这个向下转播将获得：C ref2 = (C)ref

例如：

// 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

PS：如果我犯了一些错误，请原谅我，但我赶紧写了一下。

Answer 4

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

超类访问oop中子类的方法

4 个答案: