Unity基础之C#核心篇笔记5：面向对象关联知识点

最新推荐文章于 2024-01-13 11:43:31 发布
最新推荐文章于 2024-01-13 11:43:31 发布
阅读量1.1k 收藏 2
点赞数 2
分类专栏： Unity基础之C#核心篇笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42481369/article/details/117306797
版权

Unity基础之C#核心篇笔记5：面向对象关联知识点

命名空间

1.命名空间基本概念

//概念
//命名空间是用来组织和重用代码的
//作用
//就像是一个工具包，类就像是一件一件的工具，都是申明在命名空间中的

2.命名空间的使用

//基本语法
//namespace 命名空间名
//{
//  类
//  类
//}
namespace MyGame
{
    class GameObject
    {

    }
}

namespace MyGame
{
    class Player:GameObject
    {

    }
}

3.不同命名空间中相互使用 需要引用命名空间或指明出处

            Image img0 = new Image();
            MyGame.UI.Image img = new MyGame.UI.Image();
            MyGame.Game.Image img2 = new MyGame.Game.Image();

4.不同命名空间中允许有同名类

namespace MyGame2
{
    //在不同的命名空间中 是可以有同名类的
    class GameObject
    {

    }
}

5.命名空间可以包裹命名空间

namespace MyGame
{
    namespace UI
    {
        class Image
        {

        }
    }

    namespace Game
    {
        class Image
        {

        }
    }
}

6.关于修饰类的访问修饰符

//public   —— 命名空间中的类 默认为public
//internal —— 只能在该程序集中使用
//abstract —— 抽象类
//sealed   —— 密封类
//partial  —— 分部类

万物之父中的方法

1.知识回顾

            //万物之父 object
            //所有类型的基类 是一个引用类型
            //可以利用里氏替换原则装载一切对象
            //存在装箱拆箱

2.object中的静态方法

  class Test
    {
        public int i = 1;
        public Test2 t2 = new Test2();

        public Test Clone()
        {
            return MemberwiseClone() as Test;
        }

        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public override string ToString()
        {
            return "唐老狮申明的Test类";
        }
    }
    class Test2
    {
        public int i = 2;
    }
    //静态方法 Equals 判断两个对象是否相等
            //最终的判断权，交给左侧对象的Equals方法，
            //不管值类型引用类型都会按照左侧对象Equals方法的规则来进行比较
            Console.WriteLine(Object.Equals(1, 1));
            //Test t = new Test();
            //Test t2 = new Test();
            //Console.WriteLine(Object.Equals(t, t2));
            //静态方法ReferenceEquals
            //比较两个对象是否是相同的引用，主要是用来比较引用类型的对象。
            //值类型对象返回值始终是false。
            //Console.WriteLine(Object.ReferenceEquals(t, t2));

3.object中的成员方法

//普通方法GetType
            //该方法在反射相关知识点中是非常重要的方法，之后我们会具体的讲解这里返回的Type类型。
            //该方法的主要作用就是获取对象运行时的类型Type，
            //通过Type结合反射相关知识点可以做很多关于对象的操作。
            Test t = new Test();
            Type type = t.GetType();
            //普通方法MemberwiseClone
            //该方法用于获取对象的浅拷贝对象，口语化的意思就是会返回一个新的对象，
            //但是新对象中的引用变量会和老对象中一致。
            Test t2 = t.Clone();
            Console.WriteLine("克隆对象后");
            Console.WriteLine("t.i = " + t.i);
            Console.WriteLine("t.t2.i = " + t.t2.i);
            Console.WriteLine("t2.i = " + t2.i);
            Console.WriteLine("t2.t2.i = " + t2.t2.i);

            t2.i = 20;
            t2.t2.i = 21;
            Console.WriteLine("改变克隆体信息后");
            Console.WriteLine("t.i = " + t.i);
            Console.WriteLine("t.t2.i = " + t.t2.i);
            Console.WriteLine("t2.i = " + t2.i);
            Console.WriteLine("t2.t2.i = " + t2.t2.i);

可以理解为用MemberwiseClone方法克隆对象后，克隆体中开辟了与原对象一样的内存空间。
克隆体中引用变量的内存单元存储的值和原对象一样（克隆了原对象的引用变量的地址），也就是两者的引用地址指向同一堆内存单元中，修改时，原对象的引用变量也会改变。
而克隆体开辟的值类型的内存，存储的值与原来对象值类型值一致，两者没有联系，修改时原对象值类型值不变

4.object中的虚方法

            //虚方法Equals
            //默认实现还是比较两者是否为同一个引用，即相当于ReferenceEquals。
            //但是微软在所有值类型的基类System.ValueType中重写了该方法，用来比较值相等。
            //我们也可以重写该方法，定义自己的比较相等的规则

            //虚方法GetHashCode
            //该方法是获取对象的哈希码
            //（一种通过算法算出的，表示对象的唯一编码，不同对象哈希码有可能一样，具体值根据哈希算法决定），
            //我们可以通过重写该函数来自己定义对象的哈希码算法，正常情况下，我们使用的极少，基本不用。

            //虚方法ToString
            //该方法用于返回当前对象代表的字符串，我们可以重写它定义我们自己的对象转字符串规则，
            //该方法非常常用。当我们调用打印方法时，默认使用的就是对象的ToString方法后打印出来的内容。

5.总结

1.虚方法 toString 自定字符串转换规则
2.成员方法 GetType 反射相关
3.成员方法 MemberwiseClone 浅拷贝
4.虚方法 Equals 自定义判断相等的规则

6.练习题

1.练习题1

    //有一个玩家类，有姓名，血量，攻击力，防御力，闪避率等特征
    //请在控制台打印出“玩家XX，血量XX，攻击力XX，防御力XX”XX为具体内容

    class Player
    {
        private string name;
        private int hp;
        private int atk;
        private int def;
        private int miss;

        public Player(string name, int hp, int atk, int def, int miss)
        {
            this.name = name;
            this.hp = hp;
            this.atk = atk;
            this.def = def;
            this.miss = miss;
        }

        public override string ToString()
        {
            return string.Format("玩家{0},血量{1},攻击力{2},防御力{3},闪避{4}", name, hp, atk, def, miss);
        }
    }

2.练习题2

   //一个Monster类的引用对象A，Monster类有 攻击力、防御力、血量、技能ID等属性。
    //我想复制一个和A对象一模一样的B对象。并且改变了B的属性，A不会受到影响。请问如何实现？

    class Monster
    {
        public Monster(int atk, int def, int hp, int skillID)
        {
            Atk = atk;
            Def = def;
            Hp = hp;
            SkillID = skillID;
        }

        public int Atk
        {
            get;
            set;
        }

        public int Def
        {
            get;
            set;
        }
        public int Hp
        {
            get;
            set;
        }
        public int SkillID
        {
            get;
            set;
        }

        public Monster Clone()
        {
            return MemberwiseClone() as Monster;
        }

        public override string ToString()
        {
            return string.Format("攻击里{0},防御力{1},血量{2},技能{3}", Atk, Def, Hp, SkillID);
        }
    }
        class Program
    {
        static void Main(string[] args)
        {
            Monster m = new Monster(10, 20, 100, 1);
            Monster m2 = m.Clone();
            m2.Atk = 30;
            m2.SkillID = 100;
            Console.WriteLine(m);
            Console.WriteLine(m2);
        }
    }

String

1.字符串指定位置获取

            //字符串本质是char数组
            string str = "123";
            Console.WriteLine(str[0]);
            //转为char数组
            char[] chars = str.ToCharArray();
            Console.WriteLine(chars[1]);

            for (int i = 0; i < str.Length; i++)
            {
                Console.WriteLine(str[i]);
            }

2. 字符串拼接

			str = string.Format("{0}{1}", 1, 3333);
            Console.WriteLine(str);

3. 正向查找字符位置

            str = "123！";
            int index = str.IndexOf("1");
            Console.WriteLine(index);

            index = str.IndexOf("4");
            Console.WriteLine(index);

4. 反向查找指定字符串位置

           str = "123456456";

            index = str.LastIndexOf("456");
            Console.WriteLine(index);

            index = str.LastIndexOf("456");
            Console.WriteLine(index);

5. 移除指定位置后的字符

            str = "123456456";
            str.Remove(4);
            Console.WriteLine(str);
            str = str.Remove(4);
            Console.WriteLine(str);
            
            //执行两个参数进行移除
            //参数1 开始位置
            //参数2 字符个数
            str = str.Remove(1, 1);
            Console.WriteLine(str);

6. 替换指定字符串

            str = "123456456";
            str.Replace("123", "789");
            Console.WriteLine(str);
            str = str.Replace("123", "789");
            Console.WriteLine(str);

7. 大小写转换

            str = "ksdfasdfasfasdfsasdfasdf";
            str.ToUpper();
            Console.WriteLine(str);
            str = str.ToUpper();
            Console.WriteLine(str);

            str.ToLower();
            Console.WriteLine(str);
            str = str.ToLower();
            Console.WriteLine(str);

8. 字符串截取

            str = "456456";
            //截取从指定位置开始之后的字符串
            str.Substring(2);
            Console.WriteLine(str);
            str = str.Substring(2);
            Console.WriteLine(str);

            //参数一 开始位置
            //参数二 指定个数
            //不会自动的帮助你判断是否越界 你需要自己去判断
            str = str.Substring(2, 2);
            Console.WriteLine(str);

9. 字符串切割

            str = "1_1|2_2|3_3|5_1|6_1|7_2|8_3";
            string[] strs = str.Split('|');
            for (int i = 0; i < strs.Length; i++)
            {
                Console.WriteLine(strs[i]);
            }

10. 练习题

1.练习题1

            //请写出string中提供的截取和替换对应的函数名
            //string str = "123123";
            //str = str.Substring(1);
            //str = str.Substring(1, 1);

            //str = "123123";
            //str = str.Replace("123", "456");

2.练习题2

            //请将字符串1 | 2 | 3 | 4 | 5 | 6 | 7
            //变为     2 | 3 | 4 | 5 | 6 | 7 | 8
            //并输出
            //（使用字符串切割的方法）
            str = "1 | 2 | 3 | 4 | 5 | 6 | 7";
            string[] strs = str.Split('|');
            str = "";
            for (int i = 0; i < strs.Length; i++)
            {
                str += int.Parse(strs[i]) + 1;
                if (i != strs.Length - 1)
                {
                    str += "|";
                }
            }
            Console.WriteLine(str);

3.练习题3

//String和string、Int32和int、Int16和short、Int64和long他们的区别是什么？
//别名，本质是一家

4.练习题4

            //string str = null;
            //str = "123";
            //string str2 = str;
            //str2 = "321";
            //str2 += "123";
            //请问，上面这段代码，分配了多少个新的堆空间
            //3个 “123”，“321”，“321123”

5.练习题5

            //编写一个函数，将输入的字符串反转。不要使用中间商，你必须原地修改输入数组。交换过程中不使用额外空间
            //比如：输入{‘h’,‘e’,‘l’,‘l’,‘o’}
            //输出      {‘o’,‘l’,‘l’,‘e’,‘h’}
                        Console.WriteLine("请输入内容");
            string str3 = Console.ReadLine();
            char[] chars = str3.ToCharArray();
            for (int i = 0; i < chars.Length / 2; i++)
            {
                //交换
                //char temp = chars[i];
                //chars[i] = chars[chars.Length - 1 - i];
                //chars[chars.Length - 1 - i] = temp;
                chars[i] = (char)(chars[i] + chars[chars.Length - 1 - i]);
                chars[chars.Length - 1 - i] = (char)(chars[i] - chars[chars.Length - 1 - i]);
                chars[i] = (char)(chars[i] - chars[chars.Length - 1 - i]);
            }

            for (int i = 0; i < chars.Length; i++)
            {
                Console.Write(chars[i]);
            }
            Console.WriteLine();
            str3 = new string(chars);
            Console.WriteLine(str3);

StringBuilder

1.知识回顾

        string是特殊的引用
        每次重新赋值或者拼接时会分配新的内存空间
        如果一个字符串经常改变会非常浪费空间

2.StringBuilder

            //C#提供的一个用于处理字符串的公共类 
            //主要解决的问题是：
            //修改字符串而不创建新的对象,需要频繁修改和拼接的字符串可以使用它，可以提升性能
            //使用前 需要引用命名空间

            #region 初始化 直接指明内容
            StringBuilder str = new StringBuilder("123123123");
            Console.WriteLine(str);
            #endregion

            #region 容量
            //StringBuilder存在一个容量的问题，每次往里面增加时 会自动扩容
            //获得容量
            Console.WriteLine(str.Capacity);
            //获得字符长度
            Console.WriteLine(str.Length);
            #endregion

            #region 增删查改替换
            //增
            str.Append("4444");
            Console.WriteLine(str);
            Console.WriteLine(str.Length);
            Console.WriteLine(str.Capacity);

            str.AppendFormat("{0}{1}", 100, 999);
            Console.WriteLine(str);
            Console.WriteLine(str.Length);
            Console.WriteLine(str.Capacity);
            //插入
            str.Insert(0, "唐老狮");
            Console.WriteLine(str);
            //删
            str.Remove(0, 10);
            Console.WriteLine(str);
            //清空
            //str.Clear();
            //Console.WriteLine(str);
            //查
            Console.WriteLine(str[1]);
            //改
            str[0] = 'A';
            Console.WriteLine(str);
            //替换
            str.Replace("1", "唐");
            Console.WriteLine(str);

            //重新赋值 StringBuilder
            str.Clear();
            str.Append("123123");
            Console.WriteLine(str);
            //判断StringBuilder是否和某一个字符串相等
            if( str.Equals("12312") )
            {
                Console.WriteLine("相等");
            }

3.练习题

1.练习题1

            #region 练习题一 请描述string和stringbuilder的区别
            //1.string相对stringbuilder 更容易产生垃圾 每次修改拼接都会产生垃圾
            //2.string相对stringbuilder 更加灵活 因为它提供了更多的方法供使用
            //如何选择他们两
            //需要频繁修改拼接的字符串可以使用stringbuilder
            //需要使用string独特的一些方法来处理一些特殊逻辑时可以使用string
            #endregion

2.练习题2

            #region 练习题二 如何优化内存
            //内存优化 从两个方面去解答 
            //1.如何节约内存
            //2.如何尽量少的GC（垃圾回收）

            //少new对象 少产生垃圾
            //合理使用static 
            //合理使用string和stringbuilder
            #endregion

结构体和类的区别

1.区别概述

        结构体和类最大的区别是在存储空间上的，因为结构体是值，类是引用，
        因此他们的存储位置一个在栈上，一个在堆上，
        通过之前知识点的学习，我相信你能够从此处看出他们在使用的区别——值和引用对象在赋值时的区别。

        结构体和类在使用上很类似，结构体甚至可以用面向对象的思想来形容一类对象。
        结构体具备着面向对象思想中封装的特性，但是它不具备继承和多态的特性，因此大大减少了它的使用频率。
        由于结构体不具备继承的特性，所以它不能够使用protected保护访问修饰符。

2.细节区别

        1.结构体是值类型，类是引用类型
        2.结构体存在栈中，类存在堆中
        3.结构体成员不能使用protected访问修饰符，而类可以
        4.结构体成员变量申明不能指定初始值，而类可以
        5.结构体不能申明无参的构造函数，而类可以
        6.结构体申明有参构造函数后，无参构造不会被顶掉
        7.结构体不能申明析构函数，而类可以
        8.结构体不能被继承，而类可以
        9.结构体需要在构造函数中初始化所有成员变量，而类随意
        10.结构体不能被静态static修饰（不存在静态结构体），而类可以
        11.结构体不能在自己内部申明和自已一样的结构体变量，而类可以

3.结构体的特别之处

结构体可以继承 接口 因为接口是行为的抽象

4.如何选择结构体和类

        1.想要用继承和多态时，直接淘汰结构体，比如玩家、怪物等等
        2.对象是数据集合时，优先考虑结构体，比如位置、坐标等等
        3.从值类型和引用类型赋值时的区别上去考虑，比如经常被赋值传递的对象，并且
        改变赋值对象，原对象不想跟着变化时，就用结构体。比如坐标、向量、旋转等等
        #endregion

抽象类和接口的区别

1.知识回顾

        抽象类和抽象方法
        abstract修饰的类和方法
        抽象类 不能实例化
        抽象方法只能在抽象类中申明 是个纯虚方法 必须在子类中实现

        接口
        interface 自定义类型
        是行为的抽象
        不包含成员变量
        仅包含方法、属性、索引器、事件，成员都不能实现，建议不写访问修饰符，默认public

2.相同点

    1.都可以被继承
    2.都不能直接实例化
    3.都可以包含方法申明
    4.子类必须实现未实现的方法
    5.都遵循里氏替换原则

3.区别

        1.抽象类中可以有构造函数；接口中不能
        2.抽象类只能被单一继承；接口可以被继承多个
        3.抽象类中可以有成员变量；接口中不能
        4.抽象类中可以申明成员方法，虚方法，抽象方法，静态方法；接口中只能申明没有实现的抽象方法
        5.抽象类方法可以使用访问修饰符；接口中建议不写，默认public

4.如何选择抽象类和接口

        表示对象的用抽象类，表示行为拓展的用接口
        不同对象拥有的共同行为，我们往往可以使用接口来实现
        举个例子：
        动物是一类对象，我们自然会选择抽象类；而飞翔是一个行为，我们自然会选择接口。

面向对象七大原则

1.单一职责原则

SRP(Single Responsibility Principle)
类被修改的几率很大，因此应该专注于单一的功能。
如果把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能。
举例:假设程序、策划、美术三个工种是三个类，他们应该各司其职，在程序世界中只应该做自己应该做的事情。

2.开闭原则

OCP(Open-Closed Principle)对拓展开发，对修改关闭
拓展开放:模块的行为可以被拓展从而满足新的需求
修改关闭:不允许修改模块的源代码（或者尽量使修改最小化)
举例:继承就是最典型的开闭原则的体现，可以通过添加新的子类和重写父类的方法来实现

3.里氏替换原则

LSP(Liskov Substitution Principle)任何父类出现的地方，子类都可以替代
举例:用父类容器装载子类对象，因为子类对象包含了父类的所有内容

4.依赖倒转原则

DIP(Dependence Inversion Principle)要依赖于抽象，不要依赖于具体的实现

在这里插入图片描述

5.迪米特原则

LoP(Law of Demeter)又称最少知识原则
一个对象应当对其它对象尽可能少的了解（不要和陌生人说话）
举例:一个对象中的成员，要尽可能少的直接和其它类建立关系。目的是降低耦合性

6.接口分离原则

ISP(Interface Segregation Principle)不应该强迫别人依赖他们不需要使用的方法
一个接口不需要提供太多的行为，一个接口应该尽量只提供一个对外的功能，让别人去选择需要实现什么样的行为，而不是把所有的行为都封装到一个接口当中
举例:飞行接口、走路接口、跑步接口等等虽然都是移动的行为但是我们应该把他们分为一个一个单独的接口，让别人去选择使用

7.合成复用原则

CRP(Composite Reuse Principle)
尽量使用对象组合，而不是继承来达到复用的目的继承关系是强耦合，组合关系是低耦合
举例:脸应该是眼镜、鼻子、嘴巴、耳朵的组合，而不是依次的继承角色和装备也应该是组合，而不是继承
注意:不能盲目的使用合成复用原则，要在遵循迪米特原则的前提下

8.总结

单一职责原则:一个类只处理自己应该处理的内容，不应该啥都写在一起
开闭原则:对拓展开放，对修改封闭。新加功能尽量是加处理而不是改代码
里氏替换原则:任何地方子类都能替代父类，父类容器装子类
依赖倒转原则:不要依赖具体的实现，要依赖抽象（接口)
迪米特法则:一个类要尽量减少对别的类的了解，尽量少用别的类和自己关联
接口隔离原则:一个接口一个行为，不要一个接口n个行为
合成复用原则:除非设计上需要继承，否则尽量用组合复用的形式

9.如何使用这些原则

在开始做项目之前，整理UML类图时先按自己的想法把需要的类整理出来
再把七大原则截图放在旁边，基于七大原则去优化整理自己的设计
整体目标就是:高内聚，低耦合
四月的白羊座
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Unity设计模式——原型模式
问渠哪得清如许，为有源头活水来
01-31 370
原型模式是一种创造性模式，它通过复制一个已有对象来获取更多相同或者相似地对象。原型模式可以提高相同类型对象的创造效率，简化创建流程。让我们来看看Unity里怎么使用原型模式。
【每天进步一点】C#对象之间的关系
qq_44032411的博客
12-17 950
一、简介 类是对象的集合，展示了对象的结构以及与系统的交互行为。类主要有属性（Attribute）和方法（Method）构成,属性代表对象的状态，如果属性被保存到数据库，此称之为“持久化”；方法代表对象的操作行为，类具有继承关系，可以继承于父类，也可以与其他的Class进行交互。 二、 对象之间的关系 1.（树形）继承–>实现（父类–子类) 接口–>实现 2. (平行)由强到弱的关系...
【Unity】Prefab预设体及取消关联
weixin_43962215的博客
10-27 8483
【Unity】Prefab预设体及取消关联 如果将Prefab在资源面板中删除，GameObject失去关联对象，名字变成暗红色。 那么问题来了，如果想取消GameObject对Prefab的关联，该如何操作？ 1.选中要取消关联的物体 2.鼠标右键选中物体点击Unpack Prefab,即可。 这样边取消了物体对预设体的关联，名字已经是正常的，预设体变化时，也不会影响该物体了 ...
Unity3D - 【GameObject】游戏对象的操作（一）
⚡
01-16 9559
Unity中的所有实体都属于游戏对象， 对于游戏物体对象的操作以及游戏对象之间的交互都需要使用代码来完成。 ① 创建游戏对象 ② 获取游戏对象 ③ 为游戏对象添加组件和修改组件 ④ 发送广播与消息 ⑤ 克隆游戏对象 ***********************************************************************************...
【unity数据交互】-Unity公共类PlayerPrefs
秩沅
05-07 1536
Unity公共类PlayerPrefs的知识点和实践
C#基础教程,含读书笔记word版.rar
05-17
C#是一种由微软公司开发的面向对象的编程语言，它被广泛应用于Windows平台的...通过深入学习和实践这些知识点，初学者将能够逐步掌握C#编程，并为进一步学习更高级的主题，如ASP.NET、WPF或Unity游戏开发打下坚实基础。
unity笔记-面对对象，unity
09-20
本摘要信息将对 Unity 笔记中的面对对象编程概念进行详细的解释和总结，并对相关的知识点进行详细的解释。 一、变量类型和使用规则 在 C# 语言中，变量类型包括 int、double、string、char、bool、decimal 等。...
达内Unity课程四个月学习笔记
01-12
在Unity3D的学习旅程中，达内的四个月课程涵盖了从基础到高级的多个关键知识点，旨在帮助学员掌握这款强大的游戏开发引擎。以下是根据这四个月学习笔记中的关键内容所提炼的详细知识点： 一月内容主要涉及Unity的...
unity笔记 全阶段
03-16
本笔记旨在为初学者提供一个全面的Unity学习路径，从基础到进阶，涵盖环境搭建、3D基础知识、C#编程语言、脚本编写等多个方面。 一、Unity基础 1. 引言：在开始Unity学习之前，了解其历史背景、应用领域和主要功能...
unity学习笔记.zip
05-18
在压缩包中的"unity学习笔记"中，你可能会找到关于以上知识点的详细说明和示例代码。每个功能分类下的代码可以直接应用到你的项目中，帮助你快速掌握Unity3D的常用操作。对于初学者，这是一份宝贵的参考资料，而对于...
[Unity&对象]怎么理解变量public 还是private ，还是使用getset方法定义
BuladeMian的博客，菜得抠脚，菜得真实
06-13 7339
怎么理解变量public 还是private ，还是使用getset方法定义 private 变量 只能被自己的 类 调用。 public 变量 可以被其他 类调用。 get set 方法的本质是，为了让 操作代码 的设计师 、程序员明白 这个变量 的使用 条件，和应用的 环境。便于工作 ，优化代码。 在参考资料1中 第30个技巧，提到 可以 使
Unity对象池和自写对象池
新东西新事物....
12-23 2157
一. 什么是对象池顾名思义就是一定数量的已经创建好的对象(Object)的集合。当需要创建对象时，先在池子中获取，如果池子中没有符合条件的对象，再进行创建新对象，同样，当对象需要销毁时，不做真正的销毁，而是将其setActive(false)，并存入池子中，这样就避免了大量对象的创建。好处：降低性能，减少反复生成和摧毁产生的大量GC。坏处：①回收过程复杂度增加，在下次使用的同时，需要清空回收前的数据。②生命周期比其他的对象较长。
unity 类的深拷贝
weixin_41798071的博客
08-19 1759
将对象的字段复制到新的对象副本中，同时将字段的值也复制过去，但引用类型值复制引用，而不是引用类型本身，也就是，如果源对象的引用类型的字段的值改变了，拷贝的对象的对应的引用类型的字段也会跟着变化。将对象的字段复制到新的对象副本中，无论是值类型还是引用类型的字段，都会复制类型本身及值。但，源对象的值变化，并不会影响副本中的对应的值。
unity C#深拷贝、浅拷贝、直接赋值区别与经典实例
最新发布
qqrrjj2011的博客
01-13 2183
浅拷贝是指复制对象时，只复制对象本身所包含的值类型字段，并将引用类型字段简单地复制一份引用，而不是复制引用的对象内容。当一个对象被直接赋值给另一个变量时，实际上创建的是原对象的一个引用副本。浅拷贝同样是创建了一个新的对象，并且复制了原对象的所有非引用类型字段值和引用类型的引用。与直接赋值类似，浅拷贝后的引用类型成员仍然指向原来的引用类型的实例。深拷贝则不仅复制值类型字段，还复制引用类型字段所引用的对象，并为这些对象分配新的内存空间。这样一来，修改深拷贝后对象的引用类型字段不会影响到原对象。
Unity3D中Public和[SerializeField]的使用
CoderH 技术博客
10-15 5553
在Unity3d中Unity3D 中提供了非常方便的功能可以帮助用户将 成员变量 在Inspector中显示，并且定义Serialize关系。 也就是说凡是显示在Inspector 中的属性都同时具有Serialize功能(序列化的意思是说再次读取Unity时序列化的变量是 有值的，不需要你再次去赋值，因为它已经被保存下来)。 public 变量 在没有加入任何Attribute的前提下，pu...
Unity中对游戏对象的操作
wangxuewen990129的博客
07-09 552
using UnityEngine; public class shiyan : MonoBehaviour { public GameObject prefab;//要操作的对象 private void Start() { //给对象添加组件 prefab.AddComponent<Rigidbody>();//这里尖括号<>中可以填 组件 或者是脚本名称 //移除对象身上的组件 Destr
【唐老狮】C#四部曲之C#入门：习题汇总
MrTang_Unity的博客
04-26 3160
本篇文章对视频教程 《【唐老狮】Unity系列之C#四部曲—C#入门》 当中的课后练习题进行了汇总，方便同学们统一进行练习和复习 这些习题的解题部分都在本教程中以视频的形式进行了详细讲解 B站免费试看 【唐老狮】Unity系列之C#四部曲—C#入门_哔哩哔哩_bilibili 泰课会员免费看： https://www.taikr.com/goods/show/589 本套课程属于Unity实战就业路线（打折预售中） https://www.taikr.com/goods/show/5.
C#面向对象学习总结
run__ning的博客
12-16 546
对事物进行分析和总结，抽象出共同的特征和行为，封装成类，再把类进行实例化。这种设计思想就叫面向对象。方法重载：方法名相同，参数的类型不同，或者参数的个数不同 方法重载的作用：少取方法名，构造方法是给属性赋初始值，文件读写基本步骤FileStream fs=new FileStream("Path",FileMode.枚举值,FileAccess.枚举值);
unity系统入门笔记
09-06
当初我学习Unity系统的时候，我做了一些笔记，希望能帮到你入门。下面是一些关键点： 1. Unity是一个跨平台的游戏开发引擎，可用于开发2D和3D游戏。它提供了一个可视化的编辑器，让你可以轻松地创建场景、对象、材质等。 2. 编辑器界面：Unity的编辑器界面分为场景视图、层次视图、资源视图和检视视图等。场景视图用于查看和编辑场景，层次视图显示场景中的对象层次结构，资源视图用于管理项目中的资源，检视视图则显示了当前选中对象的属性和组件。 3. 游戏对象：Unity中的一切都是游戏对象，包括角色、道具、相机等。每个游戏对象都可以附加多个组件，比如渲染器、碰撞器、脚本等，用来实现不同的功能和行为。 4. 脚本编程：Unity使用C#作为主要的编程语言。你可以编写脚本来控制游戏对象的行为。脚本可以挂载到游戏对象上，通过组件来访问和修改游戏对象的属性和方法。 5. 场景管理：通过场景管理器可以创建、编辑和切换不同的场景。你可以在场景中添加、移动、旋转和缩放游戏对象，设置摄像机视角，调整光照效果等。 6. 资源管理：Unity提供了资源视图来管理项目中的资源，包括纹理、音频、模型等。你可以导入和导出资源，并在项目中进行引用和使用。 7. 物理引擎：Unity内置了物理引擎，可以模拟物体的运动和碰撞。你可以给游戏对象添加刚体组件，设置质量、重力、碰撞检测等属性，实现真实的物理效果。 8. 动画系统：Unity提供了强大的动画系统，可以创建和编辑角色的动画。你可以通过动画控制器来管理不同的动画状态，并通过脚本控制角色的动画播放和过渡。 这些仅是入门的基本知识点，希望对你有所帮助。如果你还有其他问题，可以继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四月的白羊座

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值