C#学习笔记14-里氏转换

里氏转换

里氏转换原则(Liskov Substitution Principle，LSP)面向对象设计的基本原则之一。 里氏转换原则中说，任何父类可以出现的地方，子类一定可以出现。

里氏转换，实质上就是类型的转换，在学C#过程中，我们一定经历过类型转换，如将int转换为double等，那么里氏转换，就是实现类中的类型转换，从而实现设计的封闭性。

里氏转换原则

1）子类可以赋值给父类
如果有一个地方需要用父类作为参数，我们可以用一个子类代替
如：C#学习笔记11-继承的基本概念中提到的父类Person，子类StudentInfo、TeacherInfo等，那么在创建对象过程中，可以用子类来代替

Person p=new StudentInfo();

2）如果父类中装的是子类，那么可以将这个父类强转为子类

 Person p2 = new Student()；
 Student s1 = (Student)p2;

子类对象可以调用父类的成员，但是父类对象不可以调用子类的成员

里氏转换中的is 和 as

is关键字

is表示类型转换，如果能够转换成功，返回一个true，否则返回false

            Student s = new Student();
            Person p = s;//子类可以赋值给父类
            if(p is Teacher)
            {
                Teacher s3 = (Teacher)p2;
            }
            else
            {
                Console.WriteLine("转换失败");
            }

as关键字

as表明类型转换，如果能够转换，则返回对应对象，否则返回null

  Person p2 = new Teacher();//子类赋值给父类
  Teacher s4 = p2 as Teacher;

里氏转换实例

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

namespace _02里氏转换练习
{
    class Program
    {
        static void Main(string[] args)
        {
            /*
             * 随机输出我是野兽、人类、学生、老师、帅锅、美女
             */
            Person[] p1 = new Person[10];//子类可以赋值给父类，所以可以都归为Person
            Random r = new Random();
            //为数组赋值
            for (int i = 0; i < p1.Length; i++)
            {
                int rNumber = r.Next(1, 7);
                switch (rNumber)
                {
                    case 1:
                        p1[i] = new Student();
                        break;
                    case 2:
                        p1[i] = new Teacher();
                        break;
                    case 3:
                        p1[i] = new ShuaiGuo();
                        break;
                    case 4:
                        p1[i] = new MeiLv();
                        break;
                    case 5:
                        p1[i] = new Animal();
                        break;
                    default:
                        p1[i] = new Person();
                        break;
                }
            }
            //父类不能调用子类的成员，所以需要进行强制转换
            for (int i = 0; i < p1.Length; i++)
            {
                if(p1[i] is Student)
                {
                    ((Student)p1[i]).StudentSayHello();
                }
                else if(p1[i] is Teacher)
                {
                    ((Teacher)p1[i]).TeacherSayHello();
                }
                else if(p1[i] is ShuaiGuo)
                {
                    ((ShuaiGuo)p1[i]).ShuaiGuoSayHello();
                }
                else if(p1[i] is MeiLv)
                {
                    ((MeiLv)p1[i]).MeiLvSayHello();
                }
                else if(p1[i] is Animal)
                {
                    ((Animal)p1[i]).AnimaSayHello();
                }
                else
                {
                    p1[i].SayHello();
                }
            }
            Console.ReadKey();
        }
        public class Person
        {
            int _age;

            public int Age { get => _age; set => _age = value; }

            public void SayHello()
            {
                Console.WriteLine("我是人类");
            }
        }
        public class Student : Person
        {
            public void StudentSayHello()
            {
                Console.WriteLine("我是学生");
            }
        }
        public class Teacher : Person
        {
            public void TeacherSayHello()
            {
                Console.WriteLine("我是老师");
            }
        }
        public class ShuaiGuo : Person
        {
            public void ShuaiGuoSayHello()
            {
                Console.WriteLine("我是帅锅");
            }
        }
        public class MeiLv : Person
        {
            public void MeiLvSayHello()
            {
                Console.WriteLine("我是美铝");
            }
        }
        public class Animal : Person
        {
            public void AnimaSayHello()
            {
                Console.WriteLine("我是野兽");
            }
        }
    }
}

注：后面的多态可以更加简单的实现该功能，敬请期待哦