学习Unity: 理解C#多态

最新推荐文章于 2023-03-26 08:29:10 发布
最新推荐文章于 2023-03-26 08:29:10 发布
阅读量475 收藏 6
点赞数 2
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42538567/article/details/103500564
版权

多态的概念:多态的实现是建立在继承的基础上实现的,当父类引用指向子类对象时,同一操作,可以产生不同的行为

一.关键字解释,虚方法,抽象方法,重写,重载,覆盖,base,this

1.虚方法(virtual):当一个方法(属性)使用关键字virtual修饰的时候,这个时候就说明此方法(属性)为虚方法(属性),子类可以重写此方法(属性),从而实现多态,虚方法是可以定义方法体的,可就是说这个函数是有作用的,可以实现具体功能的

    public virtual void DoSomething()
    {
        Debug.Log("写作业");
    }

2.抽象方法(abstract):首先关键字abstract可以修饰类,函数,属性,当类中的属性或者函数使用abstract修饰的时候,则该类必须为abstract修饰的抽象类抽象类是不能被实例化的,只能用来被继承,所以不能使用关键字sealed(密封类)来修饰,当一个函数(属性)被abstract修饰后,那么这个函数(属性)就是抽象函数(属性),那么继承此抽象类的子类必须重写此方法,从而实现多态,抽象函数(属性)是不能有函数体的

public  abstract class Stud
{
    public abstract string Name { get; set; }
    public abstract void DoSomething();
}

3.重写(override)是在子类中重写父类中使用virtual或者abstract修饰的方法(属性)。用于扩展或修改继承的方法(属性)实现。提供从基类继承的成员的新实现,从而实现多态

public  abstract class Person
{
    public abstract void DoSomething();
}
public class Stud : Person
{
    public override void DoSomething()
    {
        Debug.Log("实现");
    }
}

 4.重载(overload):当然overload并不是重载的关键字,重载并没有关键字,重载与重写一字之差,但是两者一点关系都木有~重载就是一个类中有N个重名函数,但是他们的参数类型或者个数不相同,当然顺序不相同也是可以的,调用的时候,会自动根据你填写的参数类型,个数来调用匹配的重载(注意:和返回值木有任何关系)

public class OverLoad
{
    public void Test(int a) { }

    public void Test(string a) { }

    public void Test(string a, int b) { }

    public void Test(int b, string a) { }
}

覆盖(new):说简单点来说当子类拥有了和父类重名的函数时,又没有使用override重写,这个时候就会出现问题,隐藏了父类某某某方法,建议使用new关键字,这个时候当你使用了new关键字了之后,这两个同名函数就一点关系都没有了,相当于同名的两个不同的函数

public class Test : MonoBehaviour
{
    private void Start()
    {
        Stud stud = new Stud();
        stud.Test();
        //输出Stud

        Person person1 = new Person();
        person1.Test();
        //输出Person

        Person person2 = new Stud();
        person2.Test();
        //输出Person
    }
}

public class Person
{
    public void Test() { Debug.Log("Person"); }
}
public class Stud : Person
{
    public new void Test() { Debug.Log("Stud"); }
}

 

base:指的是该子类继承的父类

this:自己类本身

二.多态的实现方式

1.利用关键字virtual与override实现多态

// 父类
public class Person
{
    //名字
    public string m_name;

    //年龄
    public int m_age;

    //昵称
    public string m_nickname;

    public Person(string name, int age, string nickname)
    {
        m_name = name;
        m_age = age;
        m_nickname = nickname;
    }

    //用virtual修饰属性,已达到子类可以重写属性目的
    public virtual string Name
    {
        get
        {
            return m_name;
        }
        set
        {
            m_name = value;
        }
    }

    //虚方法用于子类重写以达到实现多态的目的
    public virtual void Work()
    {
        Debug.Log("人们正在努力工作");
    }
}

//子类
public class Student : Person
{
    //继承父类构造
    public Student(string name, int age, string nickname) : base(name, age, nickname) { }
    //学生因为比较可爱,所以名字应该是他的昵称,所以我们应该重写Name属性
    public override string Name
    {
        get
        {
            return m_nickname;
        }
        set
        {
            m_nickname = value;
        }
    }

    //学生每天的作业可能就是学习了
    public override void Work()
    {
        Debug.Log(Name + "正在学习知识");
    }
}

//子类
public class Teacher : Person
{
    //继承父类构造
    public Teacher(string name, int age, string nickname) : base(name, age, nickname) { }
    //老师比较严肃,工作的时候就不能就昵称了,因为virtual是可以有实现的,父类的实现刚好是显示m_name所以这里可以不用再重写了
    public override void Work()
    {
        Debug.Log(Name + "正在备课");
    }
}

实现多态 

public class VirtualOverride : MonoBehaviour
{
    void Start()
    {
        //父类引用指向子类对象
        Person stud = new Student("王晓明同学", 10, "明明");
        Person teacher = new Teacher("李铁柱老师", 30, "老李");
        //调用一个函数,会产生不同的实现(同一操作,可以产生不同的行为)
        LookWorkState(stud);
        LookWorkState(teacher);
    }

    //查看Person的工作状态
    private void LookWorkState(Person person)
    {
        person.Work();
    }
}

输出

2.利用关键字abstract与override实现多态

// 父类
public abstract class Person
{
    //名字
    public string m_name;

    //年龄
    public int m_age;

    //昵称
    public string m_nickname;

    public Person(string name, int age, string nickname)
    {
        m_name = name;
        m_age = age;
        m_nickname = nickname;
    }

    //用abstract修饰属性,已达到子类可以重写属性目的,这里是不能添加方法体实现的
    public abstract string Name { get; set; }

    //abstract用于子类重写以达到实现多态的目的,这里也是不能添加实现的
    public abstract void Work();
}

//子类
public class Student : Person
{
    //继承父类构造
    public Student(string name, int age, string nickname) : base(name, age, nickname) { }
    //学生因为比较可爱,所以名字应该是他的昵称
    public override string Name
    {
        get
        {
            return m_nickname;
        }
        set
        {
            m_nickname = value;
        }
    }

    //学生每天的作业可能就是学习了
    public override void Work()
    {
        Debug.Log(Name + "正在学习知识");
    }
}

//子类
public class Teacher : Person
{
    //继承父类构造
    public Teacher(string name, int age, string nickname) : base(name, age, nickname) { }

    //老师比较严肃,工作的时候就不能就昵称了,因为父类是抽象类,所以子类要全部实现父类中的抽象属性与方法
    public override string Name
    {
        get
        {
            return m_name;
        }
        set
        {
            m_name = value;
        }
    }


    public override void Work()
    {
        Debug.Log(Name + "正在备课");
    }
}

这里的实现代码与输出都和使用关键字virtual与overload的是一样的

3.利用接口实现多态

//接口
interface IPerson
{
    string Name { get; set; }
    void Work();
}

public class Student : IPerson
{
    //名字
    public string m_name;
    //年龄
    public int m_age;
    //昵称
    public string m_nickname;

    //构造函数
    public Student(string name, int age, string nickname)
    {
        m_name = name;
        m_age = age;
        m_nickname = nickname;
    }

    //实现接口,学生可爱,所以大家都用昵称称呼他
    public string Name
    {
        get
        {
            return m_nickname;
        }
        set
        {
            m_nickname = value;
        }
    }


    public void Work()
    {
        Debug.Log(Name + "正在学习知识");
    }
}
public class Teacher : IPerson
{
    //名字
    public string m_name;
    //年龄
    public int m_age;
    //昵称
    public string m_nickname;

    //构造函数
    public Teacher(string name, int age, string nickname)
    {
        m_name = name;
        m_age = age;
        m_nickname = nickname;
    }
    //实现接口,老师比较严肃,工作的时候就不能就昵称了
    public string Name
    {
        get
        {
            return m_name;
        }
        set
        {
            m_name = value;
        }
    }
    public void Work()
    {
        Debug.Log(Name + "正在备课");
    }
}

当然接口实现多态也可以新建父类,让父类实现接口,并对接口的Name与Work,使用关键字virtual或者abstract修饰,然后子类进行重写的,具体要看大家怎么使用了 

 

//接口
interface IPerson
{
    string Name { get; set; }
    void Work();
}
//父类
public class Person : IPerson
{
    //名字
    public string m_name;
    //年龄
    public int m_age;
    //昵称
    public string m_nickname;

    //构造函数
    public Person(string name, int age, string nickname)
    {
        m_name = name;
        m_age = age;
        m_nickname = nickname;
    }

    public virtual string Name
    {
        get
        {
            return m_name;
        }
        set
        {
            m_name = value;
        }
    }
    public virtual void Work()
    {
        Debug.Log(Name + "正在备课");
    }
}
//子类
public class Student : Person
{
    //继承父类构造函数
    public Student(string name, int age, string nickname) : base(name, age, nickname) { }

    //实现接口,学生可爱,所以大家都用昵称称呼他
    public override string Name
    {
        get
        {
            return m_nickname;
        }
        set
        {
            m_nickname = value;
        }
    }


    public override void Work()
    {
        Debug.Log(Name + "正在学习知识");
    }
}
//子类
public class Teacher : Person
{
    //继承父类构造函数
    public Teacher(string name, int age, string nickname) : base(name, age, nickname) { }
    //实现接口,老师比较严肃,工作的时候就不能就昵称了
    public override string Name
    {
        get
        {
            return m_name;
        }
        set
        {
            m_name = value;
        }
    }
    public override void Work()
    {
        Debug.Log(Name + "正在备课");
    }
}

实现多态

public class Interface : MonoBehaviour
{

    void Start()
    {
        //父类引用指向子类对象
        IPerson stud = new Student("王晓明同学", 10, "明明");
        IPerson teacher = new Teacher("李铁柱老师", 30, "老李");
        //调用一个函数,会产生不同的实现(同一操作,可以产生不同的行为)
        LookWorkState(stud);
        LookWorkState(teacher);
    }

    //查看Person的工作状态
    private void LookWorkState(IPerson person)
    {
        person.Work();
    }
}

输出

 

可以看出以上三种方法输出都是一样的,大家根据自己的需求可以选择较优的方式实现~

好了,文章到此就结束了,本文有什么错误的观点或者用法,希望各位看官能够及时提出,希望在自己积累知识的同时,能帮助到大家~

 

 

 

朝夕.
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Unity之多态
u010718707的专栏
12-16 2086
1.方法隐藏： 如果子类方法的方法名和基类的方法名相同时，系统将隐藏基类同名方法，自动调用子类的同名方法 2.virtual:用在父类中，表示方法可以重写 override：用在子类中，重写父类的方法 例子： class Father{ public virtual void Print{ Console.WriteLine("父类的Print()"); } } c
在UNITY中理解类的多态用简单例子来理解，记得断点调试运行下！
11-30 209
using UnityEngine; public class Polymorphism : MonoBehaviour { // Start is called before the first frame update void Start() { // 请注意，这里的变量“myFruit”的类型是 //Fruit，但是被分配了对 Apple 的引用。这是 //由于多态而起作用的。由于 Apple 是 Fruit， .
C# 多态性
weixin_34319640的博客
03-13 166
多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。 多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。 静态多态性 在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为： 函数重载 运算符重载 运算符重载将在...
[Unity] C#中级编程 - 07 - 多态
Lovely_him的博客
12-15 534
[Unity中文课堂教程] C#中级编程 - 07 - 多态 原教程视频地址： 《[Unity中文课堂教程预告片] C#中级编程_哔哩哔哩_bilibili》 《C#中级编程 - Unity中文课堂 (u3d.cn)》 《C# 多态性 | 菜鸟教程 (runoob.com)》，菜鸟教程中提到多态，但指的是方法重载和覆写操作。和视频教程里指的不是一个东西。 内容短小精悍简练，每节只有几分钟。很适合用来预习和复习。 多态 多态是继承的一个特征，允许类拥有多个类型。在继承层次结构中，任何子类都可以称为父类，
Unity基础之C#核心篇笔记4：多态
qq_42481369的博客
05-26 1300
Unity基础之C#核心篇笔记4：多态多态1.多态的概念2.解决的问题3.多态的实现4.总结抽象类和抽象方法1.抽象类 多态 1.多态的概念 // 多态按字面的意思就是“多种状态” // 让继承同一父类的子类们 在执行相同方法时有不同的表现（状态） // 主要目的 // 同一父类的对象 执行相同行为（方法）有不同的表现 // 解决的问题 // 让同一个对象有唯一行为的特征 2.解决的问题 //让同一个对象有唯一行为的特征 class Father {
Unity-Projects:学习C＃和Unity
04-19
这个“Unity-Projects”压缩包很可能是为了帮助初学者或有经验的开发者深入理解C#编程语言以及如何在Unity环境中应用它。下面，我们将详细探讨C#在Unity中的应用以及如何通过项目学习来提升技能。 C#是一种面向对象...
学习敏锐：学习C＃
02-21
"学习敏锐：学习C#"这一主题，暗示我们将深入探讨C#语言的基础知识，以及如何有效地学习和掌握这一强大的工具。 C#语言的设计理念是简洁、类型安全和性能高效。它采用了类C语言的语法结构，同时吸收了Java和.NET...
Unity学习之C#入门.zip
04-25
本资源"Unity学习之C#入门.zip"包含了一份全面的C#学习材料，旨在帮助初学者快速入门。 首先，"21天学通C#"分为上下两部分，通常这类教程会以日为单位，每天讲解一个或多个关键概念，逐步深入。在21天的学习过程中...
Unity5实战：使用C#和Unity开发多平台游戏中文带目录
12-06
书中将详细介绍如何利用C#编写Unity脚本，包括变量、函数、类、对象实例化、继承、多态等基础知识，以及更高级的特性如异步操作和委托。 Unity引擎的核心功能包括场景管理、物理系统、动画系统、光照和渲染、资源...
Unity:拥有所有所需资产的General Unity Playground
05-02
从基础的变量定义、函数调用，到面向对象的类、继承、多态，乃至更高级的委托和异步操作，C#为Unity提供了强大而灵活的编程能力。例如，我们可以创建一个C#脚本来控制角色的移动，通过Update()方法实现每帧更新，...
Unity 3D游戏开发 - C#面向对象 | 多态之虚方法语法
weixin_41232641的博客
09-15 490
多态简介 多态 在继承关系的前提下，实例化出不同的对象，这些对象调用相同的方法，却表现出不同的行为，即为多态。 C#语言中体现多态有三种方式：虚方法，抽象类，接口。 虚方法语法 虚方法 在父类中使用 virtual 关键字修饰的方法，就是虚方法。 在子类中可以使用 override 关键字对该虚方法进行重写。 虚方法语法 父类： public virtual 返回...
unity的C#学习——静态多态性（函数重载、运算符重载）与动态多态性（抽象类、虚方法）
最新发布
时生的博客
03-26 1748
多态是同一个行为具有多个不同表现形式或形态的能力。多态性意味着有多重形式，在面向对象编程范式中，多态性往往表现为“一个接口，多个功能”。 多态性可以是静态的或动态的：在静态多态性中，函数的响应是在编译时发生的，主要借由重载(overload)实现。在动态多态性中，函数的响应是在运行时发生的，主要借由重写(override)实现。 在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自Object。多态就是同一个接口，使用不同的实例而执行不同操作。
Unity 3D游戏开发 - C#面向对象 | 多态之接口案例
weixin_41232641的博客
09-16 412
C#属性 常规属性 先定义一个私有的字段，再为这个私有字段封装一个公开的属性，在属性中实现 get 和 set 两个方法，即为常规属性。 当我们使用常规属性时，可以在 get 和 set 方法中，编写逻辑代码对取值和赋值进行逻辑的校验。 自动属性 在某些情况下，属性的 get 和 set 只是完成字段的取值和赋值操作，而不包含任何附加的逻辑代码，这个时候可以使用自动属性。 例...
Unity C# 爆破计划（十一）：动态多态
lfod1997的博客
02-21 211
文章目录十一、动态多态认识多态抽象类虚方法接口 十一、动态多态 Covers：多态（抽象类）、多态（接口） 认识多态 多态 就是一个行为可以具有多种形式或效果。在生活中你不可能没见过多态性：同一个行为“着装”，穿着校服你表现得就像是在上学，穿着西装你看起来就像是要出席重大场合，穿着睡衣你看起来就像是刚起床 —— 人就是个衣架子（夸你长得好看），总要接受一件“衣服”，但衣服的种类不是固定的，当获得了一件具体的衣服时，“穿衣服”这一行为就产生不同的效果。 多态分为 静态多态 和 动态多态，静态多态发生在编译时
Unity C#多态
YzlCoder的记事本
01-19 1571
在写游戏工程中，为了提高代码的重用性我们肯定有的时候是需要多态去实现的。 假如我们在游戏中会有很多怪物。但是由于不同的怪物属性不一样这样的话我们可以想到是可以由一个怪物基类派生出不同的怪物子类，然后复写基类的接口。 例如： 怪物基类为 MonsterBase 里面有个方法为TakeDamage(). 派生出 Monster1 、Monster2两个派生类。 这个时
Unity学习之继承和多态
jingjingcrystal的专栏
12-04 2120
希望我的博客能给喜欢unity3d的朋友们带来用处。 今天我们接着讲昨天的继承，当然也会新添内容：多态。 virtual和override        virtual 用在基类中，指定一个虚方法（属性），表示这个方法（属性）可以重写。        override 用在派生类中，表示对基类虚方法（属性）的重写。        Overload 重载  
什么是多态?
weixin_43226574的博客
02-26 454
什么是多态 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用） 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调...
【Unity 13】 C#继承，多态，抽象类的定义及使用
不积跬步，无以至千里
08-07 907
PS:本系列笔记将会记录我此次在北京学习Unity开发的总体过程，方便后期写总结，笔记为日更。 笔记内容均为 自己理解，不保证每个都对。 C#笔记未按照难度排列 Part 1 继承： PS：继承为之前博客的补充： https://blog.csdn.net/zb756999355/article/details/97520080 1、继承的特点： 派生类(子类)继承基类（父类） 减少子类的代码量,...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值