可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试):

问题:

I was wondering, is it possible that a superclass to access the methods of a inherited subclass, like for example in Java?

I know that a subclass can override and even implements, in case of abstract classes, the methods of the superclass, but the question mentioned above is possible?

Thanks

回答1:

Example in c#.. in superclass make abstract method, which is implemented in derived class

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

回答2:

Java, PHP, Ruby, Python, C# (and so on) methods are always virtual, so, no matter what, when you override a method in a subclass, this version will be called:

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

So, you not just CAN access your subclass method, you HAVE TO.

Just for comparison, in C++, for example, things work different. If you don't declare a method as virtual, you can't override it.

回答3:

I' ll try to explain as they explained to me at university.

You have a reference:

Object o = new Object()

His static type(ST) is Object : this is his own type and never changes.
His dynamic type(DT) is also Object(in this case): the reference point to an object of type Object, but it can change.

for example if i write :
```
Object o = new String("abc") // now his ST == Object but the DT == String
```

That being said:

Upcasting is always permitted: consider two references s and r. the assignment s=r compile and execute always if ST(r) <= ST(s) (the static type of r is, in the hierarchi, less or equals to the static type of s)

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

Downcasting: at compile-time it is always legal to downcast from a type X to a type Y if X and Y belong to hierarchy. Consider the reference s. I want to cast s to a type C, so if C <= TS(s) it will always compile if I do the cast as : C r = (C)s

for example:

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!

When we run our application if the downcast fails, Java raise an Exception. Otherwise it success.

To downcast correctly: consider a reference ref and we want to cast to a type C. So a downcast will success if DT(ref) <= C <= ST(ref) .
And the downcast will be obtained as: C ref2 = (C)ref

for example:

// 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: please forgive if I made some mistake but I wrote a bit in a hurry.