c#语言-------------类型转换2（里式转换）

一、里式转换（在C#中一切类都直接或间接继承与Object类）

1、子类可以赋值给父类:实质如果一个地方需要一个父类做为参数，我们可以给一个子类代替（一个方法中需要传进一个子类的对象，子类做实参，我们可以让父类作为形参接收子类的对象）

2、如果父类中装的是子类的对象，那么可以将这个父类转换为子类对象

  **子类对象可以调用父类中的成员，但是父类对象只能调用自己的成员

 

3、

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

    as：表示类型转换，如果能转换则返回对应的对象，否则返回一个null

里式转换法（子类可以赋值给父类）

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

namespace 里氏转换法1
{
    class Program
    {
        static void Main(string[] args)
        {
            //子类可以赋值给父类：实质如果一个地方需要一个父类做为参数，我们可以给一个子类代替（一个方法中需要传进一个子类的对象，子类做实参，我们可以让父类作为形参接收子类的对象）
            Student stu1 = new Student();
            Person per1 = stu1;//

            Person per2 = new Student();
            Person per3 = new Teacher();

            string str = string.Join("|", new string[] { "1", "2", "3", "4" });//这里也用到里氏转换法
            Console.WriteLine(str);
          


            //如果父类中装的是子类的对象，那么可以将这个父类的对象强转为子类对象
            Student st1 = (Student)per1;
            st1.StudentSayHello();
            Student st2 = (Student)per2;
            st2.StudentSayHello();
            Teacher tc3 = (Teacher)per3;
            tc3.TeacherSayHello();
            //Teacher tc4 = (Teacher)per1;//会抛出异常因为per1中装的是Student类的对象
            Console.ReadKey();
        }
    }
    public class Person
    {
        public void PersonSayHello()
        {
            Console.WriteLine("我是父类");
        }
    }
    public class Student:Person
    {
        public void StudentSayHello()
        {
            Console.WriteLine("我是学生类");
        }
    }
    public class Teacher : Person
    {
        public void TeacherSayHello()
        {
            Console.WriteLine("我是老师类");
        }
    }
}

运行结果：

里式转换法is的用法

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

namespace 里氏转换法2之is
{
    class Program
    {
        static void Main(string[] args)
        {

            //子类可以赋值给父类：实质如果一个地方需要一个父类做为参数，我们可以给一个子类代替（一个方法中需要传进一个子类的对象，子类做实参，我们可以让父类作为形参接收子类的对象）
            Student stu1 = new Student();
            Person per1 = stu1;//

            Person per2 = new Student();
            Person per3 = new Teacher();


            //如果父类中装的是子类的对象，那么可以将这个父类的对象强转为子类对象
            //is的用法
            //Student st1 = (Student)per1;
            //st1.StudentSayHello();
            if (per1 is Student)
            {
                Student st1 = (Student)per1;
                st1.StudentSayHello();
            }
            else 
            {
                Console.WriteLine("转换失败");
            }



            //Student st2 = (Student)per2;
            //st2.StudentSayHello();
            if (per2 is Student)
            {
                Student st2 = (Student)per2;
                st2.StudentSayHello();
            }
            else
            {
                Console.WriteLine("转换失败");
            }

            

            //Teacher tc3 = (Teacher)per3;
            //tc3.TeacherSayHello();
            if (per3 is Teacher)
            {
                Teacher tc3 = (Teacher)per3;
                tc3.TeacherSayHello();
            }
            else 
            {
                Console.WriteLine("转换失败");
            }


            //Teacher tc4 = (Teacher)per1;//会抛出异常因为per1中装的是Student类的对象
            if (per1 is Teacher)
            {
                Teacher tc4 = (Teacher)per1;
                tc4.TeacherSayHello();
            }
            else
            {
                Console.WriteLine("转换失败");
            }
            Console.ReadKey();
        }
    }
    public class Person
    {
        public void PersonSayHello()
        {
            Console.WriteLine("我是父类");
        }
    }
    public class Student : Person
    {
        public void StudentSayHello()
        {
            Console.WriteLine("我是学生类");
        }
    }
    public class Teacher : Person
    {
        public void TeacherSayHello()
        {
            Console.WriteLine("我是老师类");
        }
    }
}

运行结果：

里式转换法as的使用：

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

namespace 里氏转换法3之as
{
    class Program
    {
        static void Main(string[] args)
        {
            //子类可以赋值给父类：实质如果一个地方需要一个父类做为参数，我们可以给一个子类代替（一个方法中需要传进一个子类的对象，子类做实参，我们可以让父类作为形参接收子类的对象）
            Student stu1 = new Student();
            Person per1 = stu1;//

            Person per2 = new Student();
            Person per3 = new Teacher();
            //如果父类中装的是子类的对象，那么可以将这个父类的对象强转为子类对象
            //as的用法
            Student st1 = per1 as Student;
            st1.StudentSayHello();
            Student st2 = per2 as Student;
            st2.StudentSayHello();
            Teacher tc1 = per3 as Teacher;
            tc1.TeacherSayHello();
            Teacher tc2 = per1 as Teacher;//tc2中是null


            Console.WriteLine("======分割线======");
            Console.WriteLine(st1);
            Console.WriteLine(st2);
            Console.WriteLine(tc1);
            Console.WriteLine(tc2);
            Console.WriteLine("上面的tc2里面是空即什么也打印不出来");
            Console.WriteLine("下面的t也为空即在下面的两个分割线内什么也打印不出来");
            Console.WriteLine("======分割线======");
            Teacher t = null;
            Console.WriteLine(t);
            Console.WriteLine("======分割线======");
            Console.WriteLine("结束");
            Console.ReadKey();
        }
    }
    public class Person
    {
        public void PersonSayHello()
        {
            Console.WriteLine("我是父类");
        }
    }
    public class Student : Person
    {
        public void StudentSayHello()
        {
            Console.WriteLine("我是学生类");
        }
    }
    public class Teacher : Person
    {
        public void TeacherSayHello()
        {
            Console.WriteLine("我是老师类");
        }
    }
}

运行结果：

里氏转换法的练习：每次显示的结果都是随机的

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

namespace 里氏转换法4之练习
{
    class Program
    {
        static void Main(string[] args)
        {
            Person[] pers = new Person[10];//声明一个Person类型的数组来存Person类的对象（里氏转换法可知也可存Person的子类）
            Random r = new Random();
            for (int i = 0; i < pers.Length; i++)//作用：通过随机数给给我们的数组赋值
            {
                int rNum = r.Next(1, 8);
                switch (rNum)
                {
                    case 1:pers[i] = new Chinese();
                        break;
                    case 2: pers[i] = new Person();
                        break;
                    case 3: pers[i] = new English();
                        break;
                    case 4: pers[i] = new American();
                        break;
                    case 5: pers[i] = new Russian();
                        break;
                    case 6: pers[i] = new French();
                        break;
                    case 7: pers[i] = new German();
                        break;

                }
                
            }
            for (int i = 0; i < pers.Length; i++)
            {
                if (pers[i] is Chinese)
                {
                    ((Chinese)pers[i]).ChineseSay();
                }
                else if (pers[i] is English)
                {
                    ((English)pers[i]).EnglishSay();
                }
                else if (pers[i] is American)
                {
                    ((American)pers[i]).AmericanSay();
                }
                else if (pers[i] is French)
                {
                    ((French)pers[i]).FrenchSay();
                }
                else if (pers[i] is Russian)
                {
                    ((Russian)pers[i]).RussianSay();
                }
                else if (pers[i] is German)
                {
                    ((German)pers[i]).GermanSay();
                }
                else
                {
                    pers[i].PersonSay();
                }
            }
            Console.ReadKey();

        }
    }
    public class Person
    {
        public void PersonSay()
        {
            Console.WriteLine("我是人类");
        }

    }
    public class Chinese : Person
    {
        public void ChineseSay()
        {
            Console.WriteLine("我是中国人");
        }
    }
    public class English : Person
    {
        public void EnglishSay()
        {
            Console.WriteLine("我是英国人");
        }
    }
    public class American : Person
    {
        public void AmericanSay()
        {
            Console.WriteLine("我是美国人");
        }
    }
    public class Russian : Person
    {
        public void RussianSay()
        {
            Console.WriteLine("我是俄罗斯人");
        }
    }
    public class German : Person
    {
        public void GermanSay()
        {
            Console.WriteLine("我是德国人");
        }
    }
    public class French : Person
    {
        public void FrenchSay()
        {
            Console.WriteLine("我是法国人");
        }
    }
}

运行结果：