C#学习笔记--面向对象三大特征
C#核心面向对象--封装
用程序来抽象现实世界，（万物皆对象）来编程实现功能。
三大特性：封装、继承、多态。
类与对象
声明位置：namespace中
样式：class 类名{}
命名：帕斯卡命名法（首字母大写）
实例化对象：根据类来新建一个对象。Person p=new Person();
成员变量
[*]声明在类语句块中
[*]用来描述对象的特征
[*]可以是任意变量类型
[*]数量不做限制
[*]是否赋值根据需求决定
enum E_SexType
{
Man,
Woman
}
struct Position{}//位置结构体
class Pet{}//宠物类
//类中的成员变量
class Person
{
public string name="TonyChang";//区别于结构体--可以默认赋初始值
public int age=21;
public E_SexType sex;
public Person bestFriend;//区别于结构体---类中可以有同类的成员类型（本质是因为类属于引用类型,但不可以实例化，防止反复new，陷入死循环）
public Position pos;
public Pet pet;
}成员类型的默认值：
值类型的：数字的为0，bool类型的false
引用类型：null
查看（int类型）默认值：default(int)
补充：class属于引用类型，其中的值类型也放置在堆中。
成员方法
[*]声明在类语句块中
[*]用来描述对象行为
[*]其返回值参数不做限制
[*]数量不做限制
[*]帕斯卡命名法（首字母大写）
成员方法只有在实例化之后才可以使用调用。具体的一个对象的行为（方法），必须具体的对象调用。
//成员方法
class Person
{
public string name;
public int age;
public void Speak()
{
Console.WriteLine("你好！");
}
}
//成员方法的使用
Person p=new Person;
p.Speak();构造函数和析构函数
默认有一个无参构造函数，而类中可以允许自己声明无参构造函数，而结构体不行。
一旦有自定义的构造函数，默认的无参构造函数则失效！
构造函数：
[*]public修饰
[*]无返回值，名字和类名相同
class Person
{
public string name;
public int age;
//构造函数
public Person()
{
name="TonyChang";
age=21;
}
//此时先调用age参数的构造函数 然后再调用两个参数的构造函数
public Person(string name,int age):this(age)
{
this.name=name;
this.age=age;
}
public Person(string name)
{
this.name=name;
}
public Person(int age)
{
this.age=age;
}
}特殊的构造函数，在调用该函数之前先调用this的无参构造函数。
public Person(int age):this()
{
this.age=age;
}
析构函数：
由于C#中有自动的垃圾回收机制，一般不使用析构函数。
析构函数是当垃圾真正被回收时候才会调用。
~Person(){}//析构函数
成员属性：
用于保护成员变量，为成员属性的获取和赋值添加逻辑处理。
//成员属性 帕斯卡命名法
class Person
{
private string name;
public string Name
{
get{
return name;
}
set{
name=value;
}
}
private int age;
public int Age
{
//不可以获得年龄（或者删除set设置则可表明也无法获取age）
private get=>age;
//可以设置年龄
set
{
age=value;
}
}
//额外：
//自动成员属性 （对于没有特殊需要的成员）
public float Height
{
get;
set;
}
}索引器
可以让对象像数组一样通过索引来访问其中的元素。
注意：结构体中也支持索引器。
//索引器
class Person
{
private string name;
private int age;
private Person[] friends;
private int[,] arry;
//索引器
public Person this
{
get
{
return friends;
}
set
{
//此处可以写一些控制逻辑
friends=value;
}
}
//索引器的重载
public int this
{
get
{
return array;
}
set
{
array=value;
}
}
}
//使用
Person p=new Person();
p=new Person();//可以像数组一样进行访问静态成员
static修饰的成员变量/方法为静态成员。
静态成员归属为类，即不用初始化就可以使用的类的成员。
静态成员函数中不可以使用非静态成员，非静态成员函数中可以使用静态成员函数。
本质：在程序运行开始时，检查到静态成员，会再特定的区域为其开辟内存空间来存储。所以说静态成员与程序共生死。因为生命周期不同，所以静态成员函数中不可以使用非静态成员。
使用：全局性，稳定不变的常量。例如固定的数值 Π，重力加速度g等包括固定的计算方法，可以供全局成员来访问使用。但是静态过多会占用内存，引发GC。
常量与静态成员
相同点：都可以通过类名点来使用
不同点：
[*]const 必须初始化，不能修改，而static可以
[*]const只能修饰变量，而static可以修饰很多
[*]const一定是写在访问修饰符的后面，static则无此要求
静态类与静态构造函数
用 static修饰的类为静态类，往往来作为工具类。例如System中的Console类。只能包含静态成员，不能实例化。
静态构造函数 ：在静态构造函数中初始化静态成员变量。
[*]静态类和普通类中均可以有
[*]不能使用访问修饰符
[*]不能有参数
[*]只会自动调用一次
//静态构造函数
static class Test
{
public static int testInt=100;
public static float testFloat=20.5f;
static Test()
{
//静态构造函数
Console.WriteLine("自动调用了！");
}
}
class NormalTest
{
public static int i=5;
//首次使用静态成员时候 自动调用一次
//静态成员函数
static NormalTest()
{
Console.WriteLine("静态构造函数");
}
public NormalTest()
{
Console.WriteLine("非静态成员函数");
}
}拓展方法
拓展方法为现有的非静态变量类型添加新方法。
作用：
[*]提升程序的拓展性
[*]不需要再对对象中重新写方法
[*]不需要继承来添加方法
[*]为别人封装的类型添加额外的方法
特点：
[*]一定写在静态类中
[*]一定是个静态函数
[*]第一个参数为拓展目标（为谁而拓展）
[*]第一个参数用this修饰
//拓展方法
static class expendTool
{
//为int添加拓展方法
public static void SpeakValue(this int value)
{
Console.WriteLine("这是int的拓展方法，int的数值为{0}",value);
}
//为string拓展方法
public static void SpeakStringInfo(this string str,string name,string info)
{
Console.WriteLine("这是string的拓展方法，string的数值为{0},该拓展方法由{1}编写，拓展内容为{2}",str,name,info);
}
}
class Program
{
static void Main(string[] args)
{
int i = 5;
i.SpeakValue();
string ss = "原始字符串";
ss.SpeakStringInfo("TonyChang", "附加字符串");
}
}注意：如果拓展方法名称与自身现有的方法名称相同，则只会调用自身的方法，不会调用拓展的方法。
运算符重载
关键字 operator
特点：1.一定是一个公共的静态成员方法
[*]返回值写在operator前
[*]逻辑处理自定义
作用：可以使自定义的数据类型来完成后相同意义的运算。
注意：
[*]条件运算符要成对实现（有>必须有1代>2代</p>
手动GC:
GC.Collect();
一般在场景加载时候进行GC。
面向对象--继承
继承者（子类）继承父类（基类、超类）的特性，同时也可以有自己独特的方法性质。
只能单继承。子类只能由一个父类。
继承特性：单根性、传递性。
//运算符重载
class Point
{
public int x;
public int y;
public Point(int x,int y)
{
this.x=x;
this.y=y;
}
//重载+运算符
//参数列表中必须要有自己的类别出现
public static Point operator +(Point p1,Point p2)
{
Point sum=new Point();
sum.x=p1.x+p2.x;
sum.y=p1.y+p2.y;
return sum;
}
}
class Program
{
static void Main(string[] args)
{
Point p1=new Point(1,1);
Point p2=new Point(2,2);
Point p3=P1+p2;
Console.WriteLine(p3.x);
}
}里氏替换原则
父类容器装在子类对象。（任何父类出现的地方，子类都可以替代）
//内部类
class Person
{
public class Body
{
class Arm
{
}
}
}
class Program
{
static void Main(string[] args)
{
Person.Body body=new Person.Body();
}
}
//分布类
//分布类可以分布在不同的脚本文件中
//分布类的访问修饰符要一致
partial class Student
{
public string name;
public bool sex;
partial void Speak();
}
partial class Student
{
public int age;
public string stuId;
partial void Speak()
{
Console.WriteLine("分布方法的具体实现");
}
}is和as
is是判断一个对象是否为指定类型对象，返回值为true则为真，不是则为false
as用来将一个对象转换为指定类型对象，返回值为指定类型对象，若转换失败则返回null
继承中的构造函数
子类构造函数调用之前，先执行父类的构造函数。（爷爷-->父亲-->子类）
所以要保证父类的构造函数（尤其为无参构造函数）
[*]保证父类的无参构造函数
[*]通过base调用指定的有参构造函数
//继承
//老师类
class Teacher
{
//姓名
public string name;
//职工号
protected int number;
//介绍名字
public void SpeakName()
{
number = 10;
Console.WriteLine(name);
}
}
//教学老师继承老师类
class TeachingTeacher : Teacher
{
//科目
public string subject;
//介绍科目
public void SpeakSubject()
{
number = 11;
Console.WriteLine(subject + "老师");
}
}
//语文老师继承教学老师类
class ChineseTeacher:TeachingTeacher
{
public void Skill()
{
Console.WriteLine("一行白鹭上青天");
}
}
class Program
{
static void Main(string[] args)
{
TeachingTeacher tt = new TeachingTeacher();
tt.name = "汪老师";
//tt.number = 1;
tt.SpeakName();
tt.subject = "Unity";
tt.SpeakSubject();
ChineseTeacher ct = new ChineseTeacher();
ct.name = "张老师";
//ct.number = 2;
ct.subject = "语文";
ct.SpeakName();
ct.SpeakSubject();
ct.Skill();
}
}万物之父--装箱和拆箱
object 是所有类型的基类，
作用：
[*]可以利用里氏替换原则，用父类装子类
[*]可以用来表示不确定类型，作为函数的参数类型
装箱：
用object存值类型。本该在栈中数值转移到堆上
拆箱
将object转换为值类型，将堆上的值类型转移到栈上（配合 is和as 使用）
优点：统一对象类型（里氏替换原则），方便对不同类型对象数值的管理
缺点：消耗性能，
class GameObject
{
}
class Player:GameObject
{
public void PlayerAtk()
{
Console.WriteLine("玩家攻击");
}
}
class Monster:GameObject
{
public void MonsterAtk()
{
Console.WriteLine("怪物攻击");
}
}
class Boss:GameObject
{
public void BossAtk()
{
Console.WriteLine("Boss攻击");
}
}
class Program
{
static void Main(string[] args)
{
//里氏替换原则
Gameobjet player=new Player();
Gameobjet monster=new Monster();
Gameobjet boss=new Boss();
//is 和 as
if(player is Player)
{
(player as Player).PlayerAtk();
}
}
}*密封类（了解）
使用sealed关键字修饰的类，不可以被派生。（结扎了！）
面向对象--多态
V: virtual(虚函数)
O: override(重写)
B: base(父类)
让继承同一父类的子类们在执行相同方法有不同的表现与状态。
就是说，继承是一脉相承父类的品质，而多态是由自己的个性，尽管做的和父辈的事情相同。
解决的问题：
//继承中的构造函数
class Father
{
//父类的无参构造函数很重要！
public Father()
{
}
public Father(int i)
{
Console.WriteLine("Father的有参构造");
}
}
class Son:Father
{
public Son(int i):base(i)
{
//构造函数
}
}使用多态来保证（继承类）一个类方法的独立性
//装箱拆箱
int i=5;
object obj=i;//装箱
i=(int)obj;//拆箱抽象类与抽象方法
抽象类不可以被实例化
abstract class Thing{
public string name;
}
抽象方法：没有方法体的纯虚方法，继承的子类必须实现纯虚方法。（子类必须重写该方法，子类的子类不必强制实行，但也可以继续重写。）
抽象方法与virtual（虚函数）方法区别：
[*]抽象方法只能在抽象类中出现，没有方法体，子类必须重写实现
[*]虚函数则有方法体，可在普通类中出现，由子类选择性的实现
class Father
{
public void SpeakName()
{
Console.WriteLine("Father的方法");
}
}
class Son:Father
{
public new void SpeakName()
{
Console.WriteLine("Son的方法");
}
}
class Program
{
static void Main(string[] args)
{
#region 解决的问题
Father f = new Son();
f.SpeakName();//调用的是父亲的方法
(f as Son).SpeakName();//调用的是儿子的方法
#endregion
}
}接口（重要）
概念：接口是行为的抽象规范
关键字：interface
声明规范：
[*]不能包含成员变量
[*]只能包含方法、属性、索引器、事件
[*]成员不能被实现
[*]成员可以不用写访问修饰符，默认为public，不能是private
[*]接口不能继承类，但是可以继承另一个接口
使用规范：
[*]类可以继承多个接口
[*]类继承接口，必须实现接口中所有成员
特点：
[*]和类的声明相似
[*]接口就是用来继承的
[*]接口不能被实例化，可以作为容器存储对象(里氏替换原则，父类装子类)
接口是抽象行为的”基类“
class GameObject
{
public string name;
public GameObject(string name)
{
this.name = name;
}
//虚函数 可以被子类重写
public virtual void Atk()
{
Console.WriteLine("游戏对象进行攻击");
}
}
class Player:GameObject
{
public Player(string name):base(name)
{
}
//重写虚函数
public override void Atk()
{
//base的作用
//代表父类 可以通过base来保留父类的行为
base.Atk();
Console.WriteLine("玩家对象进行攻击");
}
}接口的使用---类的继承
[*]一个类只能继承一个基类，但是可以继承多个接口
[*]继承接口之后，必须实现其中的内容
abstract class Fruits
{
public string name;
//抽象方法 是一定不能有函数体的
public abstract void Bad();
public virtual void Test()
{
//可以选择是否写逻辑
}
}
class Apple : Fruits
{
public override void Bad()
{
}
//虚方法是可以由我们子类选择性来实现的
//抽象方法必须要实现
}接口的使用---接口的继承
接口继承基类接口之后，不需要实现接口中的内容（抽象继承抽象，还是抽象）
等到最后类来具体实现
//接口的声明
//命名规范 I+帕斯卡命名法
interface IFly
{
void Fly();//方法
string Name//属性
{
get;
set;
}
int this//索引器
{
get;
set;
}
event Action doSomthing;//事件委托
}显示实现接口
//接口的使用
class Animal
{
}
class Person:Animal,IFly
{
//实现接口方法也可以加virtual来实现
public virtual void Fly()
{
}
public string Name
{
set;
get;
}
public int this
{
get
{
return 0;
}
set
{
}
}
public event Action doSomething;
}*密封方法（了解）
sealed 修饰的重写方法，子类不会被重写方法
其它关联知识点
命名空间namespace
[*]命名空间是个工具包，用来管理类
[*]不同命名空间中允许由同名类
[*]不同命名空间相互使用时，using引用命名空间 或者指明出处
[*]命名空间可以包裹命名空间
万物之父Object中的方法
string
[*]string 本质是char[]数组 可以有
string ss="Tony",char='T'
[*]字符串的拼接
[*]正向查找字符的位置IndexOf()
[*]反向查找字符串的位置LastIndexOf()
[*]移除指定位置后的字符 Remove（index）//注意接受返回值
[*]字符串的替换
[*]大小写转换
[*]字符串的截取
[*]字符串的切割 str.Split(',');按照，切割
StringBuilder
字符串频繁拼接使用StringBuilder，不会再次频繁的创建新的对象，减少垃圾产生。
容量问题：初始时候本身有一定容量，在容量允许范围内，直接存储。
超过容量之后，会以2倍大小扩容。相对于string每一次更改便会新建对象，可减少垃圾产生。
//接口继承接口
interface IWalk
{
void Walk();
}
interface IMove:IFly,IMove
{
}
//必须实现所有相关的
//继承来的抽象内容（接口，接口的父接口中的成员）
class Test:IMove
{
public int this {
get => throw new NotImplementedException();
set => throw new NotImplementedException();
}
public string Name {
get => throw new NotImplementedException();
set => throw new NotImplementedException();
}
public event Action doSomthing;
public void Fly()
{
throw new NotImplementedException();
}
public void Walk()
{
throw new NotImplementedException();
}
}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】 我们会及时删除侵权内容，谢谢合作！
页:
[1]