初识继承和多态

1.继承:一个类可以使用另一个类的方法和属性(成员)
2.子类继承父类使用的符号是冒号
3.子类不能继承父类的构造函数
4.调用子类构造的时候，没有使用base关键字调用父类的指定的构造，默认调用父类的无参构造

5.base关键字
       base.父类的属性
       base.父类的方法
       base.父类的成员
       base(): 父类的构造

父类：

public class Person
    {  
      public Person(string name,int age)
      {
            this.Name = name;
            this.Age = age;
      } 
    }

子类：

public class Student:Person
  {
      public Student(string name, int age, Gender sex):base(name,age)
      {
        //this.Name = name;
            //base.Age=age;
                this.Sex = sex;
      }

  }
 

--总结：base(参数1,参数2)  顺序是根据父类构造的参数顺序保持一致
  但是变量名是和子类构造的参数变量名保持一致的

  6.继承的两大特性：
  单根性：一个类只能有一个直接父类
  传递性：A是B的父亲B是C的父亲  (A是爷爷  C是孙子)  C也可以继承A

  7.访问修饰符
  public：      任何位置都可以使用
  protected     当前类和子类
  private       当前类

    new子类底层原理
      1.走到子类构造，不进入构造体
      2.转向父类，进入父类构造体执行
      3.转回子类构造，执行子类构造体
      4.转到main方法，内存中构建出子类对象

  多态初步：
  多态：不同的对象对于同一种操作，做出的响应不同

父类Animal类：

public class Animal
    {
       public virtual void sayHello()
       {
           Console.WriteLine("父类打招呼的方法");
       }
    }

子类Dog类：

public class Dog:Animal
    {
        public override void sayHello()
        {
            Console.WriteLine("汪汪");
        }
    }

子类Cat类：

public class Cat:Animal
    {
        public override void sayHello()
        {
            Console.WriteLine("喵喵");
        }
    }

main方法：

public class Program
    {
        static void Main(string[] args)
        {
            List<Animal> list=new List<Animal>();
            Dog dog=new Dog();
            Cat cat=new Cat();
            list.Add(dog);
            list.Add(cat);
            foreach (Animal animal in list)
            {
                //方式一
                //animal.sayHello();

                //方式二  不使用统一调用
                if (animal is Dog)
                {
                    Dog dg = animal as Dog;
                    dg.sayHello();
                }
                if (animal is Cat)
                {
                    Cat ct = animal as Cat;
                    ct.sayHello();
                }
            }
        }
    }

总结：
1.实现方法重写
2.父类中定义SayHello（）方法，用virtual关键字定义为虚方法。
3.在子类中定义子类自己的sayHello（）方法，用override关键字修饰，就实现了对父类sayHello（）方法的重写