定义

why?

 public class Master
    {
        public void Feed(Dog dog)
        {
            dog.eat();
        }
        public void Feed(Cat cat)
        {
            cat.eat();
        }
        /*
        public void Feed(XXX xxx)    //XXX代表父类
        {
            xxx.eat();
        }
        */

    }

      假设有一个主人类。喂食不同的动物。不同动物对象调用方法的时候，对重复的代码频繁的修改。代码的可展拓展性，可维护性差。

所以我们可以用一个Animal类作为参数，让不同的动物继承这个动物类，这就是多态。

what?

        多态是同一个行为具有多个不同表现形式或形态的能力。就比如说是给上面的动物喂食。不同的动物喂不同的食物。

        多人做一件事，结果不一样。就比如说老鹰会飞。杜鹃会飞。喜鹊会飞。他们都会飞。但是他们飞行的能力是不同的。有的飞的高飞有的飞的低

         多态性：

                多态性可以是静态的或动态的。在静态多态性中，方法的响应是在编译时发生的。在动态多态性中，方法的响应是在运行时发生的。

           静态多态性：在编译时，方法和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：方法重载、运算符重载

                方法重载：在同一个类中。允许同名方法。他们的参数个数，或参数类型不同即可。

                运算符重载:就是定义一个函数。在函数体内实现想要的功能。当用到该运算符时，编译器会自动调用这个函数。也就是说，运算符重载是通过函数实现的，它本质上是函数重载。

               运算符重载_Simon的博客-CSDN博客

        动态多态性：是通过 抽象类 和 虚方法 实现的。

实现多态的两个要素（How）

1）子类重写父类方法

2）使用父类的类型（子类转换为父类：向上转型）

class Animal
{
 	public virtual void call() {
        Console.WriteLine("无声的叫唤"); 
      }
}
class Dog : Animal
 {
        // new的作用是隐藏父类的同名方法
        //public new void call() { 
            //Console.WriteLine("叫声：汪～汪～汪～"); 
      //}  	
        public override  void call() { 
            Console.WriteLine("叫声：汪～汪～汪～"); 
        }
        public void smell() { 
            Console.WriteLine("嗅觉相当不错！");
        }
 }

 class Program
    {
        static void Main(string[] args)
        {         
            Animal animal = new Dog(); //向上转型 
            animal.call();
        }
    }

/*输出： 叫声：汪～汪～汪～ */

 向上转型：将子类对象转为父类对象。此处父类对象可以是接口或抽象类。

转化后的父类对象具有父类所有方法，若方法被子类重写override，那么实际调用时，调用的是重写后的实现

通过多层继承链，理解"父类型引用永远调用的是继承链中最新版本的重写函数"

特别注意：使用new关键字后会破坏多态性！

int a=(int)3.5;
Dog dog = (Dog)animal;//向下转型
dog.call();                 
dog.smell(); 

 向下转型：把父类对象转为子类对象。

    转化后的子类对象，跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法，按重写的算。)

案例

        父类做参数

    class Animals
    {
        public virtual void Eat()
        {
            Console.WriteLine("吃");
        }
    }

     class Dog : Animals
    {
        public override void Eat()
        {
            Console.WriteLine("狗吃骨头");
        }
    }
    
    class Cat:Animals
    {
        public override void Eat()
        {
            Console.WriteLine("猫吃鱼");
        }
        
    }
    
    class Master
    {
        public void Feed(Animals a) //父类作为参数
        {
            a.Eat();
        }
    }

    
    class Program
    {
        static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog d = new Dog();
            Cat c = new Cat();
            
            a = b; //向上转型
            new Master().Feed(d);

        }
    }
       

输出：狗吃骨头

父类做返回值

 public Animals Feed(int i)  //父类作为参数
        {
            Animals a = null;    //默认赋空
            if (i==0)
            {
                a = new Dog();
            }
            else if (i == 1)
            {
                a = new Cat();
            }
            return a;
        } 


        static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog d = new Dog();
            Cat c = new Cat();
            
            a = d; //向上转型
            //new Master().Feed(d);

            a = new Master().Feed(1);
            a.Eat();    //调用方法
        }

输出：猫吃鱼

父类做参数优化

 public void Feed(Animals a) //父类作为参数
        {
            //a.Eat();    
            /*这样写不能直接判断传入的是猫还是狗？
            因此我们要对传进来的　a　进行判断。*/
                
            if (a is Dog)   //使用　ｉｓ　关键字
            {
                a.Eat();
            }
            if (a is Cat)
            {
                a.Eat();
            }
        }

static void Main(string[] args)
        {
            //匿名对象，调用一次方法
            Animals a = new Animals();
            Dog d = new Dog();
            Cat c = new Cat();
            
            a = d; //向上转型
            new Master().Feed(d);

            //a = new Master().Feed(1);
            //a.Eat();

输出：狗吃骨头

使用多态的好处

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 

2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用

1、C#中的访问修饰符
public:公开的公共的。
private:私有的，只能在当前类的内部访问。
protected:受保护的，只能在当前类的内部以及该类的子类中访问。
internal:只能在当前项目中访问。在同一个项目中，internal和public的权限是一样的。
protected internal:protected+internal
1)、能够修饰类的访问修饰符只有两个：public、internal。
2)、可访问性不一致
子类的访问权限不能高于父类的访问权限，会暴露父类的成员。
2、设计模式
设计这个项目的一种方式。
3、简单工厂设计模式。

using System;

namespace 简单工厂设计
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入您想要得笔记本品牌");
            string brand = Console.ReadLine();
            NoteBook nb = GetNoteBook(brand);
            nb.SayHello();
            Console.ReadKey();
        }

        public static NoteBook GetNoteBook(string brand)
        {
            NoteBook nb = null;
            switch(brand)
            {
                case "Lenovo":nb = new Lenovo();
                    break;
                case "IBM":nb = new IBM();
                    break;
                case "Acer":nb = new Acer();
                    break;
                case "Dell":nb = new Dell();
                    break;
            }
            return nb;
        }
    }

    public abstract class NoteBook
    {
        public abstract void SayHello();
    }

    public class Lenovo:NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是联想笔记本");
        }
    }

    public class Acer:NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是鸿基笔记本");
        }
    }
    public class Dell:NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是戴尔笔记本");
        }
    }

    public class IBM:NoteBook
    {
        public override void SayHello()
        {
            Console.WriteLine("我是IBM笔记本");
        }
    }
}

4、值类型在复制的时候，传递的是这个值得本身。
引用类型在复制的时候，传递的是对这个对象的引用。
5、系列化：就是将对象转化为二进制；
反系列化：就是将二进制转换为对象；
作用：传输数据。

一，定义

多态：

          1，多态是同一个行为具有多个不同表现形式或形态的能力。

           2，多人做一件事情，结果不一样

多态性可以是静态的或动态的。在静态多态性中，方法的响应是在编译时发生的。在动态多态性中，方法的响应是在运行时发生的。

静态多态性：在编译时，方法和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：方法重载、运算符重载

动态多态性是通过 抽象类 和 虚方法 实现的。

二，实现多态的两个要素

1）子类重写父类方法

2）使用父类的类型（子类转换为父类：向上转型）

public abstract class Shape

    {

        public abstract double GetArea();

        public abstract double GetPerimeter();

    }

    class Circle : Shape

    {

        private double r;

        public double R

        {

            get{return r;}          

            set{r = value;}

        }

        public Circle(double r)

        {

            this.r = r;

        }

        public override double GetArea()

        {

            return Math.PI * this.R * this.R;

        }

        public override double GetPerimeter()

        {

            return 2 * Math.PI * this.R;

        }

    }

三，实现多态的好处

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的

可复用性。//继承 
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护

性。 //多态的真正作用