C# 多态如何理解父类引用指向子类对象里式转换原则

最新推荐文章于 2023-02-19 15:05:30 发布

西瓜的夏天啊

最新推荐文章于 2023-02-19 15:05:30 发布

阅读量761

点赞数

文章标签： C# 多态

本文链接：https://blog.csdn.net/qq_32175379/article/details/117970134

版权

C# 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

**using System;

namespace Lesson13_继承_里氏替换原则
{
    #region 知识点一 基本概念
    // 里氏替换原则是面向对象七大原则中最重要的原则
    // 概念：
    // 任何父类出现的地方，子类都可以替代
    // 重点：
    // 语法表现——父类容器装子类对象,因为子类对象包含了父类的所有内容
    // 作用：
    // 方便进行对象存储和管理
    #endregion

    #region 知识点二 基本实现
    class GameObject
    {

    }

    class Player:GameObject
    {
        public void PlayerAtk()
        {
            Console.WriteLine("玩家攻击");
        }
    }

    class Monster:GameObject
    {
        public void MonsterAtk()
        {
            Console.WriteLine("怪物攻击");
        }
    }

    class Boss:GameObject
    {
        public void BossAtk()
        {
            Console.WriteLine("Boss攻击");
        }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("里氏替换原则");

            //里氏替换原则 用父类容器 装载子类对象
            GameObject player = new Player();
            GameObject monster = new Monster();
            GameObject boss = new Boss();

            GameObject[] objects = new GameObject[] { new Player(), new Monster(), new Boss() };

            #region 知识点三 is和as
            //基本概念 
            // is：判断一个对象是否是指定类对象
            // 返回值：bool  是为真 不是为假

            // as：将一个对象转换为指定类对象
            // 返回值：指定类型对象
            // 成功返回指定类型对象，失败返回null

            //基本语法
            // 类对象 is 类名   该语句块 会有一个bool返回值 true和false
            // 类对象 as 类名   该语句块 会有一个对象返回值 对象和null

            if( player is Player )//这里是判断类型
            {
                Player p = player as Player;//这里进行转化类型，
                //只有转化类型后才能掉子类的方法，虽然父类对象中存放的是子类
                p.PlayerAtk();
                //(player as Player).PlayerAtk();
            }

            for (int i = 0; i < objects.Length; i++)
            {
                if( objects[i] is Player )
                {
                    (objects[i] as Player).PlayerAtk();
                }
                else if( objects[i] is Monster )
                {
                    (objects[i] as Monster).MonsterAtk();
                }
                else if (objects[i] is Boss)
                {
                    (objects[i] as Boss).BossAtk();
                }
            }

            #endregion
        }
    }
    //总结
    //概念：父类容器装子类对象
    //作用：方便进行对象的存储和管理
    //使用：is和as
    // is 用于判断
    // as 用于转换
    // 注意：不能用子类容器装父类对象
}

从对象的内存角度来理解试试.

假设现在有一个父类Father,它里面的变量需要占用1M内存.有一个它的子类Son,它里面的变量需要占用0 .5M内存.

现在通过代码来看看内存的分配情况:

Father f = new Father();//系统将分配1M内存.

Son s = new Son();//系统将分配1.5M内存!因为子类中有一个隐藏的引用super会指向父类实例,
所以在实例化子类之前会先实例化一个父类,也就是说会先执行父类的构造函数.
由于s中包含了父类的实例,所以s可以调用父类的方法.

Son s1 = s;//s1指向那1.5M的内存.

Father f1 = (Father)s; 相当于Father f1 = new Son(); 为向上类型转换，
可省略，因为子类就是父类，如猫就是动物

//这时f1会指向那1.5M内存中的1M内存,即是说,f1只是指向了s中实例的父类实例对象,
所以f1只能调用父类的方法(存储在1M内存中),而不能调用子类的方法(存储在0.5M内存中).