oop - oop 中子类的超类访问方法

Question

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

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

谢谢

Answer 1

Java、PHP、Ruby、Python、C#（等等）方法总是virtual，所以，无论如何，当你在子类中重写一个方法时，这个版本将被调用：

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 2

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

Answer 3

我会尽力解释他们在大学时向我解释的。

你有一个参考：

Object o = new Object()

• 他的静态类型（ST）是 Object ：这是他自己的类型，永远不会改变。

• 他的动态类型（DT）也是Object（在这种情况下）：指向Object类型对象的引用，但它可以改变。

  例如，如果我写：

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

话虽如此：

• 向上转型总是被允许的：考虑两个引用s和r。赋值 s=r 总是编译和执行 if ST(r) <= ST(s)（在层次结构中， r 的静态类型小于或等于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 <= 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!
  

  如果向下转换失败，当我们运行我们的应用程序时，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。