C#基础强化-继承与多态

/**
  特性：
    单根性：一个子类只能有一个父类
    传递性：爷爷类 爹类 儿子类
  里氏转换
    1、子类可以赋值给父类
    2、如果父类装的是子类对象，则可以将这个父类转换为对应的子类 is as 关键字
    -->关键字
      1、is：返回bool类型，指示是否是这个类型
      2、as：如果转换成功返回对象，否则返回null
    作用：我们可以将所有的子类当做是父类来看，针对父类进行编程，写出通用代
    码，适应需求的不断改变
  多态：
    -->虚方法
      virtual override
    -->抽象类
      abstract override
    -->接口
      interface

*/

普通类的继承

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

/**
  继承中的非多态方式，很恶心人吧
  虚方法和抽象方法就是为了解决这个问题的
*/
namespace 普通类的继承 {
    class Program {
        static void Main(string[] args) {
            passen[] pas = { new Liuguan(), new Wangming() };
            foreach(passen item in pas) {
                if(item is Liuguan) {
                    (item as Liuguan).Function();
                }
                if(item is Wangming) {
                    (item as Wangming).Function();
                }
                //item.Function();该方式，打印出来都是"我是人"
            }
            Console.ReadLine();
        }
    }
    class passen {
        public void Function() {
            Console.WriteLine("我是人");
        }
    }
    class Liuguan : passen {
        public new void Function() {
            Console.WriteLine("我是刘冠");
        }
    }
    class Wangming : passen {
        public new void Function() {
            Console.WriteLine("我是王明");
        }
    }
}

抽象类的继承

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 抽象类的继承 {
    class Program {
        static void Main(string[] args) {
            //多态，父类可指向子类对象
            //子类可以赋值给父类，但调不出子类新增方法，反之不可
            animal[] ani = { new Cat(), new Dog(), new Pig() };
            foreach(animal item in ani) {
                item.Bark();               
                if(item is Cat) {//判断类型
                    Cat tempItem = (Cat)item;                    
                    tempItem.TextFunction();
                    //两个等价
                    Cat tempItem2 = item as Cat;
                    tempItem2.TextFunction();
                }
            }

            Console.ReadLine();
        }
    }
    //抽象类，抽象方法
    abstract class animal {
        public abstract void Bark();//抽象方法包含于抽象类中类，应用场景：父类没有办法如何确定子类如何去实现

    }
    //一个子类继承了一个抽象类，那么这个子类必须重写这个抽象父类中的所有成员
    class Cat : animal {
        public override void Bark() {//子类重写父类方法
            Console.WriteLine("cat");
        }
        public void TextFunction() {
            Console.WriteLine("测试方法");
        }
    }
    class Dog : animal {
        public override void Bark() {//子类重写父类方法
            Console.WriteLine("dog");
        }
        public void TextFunction() {
            Console.WriteLine("测试方法");
        }
    }
    class Pig : animal {
        public override void Bark() {//子类重写父类方法
            Console.WriteLine("pig");
        }
        public void TextFunction() {
            Console.WriteLine("测试方法");
        }
    }
}

虚方法类的继承

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 虚方法类的继承 {
    class Program {
        static void Main(string[] args) {
            person[] per = { new Liuguan(), new Wangming() };
            foreach(person item in per) {
                item.Function();
            }
            Console.ReadLine();
        }
    }
    class person {
        public virtual void Function() {//虚方法
            Console.WriteLine("我是人");
        }
    }
    class Liuguan : person {
        public override void Function() {
            //  base.Function();
            Console.WriteLine("我是刘冠");
        }
    }
    class Wangming : person {
        public override void Function() {
            //  base.Function();
            Console.WriteLine("我是王明");
        }
    }
    
}