C＃多态的实现

一、继承

        继承的特点： ①顺序不可逆性（仅能从上往下）        ②延续性（下一级具备上一级的特性）

        使用继承可以大幅减少重复代码（相同代码可以通过继承合并）

        1.如何使用继承

                抽象出公共部分，放到一个特定的类中（parent）

                其他类(childen)只需要继承父类，即可拥有父类的特征

                根据子类的需求可以添加属于自己的特征

class 子类 : 父类

         2.继承中的关键字

                使用继承需要继承符合is-a关系

                子类又称派生类，父类又称基类、超类

                ①Base关键字

                        用于调用父类的构造函数 / 属性 / 方法

                        用法及范例：

public Struct(p1,p2,p3) : base(p1,p2)    //调用构造
public Function1()
{
    base.Function();    //调用方法
}

class Animal
{
    publlic Animal(string name,string color)
    {
        this.Name = name;
        this.Color = color;
    }

    public void Introduce()
    {
        Console.writeLine("I am"+this.name+"and my color is"+this.color);
    }
}


class Dog:Animal
{
    public Dog(string name,string color,string favorite) : base(name,color)
    {
        this.Favorite = favorite;
    }    //调用父类构造

    public Race()
    {
        base.Inttroduce();    //调用父类方法
        Run();
    }
}

                ②权限访问关键字

修饰符	父类	子类	外部
public	*	*	*
protected	*	*	×
private	*	×	×

        3.继承的特性

                ①传递性        ②单根性（仅有一个父类）

        4.构造函数的调用

                1.隐式调用：会默认调用父类的无参构造函数，父类必须提供

                2.显示调用：若父类无无参构造函数，必须指明调用其哪个构造函数（base）

二、抽象

        子类可以向上转换为父类(但是转换后子类自己的方法将无法调用)

List<Animal> obj = new List<Animal>();

List.Add(aCat);
List.Add(aDog);

        1.abstract和override关键字

                在子类中需要使用override关键字对抽象方法进行重写

abstract class Animal
{
    public abstract void Have();    //不添加实现（抽象方法）
}

class Dog:Animal
{
    public Override void Have()
    {
        Consloe.WirteLine("吃东西啊");    //对父类进行重写
    }
}

                使用此方法后，父对象可以调用子类中重写的函数

foreach (Animal obj in list)
{
    obj.Have();    //直接调用
}

        2.抽象类的特点

                ①只要使用了abstract即为抽象类

                ②抽象类不能直接创建对象（不能new）

                ③抽象类可以由抽象方法，也可以没有任何抽象方法

                ④抽象类不能是静态(static)或密封(sealed)

                ⑤抽象方法不能再普通类中使用，只有声明不含任何实现

                ⑥子类中必须重写（实现）父类中的抽象函数（除非子类也是抽象类）

三、继承与多态

        1.多态与里氏替换原则

                多态是面向对象的三大特征之一，极大的提高了程序的可扩展性

                ①使用继承实现多态

                        Ⅰ父类必须采用抽象方法或虚方法

                        Ⅱ子对象必须重写父类的虚方法或抽象方法

                        Ⅲ子类对象必须转换为父类对象使用

                ②里氏替换原则（LSP）

                        Ⅰ子类对象可以替换为父类

                        Ⅱ父类对象不能替换为子类        （单向替换）

                        Ⅲ父类的方法都要在子类中实现 / 重写

                ③is和as检查符

                        is为类型兼容性检查，如果失败会造成程序中断

                        as用于兼容的引用 类型之间执行转换，失败会返回null

if(obj is cat)        //检查
        
Cat cat = obj as Cat;    //转换

        2.虚方法的使用

                虚方法可以重写，也可以直接调用（有函数实现）

                ①虚方法的实现

abstract class Animal
{
    public virtual void Have()    //虚方法
    {
        Console.WirteLine("喝啊");
    }
}

class Cat:Animal
{
    public override void Have()    //重写虚方法（也可以不重写）
    {
        base.Have();    //直接调用
        Console.WirteLine("为什么不喝");
    }
}

                        虚方法可以实现多态；即使子类没有重写虚方法时，也可直接调用父类的虚方法。

                ②系统自带虚方法

                        Equals(object obj);        //用于判断两个类型是否相等

objCat1.Equals(objCat2);

//重写Equals

public override bool Equals(objcet obj)
{
    Cat objCat = obj as Cat;
    if(objCat.Name == this.Name)
        return true;
    else
        reuturn false;
}

                        ToString();        //转换为字符串

//重写ToString();

public override string ToString()
{
    return string.Format("名字叫做"+this.Name);
}

                ③虚方法和抽象方法的对比

虚方法	抽象方法
virtual修饰	abstract修饰
要有方法体	不允许有方法体
可以被override	必须被类override
除了密封类均可	只能在抽象类中

三、密封类与方法覆盖

        1.关键字sealed

                当一个类使用sealed修饰后不能被继承（一定程度组织别人二次开发）

sealed class Novelist {}

        2.方法覆盖(关键字new)

                子类覆盖父类方法后，子类中该方法不能再次使用

public new void Introduce()    //实用new进行覆盖
{
    Console("F Q");
}

四、面相对象的三大特性