C#中基础语法学习-继承和多态

1.继承：

创建父类，父类包含常用的方法，如下：我们创建一个动物类，里面包含两个属性，ID和Name：

public class Animal
{  
    public int ID { get; set; }
    public string Name { get; set; }    


}

创建子类Pig类，继承Animal类，例如：

public class pig : Animal
{
    public void sleep()
   { 
    
    }

}

在主函数中我们可以实例化子类，并调用父类的属性：

 main()
{
  pig pig = new pig();
  pig.Name = "猪三";
  pig.ID = 1;
  Console.WriteLine($"猪的名字：{pig.Name}  猪的ID: {pig.ID}"   );
}

 打印结果：

猪的名字：猪三  猪的ID: 1

 2.父类和子类转换关系

在实际应用中，我们通过父类实例化子类对象；

Animal a=new pig();
a.Name = "A";
a.ID = 2;
Console.WriteLine($"猪的名字：{a.Name}  猪的ID: {a.ID}");

打印结果：

猪的名字：A  猪的ID: 2

 如果我们在子类pig中创建一个方法，则通过Animal类实例化对象，无法调用：

a.sleep(); //程序报错，无法执行，父类无法调用子类的拓展方法

 解决方案，里氏替换原则，任何父类出现的地方，子类都可以替换，父类负责声明，子类负责构造：

Animal b=new pig(); //向上引用
pig c = (pig)b;    //向下转换
// pig c = b as pig; //可替换上句
c.Name = "猪四";
c.ID = 2;   
c.sleep();

3.多态

父类定义一个方法，子类由不同的表现形式，例如，动物吃东西，老虎吃肉，猪吃草，则需要对父类的方法进行重写，方法重写，需要父类中用虚方法

 public class Animal  //父类
 {  
     public int ID { get; set; }
     public string Name { get; set; }

     public virtual void Eat()
     {
         Console.WriteLine( "动物需要吃东西" );
     }
 }
 public class pig : Animal    //子类
 {
     public void sleep() 
     {
         Console.WriteLine("猪在睡觉：哼哼哼"  );
     }
     public override void Eat()
     {
         base.Eat();
         Console.WriteLine( "猪吃草" );
     }
 }

在main函数中调用：

 Animal b=new pig(); //向上引用
 pig c = b as pig;    //向下转换
 c.Name = "猪四";
 c.ID = 2;   
 c.Eat();

执行结果：

动物需要吃东西
猪吃草

则可以看到对父类方法重写，Eat函数可以执行私有特性

4.抽象类：

拥有抽象方法的类为抽象类，抽象方法：只需要在父类中定义，不需要实现的方法，用关键字abstract，抽象方法在子类中定义，抽象方法的相比较方法重载的好处，父类中定义的抽象方法，子类必须定义实现方式：

public  abstract  class Animal  //父类定义为抽线类
{  
    public int ID { get; set; }
    public string Name { get; set; }

    public virtual void Eat()
    {
        Console.WriteLine( "动物需要吃东西" );
    }
    public abstract void Run();  //定义抽象方法，不需要实现，只定义即可
}


public class Pig : Animal
{
    public void sleep() 
    {
        Console.WriteLine("猪在睡觉：哼哼哼"  );
    }
    public override void Eat()
    {
        base.Eat();
        Console.WriteLine( "猪吃草" );
    }
    public override void Run() //必须重写抽象方法
    { 

    }
}

执行程序：

            Animal b=new Pig(); //向上引用
            Pig c = b as Pig;    //向下转换
            c.Name = "猪四";
            c.ID = 2;   
            c.Eat();
            c.Run();

执行结果：

动物需要吃东西
猪吃草
猪四条腿跑

总结：子类可继承父类的资源，多态编程可以优化代码数量并添加子类个性，抽象类和抽象方法必须在子类中重写，否者无法执行。当子类必须重写一个方法，则创建父类抽象.