标签: polymorphism

当我开始寻找多态性的好处时,我在这里找到了这个问题.但在这里我无法找到答案.让我告诉我想找到什么.这里我有一些课程:

class CoolingMachines{
    public void startMachine(){
        //No implementationion
    }
    public void stopMachine(){
        //No implementationion
    }
}

class Refrigerator extends CoolingMachines{
    public void startMachine(){
        System.out.println("Refrigerator Starts");
    }
    public void stopMachine(){
        System.out.println("Refrigerator Stop");
    }
    public void trip(){
        System.out.println("Refrigerator Trip");
    }
}

class AirConditioner extends CoolingMachines{
    public void startMachine(){
        System.out.println("AC Starts");
    }
    public void stopMachine(){
        System.out.println("AC Stop");
    }
}

public class PolymorphismDemo {
    CoolingMachines cm = new Refrigerator();
    Refrigerator rf = new Refrigerator();
}

现在我在Demo类中创建了两个对象,并且是对它的引用Refrigerator.我完全理解从rf对象我可以调用trip()方法 …

有没有办法在C编程语言中编写类似OO的代码？

也可以看看:

• 你能用C编写面向对象的代码吗？
• C中的面向对象

通过搜索"[c] oo"找到.

我最近得到了以下代码作为一种帮助理解Polymorphism和Inheritance在OOP - C#中的谜题.

// No compiling!
public class A
{
     public virtual string GetName()
     {
          return "A";
     }
 }

 public class B:A
 {
     public override string GetName()
     {
         return "B";
     }
 }

 public class C:B
 {
     public new string GetName()
     {
         return "C";
     }
 }

 void Main()
 {
     A instance = new C();
     Console.WriteLine(instance.GetName());
 }
 // No compiling!

现在,在与提出拼图的其他开发者进行了长时间的长时间聊天后,我知道输出是什么,但我不会为你破坏它.我真正遇到的唯一问题是我们如何得到输出,代码如何逐步通过,继承什么等等.

我认为C会返回,因为它似乎是定义的类.然后我通过我的脑袋了解是否B会因为C继承而返回B- 但B也继承A(这是我困惑的地方!).

题:

任何人都可以解释多态性和继承如何在检索输出中发挥作用,最终显示在屏幕上？

我有这个基类:

abstract class Base
{
  public int x
  {
    get { throw new NotImplementedException(); }
  }
}

以下的后代:

class Derived : Base
{
  public int x
  {
    get { //Actual Implementaion }
  }
}

当我编译时,我得到这个警告,说Derived类的定义x是要隐藏Base的版本.是否可以覆盖c#like方法中的属性？

我有一位同事告诉我,他曾经为一家公司工作,该公司的政策是在代码中永远不会有条件("if"和"switch"语句)并且他们让代码中的所有决策都使用多态性和(我猜)其他一些OO原则.

我有点理解这背后的原因,让代码更干,更容易更新,但我正在寻找对这个概念的更深入的解释.或者它可能是更通用的设计方法的一部分.

如果任何人有任何资源或愿意解释甚至有更多与此相关的术语我可以用来找到更多的答案,我将非常感激.

我发现一个关于SO的问题有点相关但我不熟悉C++,所以我不太了解那里的答案.

(我不是OO guru btw,但我可以管理)

我最熟练的PHP,在那之后,我更喜欢那些使用这些语言的信息.

更新:我会问我的同事有关他的确切含义的更多信息.

2015年更新:经过多年的编程经验,我现在看到这个策略的目的可能是阻止程序员通过在某些地方添加条件(if语句)来随意添加功能.扩展软件的更好方法是使用"开放/封闭原则",其中使用继承和多态来扩展软件.我强烈怀疑这项政策是否对所有条件都非常严格,因为如果没有这些条件,这种政策就很难完全实现.

我有一个抽象类,我想把它推广到一个扩展它的类.

我将子类名称作为字符串.

除此以外...

String childClassString;
MyAbstractClass myObject;

if (childClassString = "myExtenedObjectA")
    myObject = new ExtenedObjectA();
if (childClassString = "myExtenedObjectB")
    myObject = new ExtenedObjectB();

我怎样才能做到这一点？基本上我如何摆脱这里的if语句？

有没有一种简单的方法来验证对象属于给定的类？例如,我能做到

if(a.getClass() = (new MyClass()).getClass())
{
    //do something
}

但这需要每次动态实例化一个新对象,只是丢弃它.有没有更好的方法来检查"a"属于"MyClass"类？

我试图通过程序员布鲁斯的一个教程来完成,该教程应该允许多态JSON的反序列化.

完整的列表可以在这里找到 程序员布鲁斯教程(伟大的东西顺便说一句)

我已经完成了前五个没有问题,但我在最后一个(示例6)遇到了障碍,当然这是我真正需要工作的那个.

我在编译时遇到以下错误

ObjectMapper类型中的方法readValue(JsonParser,Class)不适用于参数(ObjectNode,Class)

它是由大量代码引起的

  public Animal deserialize(  
      JsonParser jp, DeserializationContext ctxt)   
      throws IOException, JsonProcessingException  
  {  
    ObjectMapper mapper = (ObjectMapper) jp.getCodec();  
    ObjectNode root = (ObjectNode) mapper.readTree(jp);  
    Class<? extends Animal> animalClass = null;  
    Iterator<Entry<String, JsonNode>> elementsIterator =   
        root.getFields();  
    while (elementsIterator.hasNext())  
    {  
      Entry<String, JsonNode> element=elementsIterator.next();  
      String name = element.getKey();  
      if (registry.containsKey(name))  
      {  
        animalClass = registry.get(name);  
        break;  
      }  
    }  
    if (animalClass == null) return null;  
    return mapper.readValue(root, animalClass);
  }  
} 

具体由行

return mapper.readValue(root,animalClass);

有没有人遇到过这个问题,如果有的话,是否有解决方案？

我很感激任何人都可以给予任何帮助.

令我感到困惑的是,haskell编译器有时会推断出比我预期的更不易变形的类型,例如在使用无点定义时.

似乎问题是"单态限制",默认情况下在旧版本的编译器上启用.

考虑以下haskell程序:

{-# LANGUAGE MonomorphismRestriction #-}

import Data.List(sortBy)

plus = (+)
plus' x = (+ x)

sort = sortBy compare

main = do
  print $ plus' 1.0 2.0
  print $ plus 1.0 2.0
  print $ sort [3, 1, 2]

如果我编译它,ghc我没有获得错误,可执行文件的输出是:

3.0
3.0
[1,2,3]

如果我将main身体改为:

main = do
  print $ plus' 1.0 2.0
  print $ plus (1 :: Int) 2
  print $ sort [3, 1, 2]

我没有编译时错误,输出变为:

3.0
3
[1,2,3]

正如所料.但是,如果我尝试将其更改为:

main = do
  print $ …

如何以易于理解的方式描述多态？

我们可以在Internet和书籍上找到关于该主题的大量信息,例如Type polymorphism.但是,让我们尽可能地让它变得简单.