C#面向对象核心-封装

羽你同乐

封装

封装定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"，这个包就是类。在面向对象程序设计方法论中，封装可以防止对实现细节的访问。
1 类和对象

1.1 什么是类

具有相同特征、行为，是一类事物的抽象
类是对象的模板，通过类创建对象
1.2 类声明语法

1. //声明在namespace中
2. /*class 类名
3. {
4.     //成员变量 表示特征
5.     //成员方法 表示行为
6.     //成员属性 保护成员变量
7.     //构造函数和析构函数 初始化和释放
8.     //索引器 像数组一样使用
9.     //运算符重载 自定义对象可计算
10.     //静态成员 类名.点出成员使用
11. }*/
12. class Person
13. {
15. }

复制代码

1.3 类对象

类声明和类对象声明是两个概念：

• 类声明相当于定义了一个变量类型；
  
• 类对象声明相当于声明一个类的变量，这个过程称为实例化对象；
  
• 类对象是引用类型。
  

1. //类名 变量名；
2. //类名 变量名 = null;
3. //类名 变量名 = new 类名();
4. Person p1;
5. Person p2 = null;//空，不分配堆的内存空间
7. //p3 p4虽然来自一个类的实例化对象，但它们的特征行为等都是分别独有的，不会相互共享
8. Person p3 = new Person();
9. Person p4 = new Person();

复制代码

2 成员变量和访问修饰符

2.1 成员变量

声明在类语句块中，来描述对象的特征，可以是任意的变量类型，数量无限制，是否赋值根据需求确定

1. enum E_SexType
2. {
3.     Man,
4.     Woman,
5. }
7. struct Position
8. {
10. }
12. class Pet//宠物类
13. {
15. }
17. class Person
18. {
19.     //成员变量
20.     public string name;
21.     public int age;
22.     public E_SexType sex;
23.     //如果在类中声明和自己类型相同的成员变量时，不能对它实例化：Person grilFriend = new Person();
24.     public Person grilFriend;//女朋友 类可以用自己，但结构体不能，因为类在初始化时候才会分配内存，结构体则会一直死循环
25.     public Person[] friend;//朋友
26.     public Position pos;//位置
27.     public Pet pet = new Pet();//宠物
28. }

复制代码

2.2 访问修饰符

• public 公共的，自己（内部）和别人（外部）都能访问使用
  
• private 私有的，自己才能访问和使用，不写默认为私有
  
• protected 保护的，自己和子类才能访问使用
  
• internal 内部的，同一个程序集的对象可以访问，程序集就是命名空间
  

2.3 成员变量的使用和初始值

1. Person p = new Person();
2. /* 成员变量的使用和初始值
3. * 值类型、数字类型：默认为0
4. * bool类型：默认为false
5. * 引用类型：默认为null
6. * 用default(变量类型) 关键字可以看默认值
7. */
8. Console.WriteLine(default(bool));
9. p.age = 10;

复制代码

3 成员方法

3.1 成员方法声明

• 声明在类语句块中，来描述对象的行为
  
• 和函数声明规则相同，受访问限制符影响
  
• 不需要加static关键字
  

1. class Person
2. {
3.     public string name;
4.     public int age;
5.     public Person[] friends;
7.     //成员方法
8.     public void Speak(string str)
9.     {
10.         Console.WriteLine($"{name}说{str}");
11.     }
13.     public bool isAudlt()
14.     {
15.         return age >= 18;
16.     }
18.     public void AddFriend(Person p)//添加朋友
19.     {
20.         if (friends == null)
21.         {
22.             friends = new Person[] { p };
23.         }
24.         else
25.         {
26.             Person[] newFriends = new Person[friends.Length + 1];
27.             for(int i = 0; i < friends.Length; i++)//老朋友复制到新数组
28.             {
29.                 newFriends[i] = friends[i];
30.             }
31.             newFriends[newFriends.Length - 1] = p;//新加的朋友
32.             friends = newFriends;//地址重定向
33.         }
34.     }

复制代码

3.2 成员方法的使用

必须实例化对象，再通过对象来使用，相当于对象执行了某个行为

1. Person p =  new Person();
2. p.name = "abc";
3. p.age = 18;
4. p.Speak("123");
6. if (p.isAudlt()) p.Speak("我成年了");//使用
8. Person p2 = new Person();
9. p2.name = "def";
10. p2.age = 24;
12. p.AddFriend(p2);
14. foreach(Person f in p.friends)
15. {
16.     Console.WriteLine(f.name);
17. }

复制代码

4 构造函数、析构函数和垃圾回收

4.1 构造函数

• 用处：在实例化对象时，会调用的用于初始化的函数，如果没写，默认存在一个无参的构造函数
  
• 没有返回值，函数名和类名相同，访问权限一般都是public
  
• 如果实现了有参构造函数且没有写无参构造函数，那么默认的无参构造函数就没有了，实例化对象时只能有参实例化
  

1. class Person
2. {
3.     public string name;
4.     public int age;
6.     //类中允许无参构造函数，结构体中不行
7.     //无参构造函数
8.     public Person()
9.     {
10.         name = "tyy";
11.         age = 24;
12.     }
14.     //构造函数可以被重载，this代表当前调用该函数的对象本身
15.     public Person(string name, int age)
16.     {
17.         this.name = name;
18.         this.age = age;
19.     }
21.     //构造函数特殊写法：通过this 复用构造函数代码
22.     //访问修饰符 构造函数名（参数）：this（参数1，参数2...）。先调用this()里面的构造函数重载，再执行后面花括号内容
23.     //先调用this()里面的构造函数重载，再执行后面花括号内容
24.     public Person(string name):this()
25.     {
26.         Console.WriteLine("两个构造函数调用");
27.     }
28. }

复制代码

4.2 析构函数

• 与内存垃圾回收有关，C#有自动回收垃圾，几乎不用析构函数
  
• 析构函数只能在类中定义，不能用于结构体；
  
• 一个类中只能定义一个析构函数；
  
• 析构函数不能继承或重载；
  
• 析构函数没有返回值；
  
• 析构函数是自动调用的，不能手动调用；
  
• 析构函数不能使用访问权限修饰符修饰，也不能包含参数。
  

1. class Person
2. {
3.     public Person()
4.     {
5.         
6.     }
7.         ~Person()
8.     {
10.     }
11. }

复制代码

4.3 垃圾回收

• 垃圾就是内存中没有被任何变量、对象引用的内容；
  
• 垃圾回收（Garbage Collecyor  GC）就是遍历堆（Heap）上动态分配的所有对象，识别它们是否被引用来确定哪些对象是垃圾，哪些对象有用；
  
• GC只负责Heap内存的垃圾回收，引用类型都是存放在Heap中，因此它们的分配释放都通过GC来处理；
  
• 系统自动管理栈（Stack）内存的垃圾回收，值类型通过Stack分配内存，它们有自己的生命周期，自动分配释放；
  
• 垃圾回收算法：引用计数（Reference Counting）、标记清除（Mark Sweep）、标记整理（Mark Compact）、复制集合（Copy Collection）。
  

GC基本原理：

• 分代算法：把Heap内存分为 0代内存   1代内存    2代内存
  
• 新分配的对象存储在0代内存里，每次分配或（0 1 2代内存满）可能进行垃圾回收释放内存，执行下列两步：
  
• 1、标记对象：从根（静态字段、方法参数）开始检测引用对象，检测到的为可达对象，未检测到的为不可达对象（垃圾）
  
• 2、搬迁对象压缩堆：释放不可达对象，搬迁可达对象到下一代，修改它们的引用地址
  
• 1代内存满时会触发GC释放0 1代内存空间，2代满了0 1 2代内存都释放
  

1. //手动出发垃圾回收的方法，一般在Loading切换场景时才调用
2. GC.Collect();

复制代码

5 成员属性

• 用于保护成员变量；
  
• 为成员属性的获取和赋值添加逻辑处理；
  
• 解决3P（public、private、protected）的局限性；
  
• 成员属性可以设置成员变量在外部的权限为只能获取不能修改 或 只能修改不能获取。
  

5.1 成员属性的基本语法

1. /*
2. 访问修饰符 属性类型 属性名
3. {
4.     get{}   读，写了get就一定要有一个返回值
5.     set{}   写
6. }
7. */
9. class Person
10. {
11.     private string name;
12.     private int age;
13.     private int money;
14.     private bool sex;
16.     //属性的命名用帕斯卡命名法
17.     public string Name
18.     {
19.         get
20.         {
21.             //可以在返回之前添加一些逻辑条件
22.             return name;//虽然name是私有的，但是通过成员属性也能得到它
23.         }
24.         set
25.         {
26.             //可以在设置之前添加一些逻辑条件
27.             //value关键字表示外部传入的值
28.             name = value;
29.         }
30.     }
32.     public int Money
33.     {
34.         get
35.         {
36.             //解密处理
37.             return money - 5;
38.         }
39.         set
40.         {
41.             //可以进行额外的加密处理 起到安全和保密作用
42.             if(value < 0)
43.             {
44.                 value = 0;
45.                 Console.WriteLine("钱不能为负数");
46.             }
47.             money = value + 5;
48.         }
49.     }
50. }

复制代码

5.2 成员属性的使用

1. Person p = new Person();
2. p.Name = "abc";//执行set{}
3. Console.WriteLine(p.Name);//p.Name执行get{}
5. p.Money = 1000;
6. Console.WriteLine(p.Money);//外部看是1000元，但在内存里面是1005元 起到了加密的作用

复制代码

5.3 get和set的访问修饰符

• 默认会使用属性的访问修饰符；
  
• 如果要加，权限要低于属性的访问权限；
  
• 不能让get和set的权限都低于属性的权限，要满足 只读不写 或 只写不读，解决3P的局限性。
  

5.4 get和set可以只有一个

1. class Person
2. {
3.     private string name;
4.     private int age;
5.     private int money;
6.     private bool sex;
7.    
8.     public bool Sex
9.     {
10.         get { return sex; }//创造只读属性，private类型的成员也能读
11.     }
12. }

复制代码

5.5 自动属性

• 作用：外部只读不写的特征
  
• 如果类中有一个特征是只希望外部只读不写的，又没什么特殊处理，那么可以直接使用自动属性
  

1. class Person
2. {
3.     private string name;
4.     private int age;
5.     private int money;
6.     private bool sex;
7.    
8.     public float Height
9.     {
10.         get;
11.         private set;
12.     }
13. }

复制代码

6 索引器

• 索引器（Indexer） 允许一个对象可以像数组一样使用下标的方式来访问；
  
• 当为类定义一个索引器时，该类的行为就会像一个 虚拟数组（virtual array） 一样。可以使用数组访问运算符 [ ] 来访问该类的的成员。
  

6.1 基本语法

1. /*
2. element-type this[int index]
3. {
4.     // get 访问器
5.     get
6.     {
7.         // 返回 index 指定的值
8.     }
10.     // set 访问器
11.     set
12.     {
13.         // 设置 index 指定的值
14.     }
15. }
16. */
17. class Person
18. {
19.     private string name;
20.     private int age;
21.     private Person[] friends;
23.     public Person this[int index]
24.     {
25.         //可以写逻辑条件来处理
26.         get
27.         {
28.             if(friends == null || friends.Length - 1 < index)
29.             {
30.                 return null;
31.             }
32.             return friends[index];
33.         }
34.         set
35.         {
36.             //和成员属性类似，value代表传入的值
37.             if(friends == null)
38.             {
39.                 friends = new Person[] { value };
40.             }else if(index > friends.Length - 1)
41.             {
42.                 friends[friends.Length - 1] = value;//举例 如果索引越界就把最后一个朋友顶掉
43.             }
44.             else friends[index] = value;
45.         }
46.     }
47. }

复制代码

6.2 使用

1. Person p = new Person();
2. p[0] = new Person();//调用set 得到1个朋友
3. Console.WriteLine(p[0]);//调用get

复制代码

6.3 索引器重载

1. class Person
2. {
3.     public int[,] array;
4.    
5.     //函数名相同，但参数类型、个数或顺序不同
6.     public int this[int i, int j]
7.     {
8.         get
9.         {
10.             return array[i, j];
11.         }
12.         set
13.         {
14.             array[i, j] = value;
15.         }
16.     }
17. }

复制代码

7 静态成员

• 关键字 static
  
• 用static修饰的 成员变量、方法、属性等 称为静态成员
  
• 特点：直接用类名+点 使用，如Console.XX
  

7.1 自定义静态成员

1. class Test
2. {
3.     //静态成员变量
4.     public static float PI = 3.121592654f;
5.     //成员变量
6.     public int testInt = 100;
8.     //静态成员方法
9.     //静态方法不能使用非静态成员变量，与静态和非静态的生命周期有关
10.     public static float CalcCircle(float r)
11.     {
12.         //πr²
13.         return PI * r * r;
14.     }
16.     //普通成员方法
17.     //非静态方法可以使用静态成员变量
18.     public void testFun()
19.     {
20.         Console.WriteLine("123");
21.         Console.WriteLine(PI);
22.     }
23. }

复制代码

7.2 静态成员使用

1. Console.WriteLine(Test.PI);
2. Console.WriteLine(Test.CalcCircle(2));
4. //普通的只有new了对象之后才能使用那些变量方法等
5. Test t = new Test();
6. Console.WriteLine(t.testInt);
7. t.testFun();

复制代码

7.3 为什么能够不实例化对象直接使用

• 静态成员在程序开始运行时就会分配内存空间，和程序同生共死，只要使用了静态成员，直到程序结束了它的内存才会被释放；
  
• 每个静态成员在内存里都有唯一的一块空间，因此类中只有一个该静态成员的实例，在任何地方使用都是改变那一个。
  

7.4 常量const和静态变量static

相同点：都可以使用类名+点使用
不同点：

• const必须初始化且不能修改；
  
• const只修饰变量；
  
• const一定写在访问修饰符后面，static可前可后。
  

8 静态类和静态构造函数

8.1 静态类

用 static 修饰的类，只能包含静态成员，不能被实例化
作用：

• 将常用的静态成员写在静态类中，方便使用；
  
• 静态类不能被实例化，体现工具类的唯一性 如Console就是一个静态类，它写在命名空间System里面。
  

1. static class TestClass
2. {
3.     public static int testIndex = 0;
4.     public static void testFun()
5.     {
7.     }
8. }

复制代码

8.2 静态构造函数

• 在构造函数加上static修饰；
  
• 不能使用访问修饰符，不能有参数，只会自动调用一次；
  
• 作用：在静态构造函数中初始化静态变量。
  

8.2.1 静态类 中的 静态构造函数

1. static class StaticClass
2. {
3.     //第一次使用类时，类里面的静态成员自动调用一次
4.     public static int testInt = 100;
5.     public static int testInt2 = 100;
7.     static StaticClass()
8.     {
9.         Console.WriteLine("静态构造函数");
10.     }
11. }

复制代码

8.2.2 普通类 中的 静态构造函数

1. class Test
2. {
3.     public static int testInt = 200;
4.     static Test()
5.     {
6.         Console.WriteLine("静态构造");
7.     }
8.     public Test()
9.     {
10.         Console.WriteLine("普通构造");
11.     }
12. }

复制代码

8.3 使用

1. Console.WriteLine(StaticClass.testInt);
3. //第一次使用类时，类里面的静态成员自动调用一次
4. Console.WriteLine(Test.testInt);
5. //普通构造在new的时候调用
6. Test t = new Test();

复制代码

9 拓展方法

为现有 非静态 的  添加新方法
作用：

• 提升程序的拓展性；
  
• 不需要在对象中重写方法或通过继承来添加方法；
  
• 为别人封装的类型写额外的方法。
  

特点：

• 一定写在静态类中
  
• 一定是个静态函数
  
• 第一个参数为拓展目标
  
• 第一个参数用this修饰
  

9.1 基本语法

访问修饰符 static 返回值 函数名（this 要拓展的类名 参数名，参数类型 参数名，......）

1. static class Tools
2. {
3.     //为int拓展了一个成员方法，int里面是没有SpeakValue方法的
4.     //value 代表使用该方法的 实例化对象
5.     public static void SpeakValue(this int value)
6.     {
7.         //拓展方法的逻辑
8.         Console.WriteLine("为int拓展的方法" + value);
9.     }
11.     public static void SpeakStringInfo(this string str, string str2, string str3)
12.     {
13.         Console.WriteLine("为string拓展的方法，调用方法的对象是：" + str);
14.         Console.WriteLine("传的参数：" + str2 + str3);
15.     }
17.     //为自定义的类型Test拓展方法
18.     public static void Fun3(this Test t)
19.     {
20.         Console.WriteLine("为Test拓展的方法");
21.     }
22. }
24. class Test
25. {
26.     public int i = 10;
27.     public void Fun1()
28.     {
29.         Console.WriteLine("123");
30.     }
31.     public void Fun2()
32.     {
33.         Console.WriteLine("456");
34.     }
35. }

复制代码

9.2 使用

1. int i = 10;
2. i.SpeakValue();
4. string s = "ABC";
5. s.SpeakStringInfo("a ", "b");
7. Test t = new Test();
8. t.Fun3();

复制代码

10 运算符重载

10.1 基本概念

作用：让自定义的类和结构体能够使用运算符进行运算，关键字 operator
特点：

• 一定是一个公共的静态方法；
  
• 返回值写在operator前；
  
• 逻辑处理自定义。
  

注意：

• 条件运算符需要成对实现；
  
• 一个符号可以多个重载；
  
• 不能使用ref和out。
  

10.2 可重载和不可重载的运算符

注意：运算符需要两个参数还是一个参数
可重载的：
<ul>算数运算符：+ - * / % ++ --
逻辑运算符：！
位运算符：| & ^ ~ >
条件运算符：> < >=