Tag: 多态

调用超类方法而不是子类方法: 我们来看看这段代码： public class ParentClass { public void foo(Object o) { System.out.println(“Parent”); } } public class SubClass extends ParentClass { public void foo(String s) { System.out.println(“Child”); } public static void main(String args[]) { ParentClass p = new SubClass(); p.foo(“hello”); } } 我希望这打印出“Child”，但结果是“Parent”。为什么java会调用超类，我该怎么做才能让它调用子类中的方法？

当我可以通过引用子类访问所有方法时，为什么要引用基类？: 我正在学习java概念。我对javainheritance概念有疑问。在inheritance中，我们可以将子类实例分配给基类引用，并且我们只能访问基类函数。我们可以将inheritance层次结构中的任何子类实例分配给基类引用。对于分配给特定基类引用的实例类型，我们只能访问基类函数，但我没有发现任何区别。任何人都可以给我实际的概念，为什么我们必须将子类实例分配给基类引用？有什么需要这样做？相反，我们可以从子类引用只知道访问那些基类函数。通过考虑层次结构中的特定基类和许多子类来解释。

java中方法重载的行为: 我尝试了以下代码 public class HelloWorld { public void printData(Test t) { System.out.println(“Reached 1”); } public void printData(newTest t) { System.out.println(“Reached 2”); } public void printData(newTest1 t) { System.out.println(“Reached 3”); } public static void main(String args[]) { Test t1 = new Test(); HelloWorld h = new HelloWorld(); h.printData(t1); NewTest t2 = new NewTest(); h.printData(t2); NewTest1 t3 = […]

当涉及内部类时，Javainheritance如何工作: 当内部类存在时，我无法理解inheritance在Java中的工作原理。我正在研究一个子类需要稍微改变它的父类内部类的function的东西。我在下面提出了一个更简单，更讽刺的例子。我希望这段代码打印“我是一个ChildClass.InnerClass”，而是打印“我是一个ParentClass.InnerClass”。为什么是这样？此外，如果我将main中的obj对象更改为ChildClass类型，则输出将更改为“我是ChildClass.InnerClass”。为什么是这样？一般来说，改变对象父类内部对象行为的推荐方法是什么？ class InnerClassTest { //———————————————————————– // PARENT CLASS class ParentClass { public ParentClass() { x = new InnerClass(); } InnerClass x; class InnerClass { public void speak() { System.out.println(“I am a ParentClass.InnerClass”); } } } //———————————————————————– // CHILD CLASS class ChildClass extends ParentClass { public ChildClass() { x […]

多态性和静态方法: 我对此代码有疑问 public Car { public static void m1(){ System.out.println(“a”); } public void m2(){ System.out.println(“b”); } } class Mini extends Car { public static void m1() { System.out.println(“c”); } public void m2(){ System.out.println(“d”); } public static void main(String args[]) { Car c = new Mini(); c.m1(); c.m2(); } } 我知道多态不适用于静态方法，只适用于实例方法。并且覆盖不适用于静态方法。因此我认为这个程序应该打印出来：c，d 因为c调用m1方法，但它是静态的，所以它不能覆盖它并且它在类Mini而不是Car中调用方法。它是否正确？但是，我的教科书说答案应该是：a，d 这是一个错字吗？ […]

在父类之间来回转换后，子对象是否会丢失其唯一属性: 考虑以下类： public class Phone { private boolean has3g; public boolean has3g() { return has3g; } public void setHas3g(boolean newVal) { has3g = newVal; } } public class Blackberry extends Phone { private boolean hasKeyboard; public boolean hasKeyboard() { return hasKeyboard; } public void setHasKeyboard(boolean newVal) { hasKeyboard = newVal; } } 如果我要创建一个Blackberry实例，将其转换为Phone对象，然后将其转换回Blackberry ，原始Blackberry对象是否会丢失其成员变量？例如： Blackbery […]

Java：使用多态来避免if语句？: 我正在尝试编写一个java程序，根据用户选择的内容初始化某些布局。我想要做的是尽量避免编写一堆if语句，这样如果需要添加更多布局，代码可以扩展以备将来使用。我听说实现这个的最好方法是使用多态，但我对多态的理解仍然有点模糊。说我想实现这个案例： if (user choose layoutA) { initialize layoutA } if (user choose layoutB) { initialize layoutB } if (user choose layoutC) {initialize layoutC } 我正在考虑为要实现的类创建一个接口。令我困惑的是它在main（）中是如何工作的，我是否还需要条件if或switch语句来确定要实例化哪个类？ interface LayoutHandler { public void initializeLayout(); } class layoutA implements LayoutHandler { public void initialize Layout {initialize layout A} } class layoutB implements LayoutHandler { public […]

什么时候可以使用instanceof？: 我正在设计一款游戏。在游戏中，各种游戏对象根据他们需要做的事情扩展不同的接口（和一个抽象类），并传递给处理程序，这些处理程序按照定义的时间间隔处理具有特定接口的项目（它们实际上将所有工作分散开来以一种简洁的方式确保始终处理输入/video/等）。无论如何，其中一些对象扩展了抽象类Collider并传递给CollisionHandler。 Collider类和处理程序负责碰撞中涉及的所有技术，并且只要求对象实现collidesWith（Collider c）函数，并根据它碰撞的内容进行修改。许多不同类的对象将彼此碰撞，并且将根据它们碰撞的对象的类型及其特定属性而以非常不同的方式起作用。完美的解决方案似乎是像这样使用instanceof： class SomeNPC extends Collider{ collidesWith(Collider c){ if(c instanceof enemy){ Fight it or run away depending on your attributes and theirs. } else if(c instanceof food){ Eat it, but only if it’s yellow. } else if(c instanceof BeamOfLight){ Try to move towards its source. } } } 这实际上似乎是一个合法的地方。我感觉很糟糕。 […]

多态和方法重载: 我有一个快速而直接的问题：我有这个简单的课程： public class A { public void m(Object o) { System.out.println(“m with Object called”); } public void m(Number n) { System.out.println(“m with Number called”); } public static void main(String[] args) { A a = new A(); // why will m(Number) be called? am(null); } } 更新：实际上是实际调用Number的方法。对此感到抱歉。如果我调用am（null），则使用Number参数调用方法。我的问题是：这是为什么？这个指定的java语言规范在哪里？

接受两种不同类型作为参数的方法: 我正在编写一个方法，它应该接受两个类型之一的对象作为其参数，这两个类型不共享除Object之外的父类型。例如，类型是梦想和大蒜。你可以做dreams.crush()和garlic.crush() 。我想有一个方法utterlyDestroy(parameter) ，它接受Dreams和Garlic作为它的参数。 utterlyDestroy(parameter) { parameter.crush() } Garlic和dream都是某些库的一部分，所以让它们实现一个接口ICrushable（这样我就可以编写utterlyDestroy(ICrushable parameter) ）不是一个选项。我的方法体很长，所以重载就意味着重复代码。丑陋。我相信我可以使用reflection并做一些类黑客攻击。丑陋。我尝试使用generics，但显然我不能写类似的东西 utterlyDestroy( parameter) 是否有可能将大蒜强加给梦想？ utterlyDestroy(Object parameter) { ((Dreams)parameter).crush() } 但这仍然是丑陋的。我的其他选择是什么？处理这种情况的首选方法是什么？