C#学习笔记--面向对象三大特征

随风行

C#核心

面向对象--封装

用程序来抽象现实世界，（万物皆对象）来编程实现功能。
三大特性：封装、继承、多态。
类与对象

声明位置：namespace中
样式：class 类名{}
命名：帕斯卡命名法（首字母大写）
实例化对象：根据类来新建一个对象。Person p=new Person();
成员变量

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

1. enum E_SexType
2. {
3.     Man,
4.     Woman
5. }
6. struct Position{}//位置结构体
7. class Pet{}//宠物类
8. //类中的成员变量
9. class Person
10. {
11.     public string name="TonyChang";//区别于结构体--可以默认赋初始值
12.     public int age=21;
13.     public E_SexType sex;
14.     public Person bestFriend;//区别于结构体---类中可以有同类的成员类型（本质是因为类属于引用类型,但不可以实例化，防止反复new，陷入死循环）
15.     public Position pos;
16.     public Pet pet;
17. }

复制代码

成员类型的默认值：
值类型的：数字的为0，bool类型的false
引用类型：null
查看（int类型）默认值：default(int)
补充：class属于引用类型，其中的值类型也放置在堆中。
成员方法

• 声明在类语句块中
  
• 用来描述对象行为
  
• 其返回值参数不做限制
  
• 数量不做限制
  
• 帕斯卡命名法（首字母大写）
  

成员方法只有在实例化之后才可以使用调用。具体的一个对象的行为（方法），必须具体的对象调用。

1. //成员方法
2. class Person
3. {
4.     public string name;
5.     public int age;
6.     public void Speak()
7.     {
8.         Console.WriteLine("你好！");
9.     }   
10. }
12. //成员方法的使用
13. Person p=new Person;
14. p.Speak();

复制代码

构造函数和析构函数

默认有一个无参构造函数，而类中可以允许自己声明无参构造函数，而结构体不行。
一旦有自定义的构造函数，默认的无参构造函数则失效！
构造函数：

• public修饰
  
• 无返回值，名字和类名相同
  

1. class Person
2. {
3.     public string name;
4.     public int age;
5.     //构造函数
6.     public Person()
7.     {
8.         name="TonyChang";
9.         age=21;
10.     }
11.     //此时先调用age参数的构造函数 然后再调用两个参数的构造函数
12.     public Person(string name,int age):this(age)
13.     {
14.         this.name=name;
15.         this.age=age;
16.     }
17.     public Person(string name)
18.     {
19.        this.name=name;
20.     }
21.     public Person(int age)
22.     {
23.         this.age=age;
24.     }
25. }

复制代码

特殊的构造函数，在调用该函数之前先调用this的无参构造函数。
public Person(int age):this()
{
this.age=age;
}
析构函数：
由于C#中有自动的垃圾回收机制，一般不使用析构函数。
析构函数是当垃圾真正被回收时候才会调用。
~Person(){}//析构函数
成员属性：

用于保护成员变量，为成员属性的获取和赋值添加逻辑处理。

1. //成员属性 帕斯卡命名法
2. class Person
3. {
4.     private string name;
5.     public string Name
6.     {
7.         get{
8.             return name;
9.         }
10.         set{
11.             name=value;
12.         }
13.     }
14.     private int age;
15.     public int Age
16.     {
17.         //不可以获得年龄（或者删除set设置则可表明也无法获取age）
18.         private get=>age;
19.         //可以设置年龄
20.         set
21.         {
22.             age=value;
23.         }
24.     }
25.     //额外：
26.     //自动成员属性 （对于没有特殊需要的成员）
27.     public float Height
28.     {
29.         get;
30.         set;
31.     }
32. }

复制代码

索引器

可以让对象像数组一样通过索引来访问其中的元素。
注意：结构体中也支持索引器。

1. //索引器
2. class Person
3. {
4.     private string name;
5.     private int age;
6.     private Person[] friends;
7.     private int[,] arry;
8.     //索引器
9.     public Person this[int index]
10.     {
11.         get
12.         {
13.             return friends[index];
14.         }
15.         set
16.         {
17.             //此处可以写一些控制逻辑
18.             friends[index]=value;
19.         }
20.     }
21.     //索引器的重载
22.     public int this[int i,int j]
23.     {
24.         get
25.         {
26.             return array[i,j];
27.         }
28.         set
29.         {
30.             array[i,j]=value;
31.         }
32.     }
33. }
34. //使用
35. Person p=new Person();
36. p[0]=new Person();//可以像数组一样进行访问

复制代码

静态成员

static修饰的成员变量/方法为静态成员。
静态成员归属为类，即不用初始化就可以使用的类的成员。
静态成员函数中不可以使用非静态成员，非静态成员函数中可以使用静态成员函数。
本质：在程序运行开始时，检查到静态成员，会再特定的区域为其开辟内存空间来存储。所以说静态成员与程序共生死。因为生命周期不同，所以静态成员函数中不可以使用非静态成员。
使用：全局性，稳定不变的常量。例如固定的数值 Π，重力加速度g等包括固定的计算方法，可以供全局成员来访问使用。但是静态过多会占用内存，引发GC。
常量与静态成员

相同点：都可以通过类名点来使用
不同点：

• const 必须初始化，不能修改，而static可以
  
• const只能修饰变量，而static可以修饰很多
  
• const一定是写在访问修饰符的后面，static则无此要求
  

静态类与静态构造函数

用 static修饰的类为静态类，往往来作为工具类。例如System中的Console类。只能包含静态成员，不能实例化。
静态构造函数 ：在静态构造函数中初始化静态成员变量。

• 静态类和普通类中均可以有
  
• 不能使用访问修饰符
  
• 不能有参数
  
• 只会自动调用一次
  

1. //静态构造函数
2. static class Test
3. {
4.     public static int testInt=100;
5.     public static float testFloat=20.5f;
6.     static Test()
7.     {
8.         //静态构造函数
9.         Console.WriteLine("自动调用了！");
10.     }
11. }
12. class NormalTest
13. {
14.     public static int i=5;
15.     //首次使用静态成员时候 自动调用一次
16.     //静态成员函数
17.     static NormalTest()
18.     {
19.         Console.WriteLine("静态构造函数");
20.     }
21.     public NormalTest()
22.     {
23.         Console.WriteLine("非静态成员函数");
24.     }
25. }

复制代码

拓展方法

拓展方法为现有的非静态变量类型添加新方法。
作用：

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

特点：

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

1. //拓展方法
2. static class expendTool
3. {
4.     //为int添加拓展方法
5.     public static void SpeakValue(this int value)
6.     {
7.         Console.WriteLine("这是int的拓展方法，int的数值为{0}",value);
8.     }
9.     //为string拓展方法
10.     public static void SpeakStringInfo(this string str,string name,string info)
11.     {
12.          Console.WriteLine("这是string的拓展方法，string的数值为{0},该拓展方法由{1}编写，拓展内容为{2}",str,name,info);
13.     }
14. }
15. class Program
16. {
17.     static void Main(string[] args)
18.     {
19.         int i = 5;
20.         i.SpeakValue();
21.         string ss = "原始字符串";
22.         ss.SpeakStringInfo("TonyChang", "附加字符串");
23.     }
24. }

复制代码

注意：如果拓展方法名称与自身现有的方法名称相同，则只会调用自身的方法，不会调用拓展的方法。
运算符重载

关键字 operator
特点：1.  一定是一个公共的静态成员方法

• 返回值写在operator前
  
• 逻辑处理自定义
  

作用：可以使自定义的数据类型来完成后相同意义的运算。
注意：

• 条件运算符要成对实现（有>必须有1代>2代</p>
  

手动GC:
GC.Collect();
一般在场景加载时候进行GC。
面向对象--继承

继承者（子类）继承父类（基类、超类）的特性，同时也可以有自己独特的方法性质。
只能单继承。子类只能由一个父类。
继承特性：单根性、传递性。

1. //运算符重载
2. class Point
3. {
4.     public int x;
5.     public int y;
6.     public Point(int x,int y)
7.     {
8.         this.x=x;
9.         this.y=y;
10.     }
11.    
12.     //重载+运算符
13.     //参数列表中必须要有自己的类别出现
14.     public static Point operator +(Point p1,Point p2)
15.     {
16.         Point sum=new Point();
17.         sum.x=p1.x+p2.x;
18.         sum.y=p1.y+p2.y;
19.         return sum;
20.     }
21. }
22. class Program
23. {
24.     static void Main(string[] args)
25.     {
26.         Point p1=new Point(1,1);
27.         Point p2=new Point(2,2);
28.         Point p3=P1+p2;
29.         Console.WriteLine(p3.x);
30.     }
31. }

复制代码

里氏替换原则

父类容器装在子类对象。（任何父类出现的地方，子类都可以替代）

1. //内部类
2. class Person
3. {
4.     public class Body
5.     {
6.         class Arm
7.         {
8.             
9.         }
10.     }
11. }
12. class Program
13. {
14.     static void Main(string[] args)
15.     {
16.        Person.Body body=new Person.Body();
17.     }
18. }
19. //分布类
20. //分布类可以分布在不同的脚本文件中
21. //分布类的访问修饰符要一致
22. partial class Student
23. {
24.     public string name;
25.     public bool sex;
26.     partial void Speak();
27. }
28. partial class Student
29. {
30.     public int age;
31.     public string stuId;
32.     partial void Speak()
33.     {
34.         Console.WriteLine("分布方法的具体实现");
35.     }
36. }

复制代码

is和as

is是判断一个对象是否为指定类型对象，返回值为true则为真，不是则为false
as用来将一个对象转换为指定类型对象，返回值为指定类型对象，若转换失败则返回null
继承中的构造函数

子类构造函数调用之前，先执行父类的构造函数。（爷爷-->父亲-->子类）
所以要保证父类的构造函数（尤其为无参构造函数）

• 保证父类的无参构造函数
  
• 通过base调用指定的有参构造函数
  

1. //继承
2. //老师类
3. class Teacher
4. {
5.     //姓名
6.     public string name;
7.     //职工号
8.     protected int number;
9.     //介绍名字
10.     public void SpeakName()
11.     {
12.         number = 10;
13.         Console.WriteLine(name);
14.     }
15. }
16. //教学老师继承老师类
17. class TeachingTeacher : Teacher
18. {
19.     //科目
20.     public string subject;
21.     //介绍科目
22.     public void SpeakSubject()
23.     {
24.         number = 11;
25.         Console.WriteLine(subject + "老师");
26.     }
27. }
28. //语文老师继承教学老师类
29. class ChineseTeacher:TeachingTeacher
30. {
31.     public void Skill()
32.     {
33.         Console.WriteLine("一行白鹭上青天");
34.     }
35. }
36. class Program
37. {
38.     static void Main(string[] args)
39.     {
40.         TeachingTeacher tt = new TeachingTeacher();
41.         tt.name = "汪老师";
42.         //tt.number = 1;
43.         tt.SpeakName();
45.         tt.subject = "Unity";
46.         tt.SpeakSubject();
48.         ChineseTeacher ct = new ChineseTeacher();
49.         ct.name = "张老师";
50.         //ct.number = 2;
51.         ct.subject = "语文";
52.         ct.SpeakName();
53.         ct.SpeakSubject();
54.         ct.Skill();
55.     }
56. }

复制代码

万物之父--装箱和拆箱

object 是所有类型的基类，
作用：

• 可以利用里氏替换原则，用父类装子类
  
• 可以用来表示不确定类型，作为函数的参数类型
  

装箱：
用object存值类型。本该在栈中数值转移到堆上
拆箱
将object转换为值类型，将堆上的值类型转移到栈上（配合 is和as 使用）
优点：统一对象类型（里氏替换原则），方便对不同类型对象数值的管理
缺点：消耗性能，

1. class GameObject
2. {
4. }
5. class Player:GameObject
6. {
7.     public void PlayerAtk()
8.     {
9.         Console.WriteLine("玩家攻击");
10.     }
11. }
13. class Monster:GameObject
14. {
15.     public void MonsterAtk()
16.     {
17.         Console.WriteLine("怪物攻击");
18.     }
19. }
21. class Boss:GameObject
22. {
23.     public void BossAtk()
24.     {
25.         Console.WriteLine("Boss攻击");
26.     }
27. }
28. class Program
29. {
30.     static void Main(string[] args)
31.     {
32.         //里氏替换原则
33.         Gameobjet player=new Player();
34.         Gameobjet monster=new Monster();
35.         Gameobjet boss=new Boss();
36.         //is 和 as
37.         if(player is Player)
38.         {
39.             (player as Player).PlayerAtk();
40.         }
41.     }
42. }

复制代码

*密封类（了解）

使用sealed关键字修饰的类，不可以被派生。（结扎了！）
面向对象--多态

V: virtual(虚函数)
O: override(重写)
B: base(父类)
让继承同一父类的子类们在执行相同方法有不同的表现与状态。
就是说，继承是一脉相承父类的品质，而多态是由自己的个性，尽管做的和父辈的事情相同。
解决的问题：

1. //继承中的构造函数
2. class Father
3. {
4.     //父类的无参构造函数很重要！
5.     public Father()
6.     {
7.         
8.     }
9.     public Father(int i)
10.     {
11.         Console.WriteLine("Father的有参构造");
12.     }
13. }
14. class Son:Father
15. {
16.     public Son(int i):base(i)
17.     {
18.         //构造函数
19.     }
20. }

复制代码

使用多态来保证（继承类）一个类方法的独立性

1. //装箱拆箱
2. int i=5;
3. object obj=i;//装箱
4. i=(int)obj;//拆箱

复制代码

抽象类与抽象方法

抽象类不可以被实例化
abstract class Thing{
public string name;
}
抽象方法：没有方法体的纯虚方法，继承的子类必须实现纯虚方法。（子类必须重写该方法，子类的子类不必强制实行，但也可以继续重写。）
抽象方法与virtual（虚函数）方法区别：

• 抽象方法只能在抽象类中出现，没有方法体，子类必须重写实现
  
• 虚函数则有方法体，可在普通类中出现，由子类选择性的实现
  

1. class Father
2. {
3.     public void SpeakName()
4.     {
5.         Console.WriteLine("Father的方法");
6.     }
7. }
8. class Son:Father
9. {
10.     public new void SpeakName()
11.     {
12.         Console.WriteLine("Son的方法");
13.     }
14. }
15. class Program
16. {
17.     static void Main(string[] args)
18.     {
19.         #region 解决的问题
20.         Father f = new Son();
21.         f.SpeakName();//调用的是父亲的方法
22.         (f as Son).SpeakName();//调用的是儿子的方法
23.         #endregion
24.     }
25. }

复制代码

接口（重要）

概念：接口是行为的抽象规范
关键字：interface
声明规范：

• 不能包含成员变量
  
• 只能包含方法、属性、索引器、事件
  
• 成员不能被实现
  
• 成员可以不用写访问修饰符，默认为public，不能是private
  
• 接口不能继承类，但是可以继承另一个接口
  

使用规范：

• 类可以继承多个接口
  
• 类继承接口，必须实现接口中所有成员
  

特点：

• 和类的声明相似
  
• 接口就是用来继承的
  
• 接口不能被实例化，可以作为容器存储对象(里氏替换原则，父类装子类)
  

接口是抽象行为的”基类“

1. class GameObject
2. {
3.     public string name;
4.     public GameObject(string name)
5.     {
6.         this.name = name;
7.     }
9.     //虚函数 可以被子类重写
10.     public virtual void Atk()
11.     {
12.         Console.WriteLine("游戏对象进行攻击");
13.     }
14. }
16. class Player:GameObject
17. {
18.     public Player(string name):base(name)
19.     {
21.     }
23.     //重写虚函数
24.     public override void Atk()
25.     {
26.         //base的作用
27.         //代表父类 可以通过base来保留父类的行为
28.         base.Atk();
29.         Console.WriteLine("玩家对象进行攻击");
30.     }
31. }

复制代码

接口的使用---类的继承

• 一个类只能继承一个基类，但是可以继承多个接口
  
• 继承接口之后，必须实现其中的内容
  

1. abstract class Fruits
2. {
3.     public string name;
5.     //抽象方法 是一定不能有函数体的
6.     public abstract void Bad();
8.     public virtual void Test()
9.     {
10.         //可以选择是否写逻辑
11.     }
12. }
13. class Apple : Fruits
14. {
15.     public override void Bad()
16.     {
18.     }
19.     //虚方法是可以由我们子类选择性来实现的
20.     //抽象方法必须要实现
21. }

复制代码

接口的使用---接口的继承
接口继承基类接口之后，不需要实现接口中的内容（抽象继承抽象，还是抽象）
等到最后类来具体实现

1. //接口的声明
2. //命名规范 I+帕斯卡命名法
3. interface IFly
4. {
5.     void Fly();//方法
6.     string Name//属性
7.     {
8.         get;
9.         set;
10.     }
11.     int this[int index]//索引器
12.     {
13.         get;
14.         set;
15.     }
16.     event Action doSomthing;//事件委托
17. }

复制代码

显示实现接口

1. //接口的使用
2. class Animal
3. {
4.    
5. }
6. class Person:Animal,IFly
7. {
8.     //实现接口方法也可以加virtual来实现
9.     public virtual void Fly()
10.     {
11.         
12.     }
13.     public string Name
14.     {
15.         set;
16.         get;
17.     }
18.     public int this[int index]
19.     {
20.         get
21.         {
22.             return 0;
23.         }
24.         set
25.         {
26.             
27.         }
28.     }
29.     public event Action doSomething;
30. }

复制代码

*密封方法（了解）
sealed 修饰的重写方法，子类不会被重写方法
其它关联知识点

命名空间namespace

• 命名空间是个工具包，用来管理类
  
• 不同命名空间中允许由同名类
  
• 不同命名空间相互使用时，using引用命名空间 或者指明出处
  
• 命名空间可以包裹命名空间
  

万物之父Object中的方法

string

• string 本质是char[]数组 可以有
  string ss="Tony",char[0]='T'
  
• 字符串的拼接
  
• 正向查找字符的位置  IndexOf()
  
• 反向查找字符串的位置  LastIndexOf()
  
• 移除指定位置后的字符 Remove（index）//注意接受返回值
  
• 字符串的替换
  
• 大小写转换
  
• 字符串的截取
  
• 字符串的切割 str.Split(',');按照，切割
  

StringBuilder

字符串频繁拼接使用StringBuilder，不会再次频繁的创建新的对象，减少垃圾产生。
容量问题：初始时候本身有一定容量，在容量允许范围内，直接存储。
超过容量之后，会以2倍大小扩容。相对于string每一次更改便会新建对象，可减少垃圾产生。

1. //接口继承接口
2. interface IWalk
3. {
4.     void Walk();
5. }
6. interface IMove:IFly,IMove
7. {
8.    
9. }
10. //必须实现所有相关的
11. //继承来的抽象内容（接口，接口的父接口中的成员）
12. class Test:IMove
13. {
14.    
15.        public int this[int index] {
16.            get => throw new NotImplementedException();
17.            set => throw new NotImplementedException();
18.        }
20.         public string Name {
21.             get => throw new NotImplementedException();
22.             set => throw new NotImplementedException();
23.         }
25.         public event Action doSomthing;
27.         public void Fly()
28.         {
29.             throw new NotImplementedException();
30.         }
32.         public void Walk()
33.         {
34.             throw new NotImplementedException();
35.         }
36. }

复制代码

String 还是StringBuilder？
String的方法种类较多，使用更加方便和灵活，但性能上不如StringBuilder，不如StringBuilder产生垃圾少
需要频繁修改的字符串选用StringBuilder更好些。
如何优化内存？

• 节约内存
  
  
  • 少new对象 少产生垃圾
    
  • 合理使用static
    
  • 合理使用String与StringBuilder
    
  
  
• 减少GC产生
  

结构体与类的区别

• 存储位置 结构体是值类型，存储在栈中 类是引用类型，存储在堆中
  
• 结构体中的成员变量不可以赋初始值，类中可以
  
• 结构体具备封装特性但是不具备继承和多态 而类都具有
  
• 结构体不具备继承特性，所以不可以使用protected保护修饰符修饰
  
• 结构体声明有参构造之后，无参构造不会被顶掉
  
• 结构体不能声明析构函数，而类可以
  
• 结构体需要在构造函数中初始化所有成员变量，而类随意
  
• 结构体不能被static修饰，不存在静态的结构体，而类随意
  
• 结构体不能在内部声明与自己一样的结构体变量（会无限创建...栈溢出），类可以（因为是引用）
  
• 结构体可以继承接口（不可以继承类、结构体）
  

如何选择结构体和类：

• 如果想要用继承和多态时，直接淘汰结构体，如玩家、怪物
  
• 存储的对象是数据的集合时候，优先考虑结构体，如向量、坐标等
  
• 从本质上考虑，如果经常要改变赋值对象，原有的数值不想跟着改变的，选用结构体（值类型，复制拷贝，不影响本身），如坐标、向量、旋转角等
  

抽象类与接口的区别

相同点：

• 都可以被继承
  
• 都不可以直接实例化
  
• 都可以包含方法的声明
  
• 子类必须实现未实现的方法
  
• 都遵循里氏替换原则（父类装子类）
  

区别：

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

如何选择抽象类与接口
表示对象的选用抽象类，表示行为拓展的用接口。不同对象的相同行为，我们可以抽象出行为，用接口来实现。
面向对象的七大原则

总目标：高内聚、低耦合
减少类内部对其它类的调用，减少模块与模块之间的交互复杂度。

• 单一职责原则（一个类专注于一个功能）
  
• 里氏替换原则（父类可以装子类）
  
• 开闭原则（对拓展开放，对修改关闭，要保持开放和扩展，减少修改）
  
• 依赖倒转原则（依赖于抽象，不依赖于抽象具体）
  
• 迪米特原则（最少知识原则，不要和陌生人说话）
  
• 接口隔离原则（一个接口不应该提供过多的功能，）
  
• 合成复用原则（尽量使用组合复用实现功能，减少继承高耦合行为）
  

来源:https://www.cnblogs.com/TonyCode/archive/2023/10/12/17759266.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！