C#学习9

继承和覆写

多态表现形式：1. 将父类作为类型作为方法参数

class Person
    {
        public void SayHi()
        {
            Console.WriteLine("这是Person类的SayHi方法");
        }
        virtual public void test ()
        {
            Console.WriteLine("这是person类的test方法");
        }
    }

class Student:Person
    {
        new public void SayHi()
        {
            Console.WriteLine("这是Student类的SayHi方法");
        }
        public void SayHi11()
        {
            Console.WriteLine("这是Student类的SayHi11方法");
        }
        public override void test()
        {
            //base.test();
            Console.WriteLine("这是student类的test方法");
        }
    }

static void Main(string[] args)
        {
            Person p = new Person();
            Student s = new Student();
           // bool b = p is Person;// true
           // bool b = p is Student; // false
            Person p1 = new Student();
            bool b = p1 is Student; //true
            b = p1 is Person; // true
            p1.SayHi(); //调用Person 类的SayHi方法
            p1.test(); //调用student类，子类的test方法
            if (p1 is Student)
            {
                //先确定p1是student类，再写p1调用student的方法
                //因为p1是Student类，所以可以强制转换成Student类
               Student s1 = (Student)p1;
               s1.SayHi(); //调用Student 类的SayHi方法
               s1.SayHi11(); // 调用Student类的SayHi11 方法
            }

            //as 方法
           // Student s2 = (Student)p; //这种可能会报异常
            //这种不会报异常，如果转换没有成功，会将s3置为null
            Student s3 = p as Student;
            Console.WriteLine(b);
            Console.ReadKey();

        }

关于virtual 和override 修饰符：

1. 覆写和被覆写的方法必须有相同的可访问性，不能一个是private 一个是public。

2. 不能覆写static方法或非虚方法。

3. 当使用对象基类部分的引用调用一个覆写方法是，方法的调用沿派生层上溯执行，一直到标记为override的方法的最高派生版本；

多态

class Person
    {
        virtual public void SayMe()
        {
            Console.WriteLine("我是一个Person");
        }
    }

class Student:Person
    {
        public override void SayMe()
        {
            //base.SayMe();
            Console.WriteLine("我是一个Student");
        }
    }

class Teacher :Person
    {
        public override void SayMe()
        {
            //base.SayMe();
            Console.WriteLine("我是一个Teacher");
        }
    }

class Tell
    {
        public void Sayyou(Person p)
        {
            p.SayMe();
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            Person p2 = new Student();
            Person p3 = new Teacher();
            Tell t = new Tell();
            t.Sayyou(p2);
            t.Sayyou(p3);

            Console.ReadKey();
}

多态表现形式：2. 将父类作为类型作为返回值

static void Main(string[] args)
        {
            Tell t2 = new Tell();
            string str1 = "student";
            Person p4 = t2.Say(str1);
            p4.SayMe();
            Console.ReadKey();
        }

class Tell
    {
        public Person Say(string type)
        {
            switch (type)
            {
                case "student": return new Student();
                case "teacher": return new Teacher();
                default : return null;
            }
        }
    }

输出 “ 我是一个Teacher”