初识继承和多态

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

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

父类：

1 public class Person
2     {  
3       public Person(string name,int age)
4       {
5             this.Name = name;
6             this.Age = age;
7       } 
8     }

子类：

 1 public class Student:Person
 2   {
 3       public Student(string name, int age, Gender sex):base(name,age)
 4       {
 5         //this.Name = name;
 6             //base.Age=age;
 7                 this.Sex = sex;
 8       }
 9 
10   }
11

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

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

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

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

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

父类Animal类：

1 public class Animal
2     {
3        public virtual void sayHello()
4        {
5            Console.WriteLine("父类打招呼的方法");
6        }
7     }
8

子类Dog类：

1 public class Dog:Animal
2     {
3         public override void sayHello()
4         {
5             Console.WriteLine("汪汪");
6         }
7     }

子类Cat类：

1 public class Cat:Animal
2     {
3         public override void sayHello()
4         {
5             Console.WriteLine("喵喵");
6         }
7     }

main方法：

 1 public class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             List<Animal> list=new List<Animal>();
 6             Dog dog=new Dog();
 7             Cat cat=new Cat();
 8             list.Add(dog);
 9             list.Add(cat);
10             foreach (Animal animal in list)
11             {
12                 //方式一
13                 //animal.sayHello();
14 
15                 //方式二  不使用统一调用
16                 if (animal is Dog)
17                 {
18                     Dog dg = animal as Dog;
19                     dg.sayHello();
20                 }
21                 if (animal is Cat)
22                 {
23                     Cat ct = animal as Cat;
24                     ct.sayHello();
25                 }
26             }
27         }
28     }

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