c# 面相对象4-多态性

一、定义：

       多态是面向对象程序设计的又一个特性。在面向过程的程序设计中，主要工作是编写一个个的过程或函数，这些过程和函数不能重名。例如在一个应用中，需要对数值型数据进行排序，还需要对字符型数据进行排序，虽然使用的排序方法相同，但要定义两个不同的过程（过程的名称也不同）来实现。

　　在面向对象程序设计中，可以利用“重名”来提高程序的抽象度和简洁性。首先我们来理解实际的现象，例如，“启动”是所有交通工具都具有的操作，但是不同的具体交通工具，其“启动”操作的具体实现是不同的，如汽车的启动是“发动机点火——启动引擎”、“启动”轮船时要“起锚”、气球飞艇的“启动”是“充气——解缆”。如果不允许这些功能使用相同的名字，就必须分别定义“汽车启动”、“轮船启动”、“气球飞艇启动”多个方法。这样一来，用户在使用时需要记忆很多名字，继承的优势就荡然无存了。为了解决这个问题，在面向对象的程序设计中引入了多态的机制。

　　多态是指一个程序中同名的不同方法共存的情况。主要通过子类对父类方法的覆盖来实现多态。这样一来，不同类的对象可以响应同名的方法来完成特定的功能，但其具体的实现方法却可以不同。例如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同。

　　通过方法覆盖，子类可以重新实现父类的某些方法，使其具有自己的特征。例如对于车类的加速方法，其子类（如赛车）中可能增加了一些新的部件来改善提高加速性能，这时可以在赛车类中覆盖父类的加速方法。覆盖隐藏了父类的方法，使子类拥有自己的具体实现，更进一步表明了与父类相比，子类所具有的特殊性。

　　多态性使语言具有灵活、抽象、行为共享的优势，很好地解决了应用程序函数同名问题。

二、实现的方法

      多态需要通过继承来实现。

三、分类

1、编译多态（重载overload）
 eg、 函数重载

重载(overload):在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):

• 方法名必须相同
• 参数列表必须不相同
• 返回值类型可以不相同

 如： 

public void Sleep()
        {
            Console.WriteLine("Animal睡觉");
        }
        public int Sleep(int time)
        {
            Console.WriteLine("Animal{0}点睡觉", time);
            return time;
        }

2、运行多态（重写override）

子类中为满足自己的需要来重复定义某个方法的不同实现，需要用override关键字，被重写的方法必须是虚方法，用的是virtual关键字。它的特点是(三个相同):

• 相同的方法名
• 相同的参数列表
• 相同的返回值。

  如：父类中的定义： 
          public virtual void EatFood()
          {
              Console.WriteLine("Animal吃东西");
          } 
  
         子类中的定义：
  
          public override void EatFood()
          {
              Console.WriteLine("Cat吃东西");
              //base.EatFood();
          }

  实现方式：

  父类引用指向子类
  例子：

  namespace mydemo1
  {
      class Ren
      {
          public virtual void Speak()//
          {
          }
      }
  
      class Ghost
      {
          public void Eat(Ren e)
          {
              e.Speak();
              Console.WriteLine("人类真好吃！");
          }
      }
  
      class China : Ren
      {
          public override void Speak()
          {
              Console.WriteLine("汉语");
          }
      }
  
      class Usa : Ren
      {
          public override void Speak()
          {
              Console.WriteLine("English");
          }
      }
  
      class Program
      {
          public static void Main(string[] args)
          {
              Ren a = new China();//父类的引用指向子类的实例
              Ren b = new Usa();
  
              //a.Speak();
              //b.Speak();
  
              Ghost g = new Ghost();
              China c = new China();
              Usa u = new Usa();
  
              Random r = new Random();
              int a = r.Next(0, 3);
  
              if (a == 1)
              {
                  g.Eat(c);//改eat（）方法传入的参数要求是Ren类的引用，可以向里面传其子类及父类的元素，子类对象代替父类对象
              }
              else
              {
                  g.Eat(u);
              }
              
  
          }
      }
  }

  3、虚方法

  ：即为基类中定义的允许在派生类中重写的方法，使用virtual关键字定义。

  如：

  1  public virtual void EatFood()
  2         {
  3             Console.WriteLine("Animal吃东西");
  4         }

  注意虚方法也可以直接调用

   Animal a = new Animal();
              a.EatFood();

   运行结果：

•  4、抽象方法：在基类中定义的并且必须在派生类中重写的方法，使用abstract关键字定义。如：

  public abstract class Biology
      {
          public abstract void Live();
      }
      public class Animal : Biology
      {
          public override void Live()
          {
              Console.WriteLine("Animal重写的抽象方法");
              //throw new NotImplementedException();
          } 
      }

   注意：抽象方法只能在抽象类中定义，如果不在抽象类中定义，则会报出如下错误： 

5、里氏代换原则和抽象依赖原则

里氏代换原则
如果某个方法接收的是父类引用，可以向里面传父类或其子类的元素，子类对象替代父类对象
例子：怪兽吃人

class Guaishou
    {
        public void Eat(Ren r)
        {
            r.Jiao();
            Console.WriteLine("人类真好吃");
        }
    }

    class Ren
    {
        public virtual void Speak()
        {
            Console.WriteLine("说话");
        }

        public virtual void Jiao()
        {
            Console.WriteLine("55555555555555555");
        }

    }

    class American:Ren
    {
        public override void Speak()
        {
            Console.WriteLine("Hello");
        }

        public override void Jiao()
        {
            Console.WriteLine("SOS");
        }
    }

    class Chinese:Ren
    {
        public override void Speak()
        {
            Console.WriteLine("你好");
        }
        public override void Jiao()
        {
            Console.WriteLine("救命");
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            //Ren a = new Chinese();
            //a.Speak();
            //a = new American();
            //a.Speak();

            Guaishou g = new Guaishou();

            //Ren ren;

            Random r = new Random();
            int a = r.Next(0,3);

            if(a==1)
            {
                American ren= new American();
                g.Eat(ren);
            }
            else
            {
               Chinese  ren = new Chinese();
                g.Eat(ren);
            }


        }
    }
}

抽象依赖原则

用父类的引用来指向子类的实例
例子：运行多态的例子

6、隐藏方法：在派生类中定义的和基类中的某个方法同名的方法，使用new关键字定义。

如在基类Animal中有一方法Sleep():

   public void Sleep()
        {
            Console.WriteLine("Animal Sleep");
        }

     则在派生类Cat中定义隐藏方法的代码为：

new public void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }

  或者为：

  public new void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }    

注意：（1）隐藏方法不但可以隐藏基类中的虚方法，而且也可以隐藏基类中的非虚方法。

           （2）隐藏方法中父类的实例调用父类的方法，子类的实例调用子类的方法。

           （3）和上一条对比：重写方法中子类的变量调用子类重写的方法，父类的变量要看这个父类引用的是子类的实例还是本身的实例，如果引用的是父类的实例那么调用基类的方法，如果引用的是派生类的实例则调用派生类的方法。

 

7、例题

public abstract class Biology
    {
        public abstract void Live();
    }
    public class Animal : Biology
    {
        public override void Live()
        {
            Console.WriteLine("Animal重写的Live");
            //throw new NotImplementedException();
        }
        public void Sleep()
        {
            Console.WriteLine("Animal Sleep");
        }
        public int Sleep(int time)
        {
            Console.WriteLine("Animal在{0}点Sleep", time);
            return time;
        }
        public virtual void EatFood()
        {
            Console.WriteLine("Animal EatFood");
        }
    }
    public class Cat : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Cat EatFood");
            //base.EatFood();
        }
        new public void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }
        //public new void Sleep()
        //{
        //    Console.WriteLine("Cat Sleep");
        //}
    }
    public class Dog : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Dog EatFood");
            //base.EatFood();
        }
    }

需要执行的代码：

class Program
    {
        static void Main(string[] args)
        {
            //Animal的实例
            Animal a = new Animal();
            //Animal的实例，引用派生类Cat对象
            Animal ac = new Cat();
            //Animal的实例，引用派生类Dog对象
            Animal ad = new Dog();
            //Cat的实例
            Cat c = new Cat();
            //Dog的实例
            Dog d = new Dog();
            //重载
            a.Sleep();
            a.Sleep(23);
            //重写和虚方法
            a.EatFood();
            ac.EatFood();
            ad.EatFood();
            //抽象方法
            a.Live();
            //隐藏方法
            a.Sleep();
            ac.Sleep();
            c.Sleep();
            Console.ReadKey();
        }
    }