文章目录

• 1、访问修饰符
• 2、默认值
• 3、类
• • 3.1、特征 --- 成员变量
  • 3.2、行为 --- 成员方法
  • 3.3、保护特征 --- 成员属性
  • • 3.3.1、概念
    • 3.3.2、基本语法
    • 3.3.3、get 和 set 前可加访问修饰符
  • 3.4、构造函数
  • 3.5、析构函数
  • 3.6、索引器
  • • 3.6.1、基本概念
    • 3.6.2、语法
    • 3.6.3、使用
    • 3.6.4、索引器中可以写逻辑
    • 3.6.5、索引器可以重载
  • 3.7、运算符重载
  • • 3.7.1、概念
    • 3.7.2、语法
    • 3.7.3、栗子
    • 3.7.4、可重载运算符有哪些
  • 3.8、静态成员
  • 3.9、静态类
  • 3.10、静态构造函数
  • 3.11、拓展方法
  • • 3.11.1、概念
    • 3.11.2、语法
    • 3.11.3、栗子
  • 3.12、内部类
  • 3.13、分部类 和 分部方法
  • • 3.13.1、分部类
    • 3.13.2、分部方法

点击访问官网 class

1、访问修饰符

• 点击访问官网 访问修饰符
• 以下列举常用3个（注：不写默认private）

2、默认值

• 引用类型默认值都是 null，值类型略
• 可以通过 default(类型) 查看任意类型的默认值

3、类

[访问修饰符] class 类名
{// 特征 --- 成员变量// 行为 --- 成员方法// 保护特征 --- 成员属性// 构造函数 + 析构函数// 索引器// 运算符重载// 静态成员
}

3.1、特征 — 成员变量

class Person
{public string name;protected int age;private bool sex;
}

3.2、行为 — 成员方法

class Person
{public void Speak(string word){Console.WriteLine(word);}private int OneYearPass(){return this.age++;} 
}

3.3、保护特征 — 成员属性

3.3.1、概念

• 保护成员变量，为成员变量的获取和赋值添加逻辑处理
• 解决访问修饰符的局限性，成员属性可以让成员变量在外部 只能获取不能修改 or只能修改不能获取
  • setter/getter

3.3.2、基本语法

• 属性名采用 帕斯卡命名法；就是大写首字母

访问修饰符 类型 属性名
{get{}set{}
}

• 常规 Demo
  • set 里有一个关键字 value 用于表示 入参

class Person
{// 成员变量private int money;// 成员属性public int Money{get{// 写一些逻辑保护成员变量...// money -= 5;return money;}set{// 写一些逻辑保护成员变量...// value += 5;// value 用于表示 入参money = value;}}
}

3.3.3、get 和 set 前可加访问修饰符

• 不加时默认使用属性声明时的访问修饰符
• 手动加访问修饰符要低于属性访问权限
• 不能 get 和 set 的访问修饰符都低于属性访问权限

class Person
{// 成员变量private int money;// 成员属性public int Money // 只能写不能读{private get // 不可读{return money;}set{money = value;}}
}

• get 和 set 可以只有一个

class Person
{// 成员变量private readonly int money;// 成员属性public int Money // 只读{get{return money;}}
}

• 自动属性（没有特殊处理时可以使用，可以简化一点代码）
  • 属性没有对应的成员变量，C#会自动维护一个它的成员变量

class Person
{// 自动属性(类里并没有 money 属性)public int Money{get{return money;}}
}

• Lambda写法

public int Money
{get => money;set => money = value
}

• 如果没有额外逻辑的话可以简写

public int Money{ set; get; }
//或者直接省略
public int Money;// Others
public int Money{ private set; get; }
public int Money{ set; private get; }
public int Money{ get { return money - 5; } }
public int Money{ set { money = value + 5; } }
public int Money{ get; }

3.4、构造函数

• 普普通通的构造函数

class Person
{public Person(string name, int age, bool sex){this.name = name;this.age = age;this.sex = sex;} 
}

• 构造函数的特殊写法（复用）：可以通过:this(参数列表) 重用构造函数

class Person
{public Person() { }public Person(string name):this() // 调了无参构造{this.name = name;}public Person(int age, bool sex){this.age = age;this.sex = sex;}public Person(string name, int age, bool sex): this(age, sex) // 调了上面的构造{this.name = name;}
}

3.5、析构函数

• 当引用类型的堆内存被回收时调用析构
• C# 有自动垃圾回收机制GC（学过java的小伙伴应该知道）
• 所以基本不会用这个函数，除非你就是想在这个类被清理之前做点特殊处理
• 游戏开发中更不会用到这个函数，了解即可
• 语法：~类名(){}

*垃圾回收机制：

• 垃圾回收，英文简写 GC ( Garbage Co1 lector)
• 垃圾回收的过程是在遍历堆 (Heap)上动态分配的所有对象，通过识别它们是否被引用来确定哪些对象是垃圾，哪些对象仍要被使用
• 所谓的垃圾就是没有被任何变量、对象引用的内容；垃圾就需要被回收释放
• 垃圾回收有很多种算法，比如：
  • 引用计数 ( Reference Counting)
  • 标记清除 ( Mark Sweep)
  • 标记整理 ( Mark Compact)
  • 复制集合 ( Copy Co1 lection)
• 注意:
  • GC只负责堆 (Heap)内存的垃圾回收
  • 引用类型都是存在堆 (Heap)中的，所以它的分配和释放都通过垃圾回收机制来管理
  • 栈 ( Stack)上的内存是由系统自动管理的
  • 值类型在栈( Stack)中分配内存的，他们有自己的生命周期，不用对他们进行管理，会自动分配和释放
• C#中内存回收机制的大概原理
  • 0代内存 1代内存 2代内存
  • 代的概念
    • 代是垃圾回收机制使用的一种算法 (分代算法)
    • 新分配的对象都会被配置在第 θ代内存 中
    • 每次分配都可能会进行垃圾回收以释放内存(0代内存满时)
  • 在一次内存回收过程开始时，垃圾回收器会认为堆中全是垃圾，会进行以下两步
    • 标记对象从根 ( 静态字段、方法参数 ) 开始检查引用对象，标记后为可达对象，未标记为不可达对象，不可达对象就认为是垃圾
    • 搬迁对象压缩堆 ( 挂起执行托管代码线程 ) ，释放未标记的对象，搬迁可达对象，修改引用地址
  • 大对象总被认为是第二代内存，目的是减少性能损耗，提高性能
  • 不会对大对象进行搬迁压缩，85080字节(83kb)以上的对象为大对象

3.6、索引器

3.6.1、基本概念

• 让对象可以像数组一样通过索引访问其中元素

3.6.2、语法

访问修饰符 返回类型 this[参数类型 参数名, 参数类型 参数名 ...]
{get{}set{}
}

3.6.3、使用

• 此set、get使用上和属性的set、get一样

class Person
{// 变量部分private Person[] friends;// 索引器public Person this[int index]{get { return friends[index]; }set { friends[index] = value; }}
}// 某方法内↓↓↓
Person p = new Person();
p[0] = new Person();
Console.WriteLine(p[0]);

3.6.4、索引器中可以写逻辑

• 正常上面的代码肯定会报空指针异常，补上一些逻辑补丁，让上面的代码可以正运行

class Person
{// 变量部分private Person[] friends;// 索引器public Person this[int index]{get { return friends[index >= 10 ? 9 : index]; }set { if (friends == null) {friends = new Person[10];}friends[index >= 10 ? 9 : index] = value; }}
}// 某方法内↓↓↓
Person p = new Person();
p[0] = new Person();
Console.WriteLine(p[0]);

3.6.5、索引器可以重载

• 上面的代码写个重载的demo

class Person
{// 变量部分private Person[] friends;// 索引器public Person this[int index, string key] // 随便定义，反正逻辑如何也是可以随便写{get { return friends[index]; }set {if (friends == null) {friends = new Person[10];}friends[index] = value; }}
}// 某方法内↓↓↓
Person p = new Person();
p[0, ""] = new Person();
Console.WriteLine(p[0, ""]);

3.7、运算符重载

3.7.1、概念

• 让自定义类/结构体能使用运算符
• 关键字 operator
• 特点
  • 一定是一个公共的静态方法
  • 返回类型写在 operator 前面
• 注意
  • 条件运算符需要成对实现
  • 一个符号可以多个重载
  • 不能使用 ref 和 out

3.7.2、语法

public static 返回类型 operator 运算符(参数列表)
{// ...
}

3.7.3、栗子

class Point
{public int x;public int y;public Point(int x, int y){this.x = x;this.y = y;}// + 重载 1public static Point operator +(Point p1, Point p2) {return new Point(p1.x + p2.x, p1.y + p2.y);}// + 重载 2public static Point operator +(Point p, int add) {return new Point(p.x + add, p.y + add);}// + 重载 3public static Point operator +(int add, Point p) {return p + add;}
}// 某方法内↓↓↓
Console.WriteLine(new Point(1, 2) + new Point(2, 3));

3.7.4、可重载运算符有哪些

• 算数运算符
• 逻辑运算符中的 !
• 位运算符
• 条件运算符
  • 条件运算符重载必须成对实现，例如重载了 < 就必须重载 >

3.8、静态成员

• 用 static 修饰的 成员变量、成员属性、方法等 就称为静态成员
• 直接用类名点出来使用
  • 静态成员从程序开始运行时就在静态内存区域分配空间，在第一次使用时会创建好唯一的一份，直到程序结束才会释放这部分空间
• 静态函数中不能使用非静态成员
• 非静态函数可以使用静态成员

*const 和 static 区别

• 常量可以理解为特殊的静态量
• 相同
  • 都可以类名直接点出来
• 不同
• const 必须初始化，不能修改，static 随意
• const 只能修饰变量，static 随意
• const 必须写在访问修饰符后面，static 随意

class Yuan
{// 静态成员变量public static float PI = 3.14159226f;// 普通成员变量public float r;// 静态成员方法public static float Area(float r) {return PI * r * r;}// 普通成员方法public float DemoFun(){return PI * r * r;}
}// 某方法内↓↓↓
Console.WriteLine(Yuan.PI); // 3.141592
Console.WriteLine(Yuan.Area(10f)); // 314.1592

3.9、静态类

• 用 static 修饰的 类
• 特点
  • 只能包含静态成员
  • 不能被实例化
• 作用
  • 将常用的静态成员写在静态类中，方便使用
  • 静态类不能被实例化，更能体现工具类的 唯一性
    • 比如 Console 就是一个静态类

3.10、静态构造函数

• 用 static 修饰的 构造函数
• 特点
  • 静态类和普通类都可以有
  • 不能使用访问修饰符
  • 不能有参数
  • 只会自动调用一次
• 作用
  • 在静态构造函数中初始化 静态变量

3.11、拓展方法

3.11.1、概念

• 为现有 非静态 变量类型 添加 新方法
• 作用
  • 提高程序拓展性
  • 不需要在对象中重写方法
  • 不需要继承来添加方法
  • 为别人封装的类型写额外方法
• 特点
  • 一定是写在静态类中
  • 一定是静态函数
  • 第一个参数为拓展目标
  • 第一个参数用this修饰
• 注意！！！
  • 如果拓展名和原有名重合，则拓展无效

3.11.2、语法

访问修饰符 static 返回类型 函数名(this 拓展类型 参数名, 参数类型 参数名， 参数类型 参数名 ...)
{// ...
}

3.11.3、栗子

// 拓展方法
static class Tools
{/// 
/// 为 int 拓展一个成员方法（实例化后才能使用）/// 
/// 使用该方法的实例对象/// 倍数public static void BaiDefineTime(this int value, int time) {Console.WriteLine("小白为 int 拓展的 SpeakValue 方法，当前值{0}的{1}倍为{2}", value,time, value * time);}
}// 某方法内↓↓↓
int i = 10;
i.BaiDefineTime();// "小白为 int 拓展的 SpeakValue 方法，当前值10的6倍为60"

3.12、内部类

• 在一个类中再声明一个类（比较鸡肋，平常基本不用，外部类更方便）
• 特点
  • 使用时要用包裹类点出自己
• 作用
  • 亲密关系的表现
• 注意
  • 访问修饰符作用巨大

class Person 
{public string name;public int age;public Body body;// 内部类public class Body {Arm leftArm;Arm rightArm;// 内部类class Arm{ // ...}}
}// 某方法内↓↓↓
Person p = new Person();
// 使用可访问的内部类
Person.Body body = new Person.Body();

3.13、分部类 和 分部方法

3.13.1、分部类

• 把一个类分成几部分来声明
• 关键字 partial
• 作用
  • 分部描述一个类
  • 增加程序拓展性
• 注意
  • 分部类可写在多个脚本中
  • 分部类的访问修饰符要一致
  • 分部类中不能有重复成员

partial class Person
{public string Name;
}partial class Person
{public int Age;public void Speak(){Console.WriteLine("我叫{0}，我今年{1}岁了", Name, Age);}
}// 某方法内↓↓↓
Person p = new Person();
p.Name = "666";
p.Age = 18;
p.Speak();// "我叫666，我今年18岁了"

3.13.2、分部方法

• 将方法的声明和实现分离（局限性大，了解即可）
• 特点
  • 不能加访问修饰符，默认私有
  • 只能在分部类中声明
  • 返回值只能是 void
  • 可以有参数，但不能用 out 关键字