Unity C# 爆破计划（七）：类与对象
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Unity C# 爆破计划（七）：类与对象，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12575字，纯文字阅读大概需要18分钟。
内容图文
文章目录
七、类与对象
Covers：类、属性、静态类型、继承
我们正式进入面向对象知识的学习。这节的内容很多，以防你赶时间，先上语言对比：
| C# | C++ | |
|---|---|---|
| 成员种类 | 字段、属性、方法、索引、事件 | 成员变量、成员函数 |
| 访问权限 | 5 种（已经介绍过） | 3 种 |
| 成员默认权限 | private | private |
| 类默认权限 | internal | 无此概念 |
| 多继承 | 不支持简单多继承 | 支持 |
| 继承权限 | 固定为 public | 默认 private 继承 |
| 密封类 | 使用 sealed 修饰词 | 使用 final 关键字 |
| 默认构造、析构 | 空实现 | 空实现 |
this 的类型 | 引用 | 指针 |
| 调用静态方法 | CLASSNAME.Method() | CLASSNAME::Method() |
| 抽象类是什么 | 特指 abstract class CLASSNAME | 泛指包含纯虚函数的类 |
| 接口类是什么 | 特指 interface ICLASSNAME | 泛指一类特殊的抽象类 |
| 动态多态方式 | 对象多态 | 指针多态 |
启蒙
我尽量不废话。
- 概念上，类是一种事物的蓝图，对象是具体的个体，对象是类的实例，类是对象的抽象，比如“狗”是一类生物，“汪汪”和“嘟嘟”都是狗的实例，一个类可以有无数实例；
- 实现上，类和结构体都是对数据和函数的组装方式，类是引用类型，对象的“真身”保存在托管堆中，在栈上只有它的引用。
我们用类完成对现实世界各种事物的建模，让它们相互作用，产生复杂的程序行为，是为面向对象编程。现实世界的事物极为复杂，为了能够描述它们，程序世界的类也具有足够复杂的特性，如此一来面向对象就成为了构建复杂服务的有效方法论。
- 组成类的各种零件，包括数据和函数，都是其 成员；
- 类中的成员变量称为 字段；
- 类中的成员函数称为 方法。
类经过 实例化 产生对象，在 C# 中，一个对象的生命周期中有这些关键的时间点：
-
要完成实例化，需要先从系统获取一块足够容纳对象所有字段的内存资源，这叫 空间分配；
-
获得了空间，接下来要为实例的所有字段填写内容（不然狗就没有名字没有性别没有年龄），这叫类的 初始化；
-
要完成初始化，需要调用类的一种特殊方法，叫做 构造函数，一般来说它接受参数，称为 有参构造函数，把这些参数赋给字段，字段就获得了内容；类的字段允许有默认值，这些字段不必须填写内容；如果一个类的所有字段都有默认值，或者它有一个不接受任何参数的构造函数，这个类就有 默认构造函数，一个通过默认构造函数完成初始化的对象是平凡的、不被爱的，有时却是必须的；
Mediocre, unloved, yet essential at one time or another.
-
完成了初始化的对象具有类的所有性质，其方法可以被调用，其字段可以被直接或间接地修改；
-
当对象离开其作用域时，就完成了它的使命，此时它的另一特殊方法被自动调用，叫做 析构函数，它不接受参数，负责在对象的生命周期结尾，进行一些善后处理；
注意：理论上，对象应该在走出作用域时立即被析构，但事实上，因为 CLR 采用垃圾回收机制（GC）来释放内存资源，因此当 GC 认为需要释放内存时，析构函数才会被调用。C# 不保证对象一旦走出作用域就立即被析构，只能保证在程序退出前析构。
你可以用
GC.Collect方法令 GC 立即释放一次内存。 -
最后，对象占用的内存资源被 CLR 自动回收，对象的生命周期结束。
我们用一个例子来演示这些特性：
using System;
namespace Lifetime
{
class Dog
{
// Fields:
public string Name = "";
public int Age = 0;
// Default constructor:
public Dog()
{
Console.WriteLine("A dog is born mediocre, unloved, all alone in a brutal world.\n");
}
// Constructor:
public Dog(string name, int age)
{
Name = name;
Age = age;
Console.WriteLine("A loved dog, {0}, aged {1}, is born.\n", Name, Age);
}
// Destructor:
~Dog()
{
if (Name == "")
{
Console.WriteLine("That dog stepped clumsily away and disappeared, we haven't seen him since.\n");
}
else
{
Console.WriteLine("{0}, now {1} years old, closed his eyes peacefully, surrounded by children.\n",
Name, Age);
}
}
// Methods:
public void Bark()
{
Console.Beep(2200 - Age * 100, 250);
}
public void GrowOld()
{
++Age;
Console.WriteLine("{0} is {1} years old now.\n", Name == "" ? "That dog" : Name, Age);
Bark();
}
}
class Program
{
static void Lifetime()
{
// Let there be two dogs:
Dog dog = new Dog();
Dog barky = new Dog("Barky", 3);
// Watch them grow old over 5 years:
for (int i = 0; i < 5; ++i)
{
dog.GrowOld();
barky.GrowOld();
}
}
static void Main()
{
Lifetime();
GC.Collect();
Console.ReadKey();
}
}
}
注意其中的语法：
- 构造函数：
ACCESS CLASSNAME(PARAMS) - 析构函数：
~CLASSNAME()
属性
属性与访问器
有一定经验的程序员都知道，给予用户的权限越大，程序需要考虑的安全问题就越多，对于网络服务而言更是如此。下面的代码直接将字段设为公有，允许用户直接操作，造成了问题：
using System;
namespace Learning
{
class ElementFinder
{
public int[] Array;
public ElementFinder(int[] array)
{
Array = array;
}
public int Find(int data)
{
for (int i = 0; i < Array.Length; ++i)
{
if (Array[i] == data)
{
return i;
}
}
return -1;
}
}
class Program
{
static void Main()
{
int[] arr = {1, 2, 3, 4, 5};
var finder = new ElementFinder(arr);
finder.Array = null;
Console.WriteLine(finder.Find(3));
}
}
}
运行上面的例子会抛出异常。
分析：类 ElementFinder 原本的功能是保存一个整型数组的引用，当用户调用 Find 方法时，就从保存的数组中寻找参数给定的数值，返回该值第一次出现的下标，若找不到则返回 -1；这里，ElementFinder 中保存的数组引用 Array 是公开可见的，用户（我们用 Main 中的代码模拟用户的调用行为）可以随意修改，而当用户将其修改为空引用 null 时，ElementFinder 并不知道这一点，它仍在 Find 方法中对 Array 进行解引用，因此出错。
通过上面的例子我们发现：字段暴露给用户是危险的，最好的办法是限制用户能够进行的操作。C# 为我们提供了 属性 来实现这一点。属性是类的一种具名成员，它不同于字段也不同于方法，本身不占空间，但对用户而言却表现得如同一个字段，可以像操作变量那样访问，当用户这样做时，我们可以定义属性如何响应。属性充当了与用户之间的界面（API）。
属性通过 访问器 与用户交互，访问器是两个小函数，名为 get 和 set，分别定义了该属性出现在等号右侧和左侧时的行为。可以 只编写 get 访问器，这样属性就是只读的。
我们用访问器来重写 ElementFinder：
class ElementFinder
{
int[] _array;
public int[] Reference
{
get { return _array; }
set
{
if (value == null)
{
throw new NullReferenceException("ElementFinder.Reference: Array reference must not be null!");
}
else
{
_array = value;
}
}
}
public ElementFinder(int[] array)
{
if (array == null)
{
throw new NullReferenceException("ElementFinder.Constructor: Array reference must not be null!");
}
}
public int Find(int data)
{
for (int i = 0; i < _array.Length; ++i)
{
if (_array[i] == data)
{
return i;
}
}
return -1;
}
}
我们将 Array 字段变为私有（默认权限），改名为 _array（这种私有变量小写加前缀下划线的命名方法是 C# 的一种常规代码规范），并定义属性 Reference，当它处于等号右侧（读取其值）时，直接返回 _array，而当处于等号左侧（赋值）时，将检查赋给的值是否为 null，若是，则产生一个异常，并给出“哪里出了问题”的描述。
我知道你有很多疑问：
- 什么是
throw？—— 这个关键字用于直接产生一个异常终止程序的运行：throw new EXCEP(MESSAGE);，EXCEP 是 C# 的内置异常类之一，有很多种（写这句代码时你的 IDE 应该会弹出一个大列表来供你选择），其中NullReferenceException表示“空引用异常”；MESSAGE 是任意字符串，你可以随便写，会在这个异常抛出时显示给用户（我们会在后面更系统地学习异常）； - 折腾了半天依然会抛出异常，重写后的代码有啥优点？—— 你不能奢望你的用户永远不遇到异常，但你可以通过一些异常描述信息帮助他们排错，更可以让 Bug 更早展现出来以便排除；如果这个代码是你自用的，你也可以帮助未来的你尽快找到 Bug 所在。
- 我不管，不要让这东西抛出异常！—— 当然可以，不 throw 而改成你认为妥当的其他处理即可，比如只在屏幕上打印一条信息……这样真的好吗？
言归正传，属性的定义如同字段一样，需要权限、类型和名称，只是后面加上了一个花括号，内含两个分别由 get 和 set 引导的代码块。
-
如果属性是只读的，只需编写 get 访问器即可；
-
set 访问器中，用户想要为属性赋予的值用关键字
value表示，这是 C# 的规定。 -
如果属性是只读的，且 get 访问器只有 1 行，那么可以这样简写：
public TYPE Property => EXPR;它将返回表达式 EXPR 的值。
-
当同时编写 set 和 get 访问器时，如果它们只有 1 行，也可以这样简写：
... { get => EXPR; set => FIELD = value; }其中 get 将返回 EXPR，set 将用户写在等号右侧的值赋给字段 FIELD。
自动属性
当属性的 get 和 set 访问器都是简单的（get 直接返回一个字段，set 直接将 value 赋给同一个字段），那么还可以使用 自动属性 来简化编写，而不需要写一个私有字段，再为其配备一个属性：
public TYPE Property { get; set; }
也可以只写 get，但 不能只写 set。
我的建议是，仅用自动属性来创建只读字段 —— 如果你定义了一个公共的自动属性，它又有 get 又有 set，那和你直接定义一个公共字段有什么区别呢？
继承（基础知识）
父类与子类
继承是面向对象的重要概念，这个特性允许我们根据一个类来定义另一个类，有利于代码重用，减小工作量。被继承的类称为 父类 或 基类，继承父类的类称为 子类 或 派生类，我们也用 派生 这个词，它等价于继承，称“A 类派生出了 B 类”，或“B 类派生自 A 类”。
子类具有父类的所有成员（但未必有访问权限），同时也可以新增成员，父类对子类中新增的成员一无所知；子类也可以继续派生出其他类，形成 继承链，直到类被密封（显式定义禁止继承）。
举个栗子：生物分类学就是典型的继承链。所有“动物”从“生物”基类派生出来，“脊椎动物”继承自“动物”类，“哺乳动物”继承自“脊椎动物”类，“犬科动物”继承自“哺乳动物”类，“狗”继承自“犬科动物”类，“哈士奇犬”继承自“狗”类。可见，每派生出一个子类，就在父类基础上增加了更详细的定义，但我们一定可以说出“子类对象是（is-a）父类对象”，比如“哈士奇犬是狗”、“狗是犬科动物”、“犬科动物是哺乳动物”等。
不满足“is-a”关系的继承是不成立的，但有时我们不容易发现逻辑错误。比如，狗不能继承自“宠物”类，因为“狗是宠物”这句话不成立（并非所有狗都是宠物）；当你执意这样继承时，就否认了两类的一部分差集（“野生的狗”）的存在，窄化了逻辑，降低了程序的扩展性和重用性。精辟的抽象需要严密的构思，谨慎继承、多做预想。
我们写一个例子来了解继承的语法，这次没有狗：
using System;
namespace Inheritance
{
class Shape
{
protected string Type = "";
public string ShapeType => Type;
}
class Rectangle : Shape
{
double _height;
double _width;
public Rectangle(double h, double w)
{
Type = "Rectangle";
if (h <= 0.0)
{
throw new Exception("Rectangle.ctor: Height must be greater than 0");
}
if (w <= 0.0)
{
throw new Exception("Rectangle.ctor: Width must be greater than 0");
}
_height = h;
_width = w;
}
public double Height
{
get => _height;
set
{
if (value <= 0.0)
{
Console.WriteLine("Height must be greater than 0, aborted");
}
else
{
_height = value;
}
}
}
public double Width
{
get => _width;
set
{
if (value <= 0.0)
{
Console.WriteLine("Width must be greater than 0, aborted");
}
else
{
_width = value;
}
}
}
public double Area => _height * _width;
public double Perimeter => (_height + _width) * 2.0;
}
class Program
{
static void Main()
{
var rect = new Rectangle(3, 2.5);
rect.Width = 1.414;
rect.Height = 0.828;
Console.WriteLine("{0}:", rect.ShapeType);
Console.WriteLine("\tArea = {0}", rect.Area);
Console.WriteLine("\tPerimeter = {0}", rect.Perimeter);
}
}
}
这个例子中我们定义了 Shape 基类，并派生出了一个子类 Rectangle，它的构造函数接受宽高数据（必须大于 0）；对象初始化后，可以用其属性来获取其面积和周长，也可以通过基类的 ShapeType 方法取得其种类。
控制台输出：
Rectangle:
Area = 1.170792
Perimeter = 4.484
注意继承的语法：class CLASSNAME : BASE，用冒号来表示继承。
父类的初始化
“先有鸡还是先有蛋”这个问题不好回答，但“先有父亲还是先有儿子”的答案显而易见。
在构造子类对象之前，必须先构造一个其父类的对象，这个过程是编译器自动帮我们完成的，但有时我们希望能够自己控制父类对象的构造，尤其是父类本身只有有参构造函数时。
上面的 Shape 例子中，我们为 Type 赋了默认值 ""（空字符串），因此 Shape 类有默认构造函数。在构造父类对象时，首先将 Type 赋予默认值，紧接着又在构造子类 Rectangle 对象时，重新为 Type 赋了值，这里产生了一个不必要的赋值步骤。我们改写父类的构造函数，使其只能有参构造：
class Shape
{
protected string Type;
protected Shape(string type)
{
Type = type;
}
public string ShapeType => Type;
}
注意：只要一个类具有有参构造函数，它就默认不具有默认（无参）构造函数，除非显式定义；上面的代码中即使给 Type 加上默认值，也无法再无参构造 Shape 对象。
接着改写 Rectangle 类的构造函数，使其调用父类的有参构造：
public Rectangle(double h, double w) : base("Rectangle")
{
/* Type = "Rectangle"; */
if (h <= 0.0)
...
}
注意调用父类构造函数的语法：CTOR : base(PARAMS)，CTOR 是子类构造函数的签名（说白了就是上例中冒号前面的部分），PARAMS 是传递给父类有参构造函数的实际参数。
静态成员
静态的意思是“独立于类的所有实例”、“一成不变”，静态的方法和字段不需要依托于类的实例，甚至不需要有任何实例；非静态方法和字段依托于类的实例，没有实例就不能调用。
换言之，静态成员是整个类所共有的、全局唯一的。
你已经看过多次 static 关键字。在定义方法时，如果加上 static 关键字，那么该方法就是静态方法；在定义字段时，加上 static 的字段就是静态字段。我们在调用类的某个方法时，有时点号前面是类名（Console.WriteLine），有时前面是实例名（myint.ToString），前者调用的是静态方法，后者调用的是非静态方法。
举个栗子：“狗”类如果有一个字段“有无尾巴”，那它显然应该是一个静态字段，因为所有狗都有尾巴；假如你修改这个字段为 false，那么在你的程序世界中所有狗就都没有尾巴。
再举个栗子：“狗”类如果定义一个方法“叫”，功能是在控制台打印一个“汪！”，那么这个方法就应该是静态方法，因为所有狗叫的效果都一样；如果你要让每个狗（每个实例）有不同的叫声（方法会产生与个体有关的行为），那么就不能设计为静态方法，同时你还要添加一个字段来保存每只狗怎么叫。
静态类
.NET 2.0 引入静态类的概念，静态类是一种特殊的类，不能被实例化，一般作为一些方法和“全局变量”的容器。我们熟悉的 Console 类就是一个静态类，你不能实例化 Console。
静态类有这些特点：
- 仅包含静态成员
- 不能实例化
- 是密封类（说白了就是不能被继承）
静态类虽然不能实例化，但可以拥有构造函数，静态构造函数前面要加上 static 修饰，它在第一次调用静态类的方法时被自动调用。
T.B.C.
内容总结
以上是互联网集市为您收集整理的Unity C# 爆破计划（七）：类与对象全部内容，希望文章能够帮你解决Unity C# 爆破计划（七）：类与对象所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。