Tag: 多态

从父类ctor调用重写方法

我尝试从父类的构造函数中调用重写方法，并注意到跨语言的不同行为。 C++ – 回声A.foo() class A{ public: A(){foo();} virtual void foo(){cout<<"A.foo()";} }; class B : public A{ public: B(){} void foo(){cout<<"B.foo()";} }; int main(){ B *b = new B(); } Java – 回声B.foo() class A{ public A(){foo();} public void foo(){System.out.println(“A.foo()”);} } class B extends A{ public void foo(){System.out.println(“B.foo()”);} } class Demo{ public static void main(String […]

隐藏Javainheritance中的字段

在类中，与超类中的字段具有相同名称的字段会隐藏超类的字段。 public class Test { public static void main(String[] args) { Father father = new Son(); System.out.println(father.i); //why 1? System.out.println(father.getI()); //2 System.out.println(father.j); //why 10? System.out.println(father.getJ()); //why 10? System.out.println(); Son son = new Son(); System.out.println(son.i); //2 System.out.println(son.getI()); //2 System.out.println(son.j); //20 System.out.println(son.getJ()); //why 10? } } class Son extends Father { int i = 2; int j […]

将派生类传递给需要覆盖期望基类的方法

我有一个类A，带有抽象方法doAction（BaseClass obj），期望一个类型为BaseClass的参数 public class A { //…. abstract void doAction(BaseClass obj); //…. } 现在，我有另一个需要扩展A的B类。但是，B的doAction方法需要使用扩展BaseClass的对象DerivedClass。 public class B extends class A { //.. void doAction(DerivedClass obj) { obj.callMethodAvailableOnlyInDerivedClass(); } } 我如何处理这种情况，我需要将类型为DerivedClass的param传递给期望BaseClass时要重写的方法？ 谢谢！

从子类访问父类的私有实例变量？

假设我们有一个类foo ，它有一个私有实例变量bar 。 现在让我们有另一个类， baz ，它extends foo 。 如果foo中没有定义访问器方法， baz非静态方法可以访问foo的变量bar吗？ 顺便说一下，我在Java工作。

重载和重载方法中的多态性

我们来看看这个简单的Java代码： public class Animal { public void eat() { System.out.println(“Generic Animal Eating Generically”); } } public class Horse extends Animal { public void eat() { System.out.println(“Horse eating hay “); } public void eat(String s) { System.out.println(“Horse eating ” + s); } } 我试图找出三个eat（）方法的哪个版本将运行。 现在，当我打字 Animal a = new Animal(); a.eat(); 输出是“Generic Animal Eating Generically”，这是完全可以理解的。 输入时会发生同样的事情： […]

Java是否有任何理由对同一类中的重载方法使用延迟/静态绑定？

Java是否为重载方法使用早期绑定有什么特定原因？ 是不是可以使用后期绑定？ 例： public class SomeClass { public void doSomething(Integer i) { System.out.println(“INTEGER”); } public void doSomething(Object o) { System.out.println(“OBJECT”); } public static void main (String[] args) { Object i = new Integer(2); Object o = new Object(); SomeClass sc = new SomeClass(); sc.doSomething(i); sc.doSomething(o); } } 打印：对象对象 我宁愿期待：INTEGER OBJECT

在Java中重载和多次调度

我有一个集合（或列表或数组列表），我想在其中放置String值和double值。 我决定使它成为对象的集合并使用重载ond多态，但我做错了。 我做了一点测试： public class OOP { void prova(Object o){ System.out.println(“object”); } void prova(Integer i){ System.out.println(“integer”); } void prova(String s){ System.out.println(“string”); } void test(){ Object o = new String(” “); this.prova(o); // Prints ‘object’!!! Why?!?!? } public static void main(String[] args) { OOP oop = new OOP(); oop.test(); // Prints ‘object’!!! Why?!?!? } } 在测试中，似乎参数类型是在编译时决定的，而不是在运行时决定的。 […]

重载是编译时多态。 真？

我知道覆盖和重载之间的语法差异。 我也知道覆盖是运行时多态，重载是编译时多态。 但我的问题是：“重载是否真的是编译时多态？方法调用是否真的在编译时求解？”。 为了澄清我的观点，让我们考虑一个示例类。 public class Greeter { public void greetMe() { System.out.println(“Hello”); } public void greetMe(String name) { System.out.println(“Hello ” + name); } public void wishLuck() { System.out.println(“Good Luck”); } } 由于所有方法greetMe(), greetMe(String name), wishLuck()都是公共的，它们都可以被覆盖（包括重载的），对吧？ 例如， public class FancyGreeter extends Greeter { public void greetMe() { System.out.println(“***********”); System.out.println(“* Hello *”); System.out.println(“***********”); } } 现在，请考虑以下代码段： […]

如何使用多态而不是instanceof？ （为什么？）

如果我们采用以下代码： Shape p1 = new Square(); Square c1; if(p1 instanceof Square) { c1 = (Square) p1; } 将多态性与instanceof什么意义，顺便说一句，为什么它更好？ 编辑：我理解多态是什么; 我缺少的是如何使用它而不是instanceof 。

与实例变量的多态性

这是我写的三个类： public class Shape { public int x = 0; public void getArea() { System.out.println(“I don’t know my area!”); } public String toString() { return “I am a shape!”; } public int getX() { return x; } } public class Rectangle extends Shape { public int x = 1; public int getX() { return x; […]