继承和多态性之间的区别是什么?

这是多态性:

public interface Animal 
{
  string Name { get; }
}
public class Dog : Animal
{
  public string Name { get { return "Dog"; } }
}
public class Cat : Animal
{
  public string Name { get { return "Cat"; } }
}
public class Test 
{
  static void Main()
  {
      // Polymorphism
      Animal animal = new Dog();
      Animal animalTwo = new Cat();
      Console.WriteLine(animal.Name);
      Console.WriteLine(animalTwo.Name);
  }
}

这是继承:

public class BaseClass
    {
        public string HelloMessage = "Hello, World!";
    }
    public class SubClass : BaseClass
    {
        public string ArbitraryMessage = "Uh, Hi!";
    }
    public class Test
    {
        static void Main()
        {
            SubClass subClass = new SubClass();
            // Inheritence
            Console.WriteLine(subClass.HelloMessage);
        }
    }

继承意味着如果你创建了一个带有公共字段TankSize的类Car，那么你从它派生了一个类SuperCar，最后一个继承了Car的字段TankSize。

多态性是这样一个事实:每次在代码中，你有一个方法，其中期望有一个Car，你可以传递一个SuperCar，它将表现得像一个Car。

根据需要定义虚拟方法，您将调用基类上的方法，但是您正在处理的实际对象将执行其虚拟方法的版本，因此您将调用SuperCar。获取price而不是Car。

这几个字，更多的，我看到其他人已经回答我写。

让我们用我最喜欢的动词，我们发现:

http://en.wikipedia.org/wiki/Polymorphism_%28computer_science%29

http://msdn.microsoft.com/en-us/library/ms173152%28v=vs.80%29.aspx

多态性和继承是c#和面向对象编程中必不可少的基本概念。说你懂c#而不懂这个，就像知道怎么说英语却不知道字母表是什么一样。很抱歉直言不讳，但这是事实。

从上面的Wiki链接(这不是我的)，这里是多态性的一个例子(转换为c#…)

public class Animal
{
    public virtual String talk() { return "Hi"; }
    public string sing() { return "lalala"; }
}
public class Cat : Animal
{
    public override String talk() { return "Meow!"; }
}
public class Dog : Animal
{
    public override String  talk() { return "Woof!"; }
    public new string sing() { return "woofa woofa woooof"; }
}
public class CSharpExampleTestBecauseYouAskedForIt
{
    public CSharpExampleTestBecauseYouAskedForIt()
    {
        write(new Cat());
        write(new Dog());
    }
    public void write(Animal a) {
        System.Diagnostics.Debug.WriteLine(a.talk());
    }
}

让我们用一种更有趣的方式来解释这个。继承是派生类利用基类功能的方式。多态性是基类利用派生类实现的方式。

public class Triangle :Shape {
 public int getSides() {
  return 3;
 }
}
}
public class Shape {
 public boolean isSharp(){
  return true;
 }
 public virtual int getSides(){
  return 0 ;
 }
 public static void main() {
  Triangle tri = new Triangle();
  System.Console.WriteLine("Triangle is a type of sharp? " + tri.isSharp());  //Inheritance 
  Shape shape = new Triangle();
  System.Console.WriteLine("My shape has " + shape.getSides() + " sides.");   //Polymorphism 
 }
}

多态性是重写继承的行为。

如果你不重写它，它就不是多态性，它只是继承。

继承和多态性没有区别。多态性是继承的一部分，没有它就不可能存在。简而言之，多态性是一种将对象视为基类对象的能力，但是在基类上调用VIRTUAL方法将从子类调用适当的方法。这里有一个很好的例子:http://www.psworld.pl/Programming/Inheritance

当您从基类派生一个类时，派生类将继承基类除了构造函数以外的所有成员，尽管派生类是否能够访问这些成员将取决于基类中这些成员的可访问性。c#通过继承为我们提供了多态性。基于继承的多态性允许我们在基类中定义方法，并用派生类实现覆盖它们。因此，如果您有一个基类对象，它可能包含几个派生类对象中的一个，那么适当使用多态性允许您调用一个方法，该方法将根据对象所属的派生类的类型不同而工作。

参考:http://www.codeproject.com/Articles/1445/Introduction-to-inheritance-polymorphism-in-C

这都是关于行为。

一个类声明了一个特定的行为(接口或契约):

该类也可以定义该行为(实现)或将其全部或部分委托给其任何子类:

伪代码:

class Animal {
    method walk()
    method speak()
    method jump()
    // ... here goes the implementation of the methods
}

通过子类化，使一个类继承另一个类的行为。

当一个方法的实现被委托给子类时，该方法在基类中被称为abstract，并且在Java等语言中，整个基类也变得抽象:

abstract class Animal {
    method walk() {
       doWalk()
    }
    method speak() {
       print "hi, I am an animal!"
    }
    abstract method jump() // delegated to specific animals
}
class Horse inherits from Animal {
    override method walk() {
        doWalkLikeAHorse()
    }
    override method speak() {
        print "hi, I am a horse!"
    }
    override method jump() { 
        doJumpLikeAHorse()
    }
}
class Elephant inherits from Animal {
    override method walk() {
        doWalkLikeAnElephant()
    }
    override method speak() {
        print "hi, I am an elephant!"
    }
    override method jump() { 
        throw error "Sorry, I can't jump!!"
    } 
}

默认情况下，类的行为是虚，这意味着任何类的方法都可以被任何子类覆盖。在c#和Java等语言中就是这样工作的，但在c++中就不一定了。

实质上，基类的行为只是虚的，并且可以假定为"多重"(poly)当子类覆盖虚拟行为时，"不同形式"(morphs)。这就是为什么它被称为多态性。在伪代码:

function makeAnimalSpeak(Animal animal) {
    animal.speak();
}
makeAnimalSpeak(new Elephant()) // output: "hi, I am an elephant"
makeAnimalSpeak(new Horse())  // output: "hi, I am a horse"

其他人已经给你提供了更好的例子。

在像c#和Java这样的语言中，你有接口的想法(在c++中不存在)，这只是一个行为的声明。与类不同，接口没有实现行为的义务。这只是一个声明。任何类都可以实现这种行为，无论它们从哪个基类继承。在伪代码:

interface FlyingBeing {
    method fly()
}
class FlyingPig inherits from Animal implements FlyingBeing {
    method fly() {
       print "hey, look at me, I am a flying pig!!"
    }
}