C# 核心

面向对象编程概念

面向过程编程是一种以过程为中心的编程思想，分析出解决问题所需要的步骤，然后有函数把步骤一步一步实现，使用的时候一个一个依次调用。

面向对象是一种对现实世界理解和抽象的编程方法，把相关的数据和方法组织作为一个整体来看待。从更高的层次来进行程序开发，更贴近事物的自然运行模式。

面向对象优势：提高代码复用率，提高开发效率，提高程序可拓展性，清晰的逻辑关系。

如何学习面向对象？

面向对象关键知识：类

面向对象三大特性：继承+封装+多态

封装：用程序语言来形容对象。

继承：复用封装对象的代码；儿子继承父亲，复用现成代码。

多态：同样行为的不同表现，儿子继承父亲的基因但是又不同的行为表现。

面向对象七大原则：开闭原则、依赖倒转原则、里氏替换原则、单一职责原则、接口隔离原则、合成复用原则、迪米特法则。

面向对象——封装

类和对象

类申明在命名空间内

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

类的命名用帕斯卡命名法：每个首字母都大写。

注意：同一个语句块/命名空间中的不同类不能重名。

什么是（类）对象？

类的申明和类对象（变量）的申明是两个概念。

类的申明类似枚举和结构体的申明，相当于申明了一个自定义的变量类型。

而类对象是类创建出来的，相当于申明一个指定类的变量。

类创建对象的过程一般称为实例化对象

类对象都是引用类型的。

实例化对象的基本语法

//类名 变量名;
//类名 变量名 = null;(null代表空)
//类名 变量名 = new 类名();

前两种都是在栈上分配了内存，堆上没有分配内存。

第三种会在栈和堆都分配内存。

练习

1.A目前等于多少？

GameObject A = new GameObject();
GameObject B = A;
B = null;

答：A等于之前new的这个地址，不等于空。

2.A和B有什么关系？

GameObject A = new GameObject();
GameObject B = A;
B = new GameObject();

答：A和B没有关系，B已经new了一个新的Object。

成员变量和访问修饰符

成员变量基本规则：

1.声明在类语句块中
2.用来描述对象特征
3.可以是任意变量类型
4.数量不做限制
5.是否赋值由需求决定

如果要在类中声明一个和自己相同类型的成员变量时，不能对它实例化。

enum E_SexType
{ Man，Women，}
class Person
{
    string name;
    int age;
    Person girlfriend;//=null,但不能new Person（）；    
}

访问修饰符基本规则

public 自己和别人都能访问和使用

private 自己才能访问和使用，不写访问修饰符默认private

protected 自己和子类才能访问和使用

成员变量的使用和初始值

初始值

值类型来说数字类型默认值都是0 bool类型 false 引用类型 null

看默认值的小技巧：

Console.WriteLine(default(类型));

就会输出类型默认初始值。

使用

Person p=new Person();
p.age=10;
Console.WrtieLine(p.age);

成员方法

成员方法的声明

基本概念：成员方法（函数）用来表现对象行为。

注意：

1.成员方法不要加static关键字

2.成员方法必须实例化出对象，再通过对象来使用，相当于该对象执行了某个行为。

3.成员方法受到修饰符的影响。

class Person
{
    public string name;
    public int age;
    public Person[] friends;
    bool isAdult()
    {
        return age>=18;
    }
    public void Speak(String str)
    {
        isAdult();//私有函数只能在内部使用。
        Console.WriteLine("{0}说{1}",name,str);
    } 
    public void AddFriend(Person p)
    {
         if(friends == null)
         {
             friends=new Person[] {p};
         }
        else 
        {
             Person[] newFriends=new Person[friends.Length + 1];
            for(int i=0;i<friends.Length;i++)
            {
                newFriends[i]=friends[i];
            }
            newFriends[newFriends.Length - 1] = p;
            friends=newFriends;
        }
    }
}

在c#里面通常把变量放在前面，方法放在后面，c++相反，但通常都可以。

成员方法的使用

成员方法必须实例化出对象，再通过对象来使用，相当于该对象执行了某个行为。

class Program
{
    static void Main(strring[] args)
    {
        Console.WriteLine("成员方法");
        Person p = new Person();
        p.name = "唐老师";
        p.age = 18;
        p.Sreak("我爱你");
        //p.isAdult不可以调用，因为是私有函数
        
        Person p2 = new Person();
        p2.name = "火山哥";
        p2.age = 19;
        p.addFriend(p2);
        for(int i = 0;i < p.friends.Lengh;i++)
        {
            Console.WriteLine(p.friends[i].name);
        }
    }
}

输出：成员方法

唐老师说我爱你

火山哥

构造、析构、垃圾回收

构造函数

概念：在实例化对象时，会调用的用于初始化的和函数。

写法：没有返回值、函数名和类名相同、一般为public

class Person
{
    public string name;
    public int age;
    //类中允许自己申明无参构造函数，结构体时不允许的
    public Person()
    {
        name = "唐老师";
        age = 18;
    }
    public Person(int age)
    {
        //this代表当前调用该函数的对象自己
        this.age = age;
    }
    public Person(string name)
    {
        this.name = name;
    }
    public Person(int age,string name)
    {
        this.age = age;
        this.name = name;
    }
}

注意：如果不实现自己无参构造函数而实现了有参构造函数，会失去默认的无参构造（会报错）。

构造函数的特殊写法

可以通过this 重用构造函数代码

访问修饰符构造函数名（参数列表）：this（参数1，参数2）

public Person(int age,string name):this(age)
{
}

就能够先调用this括号参数那个的构造函数，能使代码复用。

析构函数

当对象被垃圾回收时调用的，主要是用来回收资源或者特殊处理内存的。

unity中基本用不到

垃圾回收机制

垃圾回收的过程是在遍历堆（Heap）上动态分配的所有对象。
通过识别它们是否被引用来确定哪些对象是垃圾，哪些对象仍要被使用。
垃圾就需要被回收释放。
注意：
垃圾回收值负责堆内存的垃圾回收
引用类型都是存在堆中，所以它分配和释放都通过垃圾回收机制来管理。
栈（Stack）上的内存是由系统自动管理的
值类型在栈中分配内存的，他们有自己的生命周期，不用对他们进行管理，会自动分配和释放。
C#中内存回收机制的大概原理

0代内存 1代内存 2代内存

代的概念：代是垃圾回收机制的一种算法（分代算法）。新分配的对象都会被配置在第0代内存中，每次分配都可能会进行垃圾回收以释放内存（0代内存满时）

在一次内存回收过程开始时，垃圾回收器会认为队中全是垃圾，回收垃圾以下两步：

1.标记对象从根（静态字段、方法参数）开始检查引用对象，标记后为可达对象，未标记为不可达对象，不可达对象就被认为是垃圾。
2.搬迁对象压缩堆（挂起执行托管代码线程）释放未标记的对象、搬迁可达对象、修改引用地址

大对象总被认为是第二代内存，目的是减少性能损耗，提高性能。

不会对大对象进行搬迁压缩，85000字节（83kb）以上的对象为大对象。

//手动触发垃圾回收的方法
//一般情况下，我们不会频繁调用（因为会造成卡顿）
//都是在Loading过场景时才调用
GC.Collect();

成员属性

基本概念：用于保护成员变量，为成员属性的获取和赋值添加逻辑处理，解决3P的局限性。

public——内外访问

private——内部访问

protected——内部和子类访问

属性可以让成员变量在外部

只能获取不能修改或者只能修改不能获取

基本语法：

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

class Person
{
    private string name;
    private int age;
    private int money;
    private bool sex;
    
    //属性命名一般用帕斯卡命名法
    public string Name
    {
         get
         {
             //可以在返回之前添加一些逻辑规则
             //意味着这个属性可以获取的内容
             return name;
         }
        set
        {
             //可以在设置之前添加一些逻辑规则
             //value 关键字用于表示外部传入的值
             name = value;
        }
    }
}

Person p = new Person();
p.Name="唐老师";
Console.WriteLine(p.name);

成员属性中 get和set前可以加访问修饰符

注意：1.默认不加，会使用属性声明是的访问权限

2.加的访问修饰符要低于属性的访问权限

3.不能让get和set的访问权限都低于属性的权限

get和set可以只有一个

只有一个就没必要加访问修饰符了

一般情况下只会出现只有 get 的情况（只获取不修改），基本不会出现只有 set（不会只改不能获取）

自动属性

作用：外部能得不能改的特征

如果类中有一个特征只希望外部能得不能改的又没什么特殊处理，那么可以直接使用自动属性。

public float Height
{
    //没有在get和set中写逻辑的需求或想法
    get;
    set;
}

不过没什么特殊需求就不要用属性了，直接写成员变量写的代码量更少一些。

索引器

基本概念：让对象可以像数组一样通过索引访问其中元素，是程序看起来更直观，更容易编写。

基本语法：

访问修饰符 返回值 this[参数类型 参数名，参数类型 参数名……]
{
    内部的写法和规则和成员属性相同
    get{}
    set{}
}

class Person
{
    private string name;
    private int age;
    private Person[] friends;
    private int[,] array;
    
    public int this[int i,int j]
    {
        get
        {
            return arraya[i,j];
        }
        set
        {
            array[i,j] = value;
        }
    }
    
    public string this[string str]
    {
        get
        {
           switch(str)
           {
               case "name":
                   return this.name;
               case "age":
                   return age.ToString;
           }
            return "";
        }
    }
    
    public Person this[int index]
    {
        get
        {
            //可以写逻辑 根据需求来处理这里的内容
            if(friends == null||friends.Length - 1 < index)
            {
                return null;
            }
            return friends[index];
        }
        set
        {
            //value代表传入的值
            //可以写逻辑 根据需求来处理这里的内容
            if(friends == null)
            {
                frienfds = new Person[]{value};
            }
            else if(index > friends.Length - 1)
            {
                //自己定了一个规则，如果索引越界，就默认把最后一个朋友顶掉。
                friends[friends.Length - 1] = value;
            }
            else
            {
                friends[index] = value;
            }
        }
    }
}

Person p = new Person();
p[0] = new Person();
Console.WriteLine(p[0]);
p[0,0] = 10;

静态成员

基本概念：用static修饰的成员变量、方法、属性等成为静态成员。

特点：直接用类名点出使用。

早已出现的静态成员：Console

自定义静态成员

class Test
{
    //静态成员变量
    static public float PI = 3.1415926;
    //成员变量
    public int testInt = 100;
    //静态成员方法
    public static float CalcCircle(float r)
    {
        //静态函数不能使用非静态成员
        //成员变量只能将对象实例化出来后，才能点出来使用，不能无中生有
        //不能直接使用非静态成员，否则会报错
        //这样的写法才可以
        Test t = new Test();
        Console.WriteLine(t.testInt);
        return PI*r*r;        
    }
    //成员方法
    public void TestFun()
    {
        //非静态函数可以使用静态成员
        Console.WriteLine(PI)；
        Console.WriteLine("123")；
    }
}

静态成员的使用

//静态成员
Console.WriteLine(Test.PI);
Console.WriteLine(Test.CalcCircle(2));
//普通成员
Test t = new Test();
Console.WriteLine(Test.testInt);
t.TestFun();

静态成员大多都是public，要在外面点出来使用

为什么可以直接点出来使用？

记住！程序不能无中生有！我们要使用的对象，变量，函数都是要在内存中分配内存空间的，之所以要实例化对象，目的就是分配内存空间，在程序中产生有个抽象的对象。

静态成员的特点程序开始运行时就会分配内存空间。所以我们就能直接使用。静态成员和程序共生共死。只要使用了它，直到使用了它，直到程序结束时内存空间才会被释放，所以静态成员就会有自己唯一的一个“内存小房间”，这让静态成员就有了唯一性，在任何地方使用都是用小房间的里的内容，改变了它也是改变了小房间里的内容。

静态成员的作用：1.常用唯一变量的声明 2.方便别人的获取的对象声明

静态方法：常用的唯一的方法声明，比如相同规则的数学计算相关函数。

静态过多会导致频繁GC，导致卡顿。

常量和静态变量

const可以理解为特殊的static

相同点：他们都可以通过类名点出来使用

不同点：

1.const必须初始化，不能修改，static没有这个规则

2.const只能修饰变量，static可以修饰很多

3.const一定时写在访问符后面的，static没有这个要求

静态类

概念：用static修饰的类

特点：只能包含静态成员，不能被实例化

作用：1.将常用的静态成员写在静态类中，方便使用

2.静态类不能被实例化，更能体现工具类的唯一性，比如Console就是一个静态类

static class TestStatic
{
    //静态成员变量
    public static int testIndex = 0;
    
    public static void Testfun()
    {
        
    }
    
    public static int TesyIndex
    {
        get;
        set;
    }
}

静态构造函数

概念：在构造函数加上static修饰

特点：

1.静态类和普通类都可以有

2.不能访问修饰符

3.不能有参数

4.只会自动调用一次

作用：在静态构造函数中初始化静态变量

使用

1.静态类中的静态构造函数

static class StaticClass
{
    public static int testInt1 = 100;
    public static int testInt2 = 100;
    
    static staticClass()
    {
        Console.WriteLine("静态构造函数");
    }
}

Console.WriteLine(StaticClass.testInt1);
Console.WriteLine(StaticClass.testInt2);

输出：静态构造函数

100

2.普通类中的静态构造函数

class Test
{
    public static int testInt = 200;
    static Test()
    {
        Console.WriteLine("静态构造");
    }
    public Test()
    {
        Console.WriteLine("普通构造");
    }
}

Console.Write(Test.testInt);
Test t = new Test();
Test t2 = new Test();

输出：

静态构造

200

普通构造

拓展方法

概念：为现有非静态变量类型添加新方法

作用：1.提升程序拓展性

2.不需要在对象中重新写方法

3.不需要继承来添加方法

4.为别人封装的类型写额外的方法

特点：1.一定是写在静态类中

2.一定是一个静态函数

3.第一个参数为拓展目标

4.第一个参数用this修饰

//基本语法
//访问修饰符 static 返回值 函数名（this 拓展名 参数名，参数类型 参数名，参数类型 参数名……）
static class Tools
{
    //为int拓展了一个成员方法
    //成员方法是需要实例化对象后才能使用的
    //value代表使用该方法的实例化对象
    public static void SpeakValue(this int value)
    {
        //拓展方法的逻辑
        Console.WriteLine("唐老师为int拓展的方法" + value);
    }
    public static void SpeakStringInfo(this string str,string str2,string str3)
    {
        Console.WriteLine("唐老师为string拓展的方法");
        Console.WriteLine("调用方法的对象" + str);
        Console.WriteLine("传的参数" + str2 + str3);
    }
}

int i = 10;
i.SpeakValue();    //为int拓展的方法
string str = "000";
str.SpeakStringInfo("唐老师","111");

输出：唐老师为int拓展的方法10

唐老师为string拓展的方法

调用方法的对象000

传的参数唐老师111

为自定义的类型拓展方法

class Test
{
    public int i = 10;
    public void Fun1()
    {
        Console.WriteLine("123");
    }
    public void Fun2()
    {
        Console.WriteLine("456");
    }
}
static class Tools
{
     public static void Fun3(this Test t)
     {
        Console.WriteLine("为test拓展的方法");
     }
}

Test t = new Test();
t.Fun3();

输出：为test拓展的方法

如果拓展方法和成员函数重名，会调用成员函数。

静态类是不能为静态类拓展方法的。

可以有返回值和拓展参数。

运算符重载

基本概念：让自定义的类和结构体能够使用运算符。使用关键字operator。

特点：1.一定是一个公共的静态方法

2.返回值写在operator前

3.逻辑处理自定义

作用：让自定义类和结构体对象可以进行运算

注意：1.条件运算符需要成对出现

2.一个符号可以多个重载

3.不能使用ref和out

//基本语法
//public static 返回类型 operator 运算符（参数列表）
class Point
{
    public int x;
    public int y;
    
    public static Point operator +(Point p1,Point p2)
    {
        Point p = new Point();
        p.x = p1.x + p2.x;
        p.y = p1.y + p2.y;
        return p;
    }
     public static Point operator +(Point p1,int value)
    {
        Point p = new Point();
        p.x = p1.x + value;
        p.y = p1.y + value;
        return p;
    }
     public static Point operator +(int value,Point p1)
    {
        Point p = new Point();
        p.x = p1.x + value;
        p.y = p1.y + value;
        return p;
    }
}

Point p1 = new Point();
Point p2 = new Point();
p1.x=1;p1.y=1;
p2.x=2;p2.y=2;
Point p3=p1+p2;

可重载的运算符：算数运算符逻辑运算符位运算符条件运算符

不可重载的运算符：逻辑与或（&& ||）索引符[ ] 强转运算符特殊运算符（点. 三目运算符？：赋值符号 =）

内部类和分布类

内部类

概念：在一个类中再声明一个类

特点：使用时要包裹者点出自己

作用：亲密关系的变现

注意：访问修饰符作用很大

class Person
{
    public int age;
    public string name;
    public Body body;
    public class Body
    {
        Arm leftArm;
        Arm rightArm;
        //不写public，外部调用不了的
        class Arm
        {
            
        }
    }
}

Person p = new Person();
Person.Body body = new Person.Body();

分部类

概念：把一个类分成几部分申明

关键字：partial

作用：分部描述一个类，增加程序的可拓展性

注意：分布类可以写在多个脚本文件中

分布类的访问修饰符要一致

分布类中不能有重复成员

partial class Student
{
    public bool sex;
    public string name;
}
partial class Student 
{
    public int number;
    public void Speak(string str)
    {
        
    }
}

分部方法

概念：将方法的申明和实现分离

特点：1.不能加访问修饰符默认私有

2.只能在分部类中申明

3.返回值只能是void

4.可以有参数但不用out关键字

partial class Student
{
    public bool sex;
    public string name;
    partial void Speak();
}
partial class Student 
{
    public int number;
    public void Speak(string str)
    { }
    partial void Speak()
    {
        //实现逻辑
        throw new NotImplementedException();
    }
}

挺鸡肋的hhhh

面向对象——继承

继承的基本规则

基本概念：一个类A继承一个类B，类A会继承类B的所有成员，A类将拥有B类的所有特征和行为

被继承的类B称为父类、基类、超类、

继承的类A称为子类、派生类。

子类可以有自己的特征和行为

特点：1.单根性：子类只能有一个父亲

2.传递性：子类可以间接继承父类的父类

class Teacher
{
    public string name;
    public int number
    public void SpeakName()
    {
        Console.WriteLine(name);
    }
}
class TeachingTeacher : Teacher
{
    public string subject;
    public void SpeakSubject()
    {
        Console.WriteLine(subject + "老师");
    }
}
class ChineseTeacher : TeachingTeacher
{
    public void Skill()
    {
        Console.WriteLine("一行白鹭上青天");
    }
}

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();

访问修饰符的影响

public - 公共内外部访问

private - 私有内部访问

protected - 保护内部和子类访问

之后讲命名空间的时候讲：internal - 内部的只有在同一个程序集的文件中，内部类型或者是成员才可以访问

子类和父类的同名成员

概念：C#中允许子类存在和父类同名的成员，但是极不建议使用。

里氏替换原则

里氏替换原则是面向对象七大原则中最重要的原则

概念：任何父类出现的地方，子类都可以替代

重点：语法表现-父类容器装着子类对象，因为子类对象包含了父类的所有内容

作用：方便进行对象的储存和管理

class GameObject
{}
class PlayerAtk:GameObject
{
    public void PlayerAtk()
    {
        Console.WriteLine(("玩家攻击"));
    }
}
class Monster:GameObject
{
    public void MonsterAtk()
    {
        Console.WriteLine("怪物攻击");
    }
}
class Boss:GameObject
{
    public void BossAtk()
    {
        Console.WriteLine("Boss攻击");
    }
}

//用父类容器装载子类对象
GameObject player = new Player();
GameObject monster = new Monster();
GameObject boss = new Boss();
GameObject[] objects = new GameObject[] {new Player(),new Monster(),new Boss()};
//无法调用player.PlayerAtk()

is和as

基本概念：

is：判断一个对象是否执行类对象

返回值：bool 是为真不是为假

as：将一个对象转换为指定类对象

返回值：指定类型对象

成功返回执行类型对象，失败返回null

//类对象 is 类名 该语句块 会有一个bool返回值 true和false
//类对象 as 类名 该语句块 会有一个对象返回值 对象和null
if(player is Player)
{
    Player p = player as Player
    p.PlayerAtk();
    //或者可以这么写
    //(player as Player).PlayerAtk();
}
for(int i = 0;i < objects.Length;i++)
{
    if(object[i] is Player)
    {
        (object[i] as Player).PlayerAtk();
    }
    else if(object[i] is Monster)
    {
        (object[i] as Monster).MonsterAtk();
    }
    else if(object[i] is Boss)
    {
        (object[i] as Boss).BossAtk();
    }
}

继承中的构造函数

基本概念：当申明一个子类对象时，先执行父类的构造函数，在执行子类的构造函数。

注意：1.父类的无参构造函数很重要

2.子类可以通过base关键字代表父类调用父类构造

class GameObject()
{
    public GameObject()
    {
        Console.WriteLine("GameObject的构造函数");
    }
}
class Player:GameObject
{
    public Player()
    {
        Console.WriteLine("Player的构造函数");
    }
}
class MainPlayer:Player
{
    public MainPlayer()
    {
        Console.WriteLine("MainPlayer的构造函数");
    }
}

MainPlayer mp = new MainPlayer();

输出：GameObject的构造函数

Player的构造函数

Mainplayer的构造函数

父类的无参构造

class Father
{
    //子类实例化时，默认自动调用的时父类的无参构造 所以如果父类无参构造被顶掉，会报错
    //public Father()
    //{       
    //}
    public Father(int i)
    {
        Console.WriteLine("Father的构造");
    }
}
class Son:Father
{
    //通过base调用指定父类构造
    public Son(int i) : base(1)
    {
        Console.WriteLine("Son的一个参数构造");
    }
    public Son(int i,string str):this(i)
    {
        Console.WriteLine("Son的两个参数构造");
    }
}

Son s = new Son(1,"123");

输出：Father的构造

Son的一个参数构造

Son的两个参数构造

万物之父

关键字：object

概念：object是所有类型的父类/基类，它是一个类（引用类型）

作用：1.可以利用里氏替换原则，用object容器装所有对象

2.可以用来表是不确定类型，作为函数参数类型

Father f = new Son();
if(f is son)
{
    (f as son).Speak();
}
//引用类型
object o = new Son();
Son s = new Son();
o = s;
o = f;
if(o is Son)
{
    (o as Son).Speak();
}
//值类型
object o2 = 1f;
//用强转
float f1 = (float)o2;
//特殊的string类型
object str = "123123";
string str2 = str.ToString();
//或者string str2 = str as string;
object arr = new int[10];
int[] ar = (int[])arr;
//或者int[] ar = arr as int[];
//看到引用类型都用as就好了

拆箱装箱

发生条件：用object存值类型（装箱），再把object转为值类型（拆箱）。

装箱：把值类型用引用类型存储，栈内存会迁移到堆内存中
拆箱：把引用类型储存的值类型取出来，堆内存会迁移到栈内存中
好处：不确定类型时可以方便参数的储存和传递
坏处：存在内存迁移。增加性能消耗

//装箱
object v = 3;
//拆箱
int intValue = (int)v;

static void TestFun( params object[] array)
{
    //里面的内容用is和as写各种操作就好了
}
//调用的时候就可以传任意的参数了
TestFun(1,2,3,4f,34.5,new Son());

尽量少用，因为装箱拆箱会造成性能消耗。也不是完全不能用。

密封类（不重要）

基本概念：密封类时使用sealed密封关键字修饰的类

作用：让类无法再被继承 “结扎”

sealed class Father
{
    
}
//会报错
class Son : Father
{
    
}

作用：在面向对象程序的设计中，密封类的主要作用就是不允许最底层子类被继承。可以保证程序的规范性和安全性。

目前来说用处不大，以后制作复杂系统或者程序框架时，便能慢慢体会到密封的作用。

意义：加强面向对象程序设计的规范性、结构性、安全性。

面向对象——多态

概念：多态按字面意思就是“多种状态”，让继承同一父类的子类们，在执行相同方法时有不同的表现（状态）。

主要目的：同一父类的对象，执行相同行为（方法）有不同的表现。

解决的问题：

让同一个对象有唯一行为的特征。

class Father
{
    public void SpeakName()
    {
        Console.WriteLine("Father的方法");
    }
}
class Son : Father
{
     public new void SpeakName()
    {
        Console.WriteLine("Son的方法");
    }
}

Father f = new Son();
f.SpeakName();
//会输出Father的方法
(f as Son).SpeakName();
//会输出Son的方法

这样写破坏了对象的唯一性。

多态的实现

我们目前学过的多态：编译时多态—— 函数重载，开始就写好的

我们将学习的多态：运行时的多态（vob、抽象函数、接口）

vob

v：virtual（虚函数）

o：override（重写）

b：base（父类）

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("玩家对象的攻击");
    }
}

GameObject p = new Player();
p.Atk();
//输出：游戏对象进行攻击
//玩家对象进行攻击

抽象类和抽象函数

抽象类

概念：被抽象关键字abstract修饰的类

特点：1.不能被实例化的类

2.可以包含抽象方法

3.继承抽象类必须重写其抽象方法

abstract class Thing
{
    //抽象类中 封装函数的所有知识点都可以在其中书写
    public string name;
    //可以在抽象类中写抽象函数
    
}
class Water : Thing
{
    
}
//不能Thing t = new Thing();
//但是可以用里氏替换原则
Thing t = new Water();

抽象函数

又叫纯虚方法，用abstract关键字修饰的方法

特点：1.只能在抽象类中申明

2.没有方法体

3.不能是私有的

4.继承后必须实现用override重写

abstract class Fruits)
{
    public string name;
    //抽象方法必须写访问修饰符，因为默认是private，而抽象方法必须在子类重写，所以一定要写public或者protected
    protected abstract void Bad();   //不用去实现
    public virtual void Test()
    {
        //可以选择是否写逻辑
    }
}
class Apple : Fruits
{
    //子类不重写的父类的抽象方法会报错
    public override void Bad()
    {
        
    }
    //子类可以不重写虚函数，不会报错
 class SuperApple:Apple
 {
     //子类的子类就不用必须重写抽象方法了
     //虚方法和抽象方法都可以被子类无线的去重写
     public override void Bad()
    {
        
    }
     public override void Test()
    {
        //可以选择是否写逻辑
    }
 }

}

如何选择普通类和抽象类？

不需要被实例化的对象，相对比较抽象的类可以使用抽象类

父类中的行为不太需要被实现的，只希望子类去定义具体的规则的，可以选择抽象类如何使用其中的抽象等等来定义规则

作用：整体框架设计时，会使用。让父类更安全

接口

概念：接口是行为的抽象规范，它也是一种自定义类型。

关键字：interface

接口申明的规范

1.不包含成员变量

2.只包含方法、属性、索引器、事件

3,成员不能被实现

4.成员可以不用写访问修饰符，不能是私有的

5.接口不能继承类，但可以继承另一个接口

接口的使用规范

1.类可以继承多个接口

2.类继承接口后，必须实现接口中所有成员

特点

1.它和类的申明类似

2.接口是用来继承的

3.接口不能被实例化，但是可以作为容器储存对象

接口的声明

interface IFly
{
    //默认public，不能是private
    void Fly();  //不需要写
    string Name
    {
        get;
        set;
    }
    int this[int index]
    {
        get;
        set;
    }
    //事件
    event Action doSomething;
}

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

接口命名规范：帕斯卡前面加个I

接口的使用

接口是用来继承的

1.类可以继承一个类，n个接口
2.继承了接口后，必须实现其中的内容，并且必须是public的
3.实现的接口函数，可以加v再在子类重写

class Animal
{}
class Person:Animal,IFly
{
    //必须加public，不能是protected
    public virtual void Fly()
    {
        //virtual虚函数，可以再被子类继承和重写
    }
    public string Name
    {
        get;
        set;
    }
    public int this[int index]
    {
        get
        {
            return 0;
        }
        set;
    }
    //事件
    public event Action doSomething;
}

//接口不能被实例化，但是可以用里氏替换原则
IFly f = new Person();

接口可以继承接口

接口继承接口时不需要实现

待类继承接口后类自己去实现所有内容

interface IWalk
{
    void Walk();
}
interface IMove:IFly,IWalk
{
    
}
//类中就得把接口全部实现
class Test:IMove
{
     public virtual void Fly()
    {
    }
    public string Name
    {
        get;
        set;
    }
    public int this[int index]
    {
        get
        {
            return 0;
        }
        set;
    }
    public event Action doSomething;
}

显示实现接口

当一个类继承两个接口，但是接口中存在着同名方法时，不能写访问修饰符

注意：显示实现接口时，不能写访问修饰符

interface IAtk
{
    void Atk();
}
interface ISuperAtk
{
    void Atk();
}
class Player:IAtk,ISuperAtk
{
    //显示实现接口 就是用 接口名.行为名
    void IAtk.Atk()
    {
        
    }
    void ISuperAtk.Atk()
    {
        
    }
    public void Atk()
    {
        
    }
}

Player p = new Player();
(p as IAtk).Atk();
(p as ISuperAtk).Atk();
p.Atk();

总结：

继承类：是对象间的继承，包括特征行为等等

继承接口：是行为间的继承，继承接口的行为规范，按照规范去实现内容

由于接口也是遵循里氏替换原则，可以用接口容器装对象。那么就可以实现装载各种毫无关系但却有相同行为的对象

注意：

1.接口值包含成员方法、属性、索引器、事件，并且都不实现，都没有访问修饰符
2.可以继承多个接口，但只能继承一个类
3.接口可以继承多个接口，相当于在进行行为合并，待子类继承时再去实现具体的行为
4.接口可以被显示继承，主要用于实现不同接口中的同名函数的不同实现
5.实现的接口方法，可以加virtual关键字，之后子类再重写

密封方法

基本概念：用密封关键字sealed修饰的重写函数

作用：让虚方法或者抽象方法之后不能再被重写

特点：和override

abstract class Animal
{
    public string name;
    public acstract void Eat();
    public virtual void Speak()
    {
        Console.WriteLine("叫");
    }
}
class Person:Animal
{
    //会报错，就不能写了
    //public sealed override void Eat()
    //{ }
    public override void Speak()
    {
        
    }
}
class WhitePerson:Person
{
    public override void Eat()
    {
        base.Eat();
    }
    public override void Speak()
    {
        base.Speak();
    }
}

面向对象关联知识点

命名空间

基本概念：命名空间是用来组织和重用代码的

作用：就像是一个工具包，类就像是一件一件的工具，都是申明在命名空间中的

基本语法：

namespace 命名空间名

{

类

}

namespace MyGame
{
    class GameObject
    {
        
    }
}
namespace MyGame
{
    class Player:GameObject
    {
        
    }
}
namespace MyGame2
{
    class GameObject
    {
        
    }
}

using MyGame;
using MyGame2;
//不同命名空间中相互使用，需要引用命名空间或指明出处
MyGame.GameObject g = new MyGame.GameObject();
MyGame2.GameObject g2 = new MyGame2.GameObject();

在不同的命名空间中可以有同名类。

如果有两个命名空间中有同名类，那么在使用的时候需要指明出处。

//命名空间可以包裹命名空间
namespace MyGame
{
    namespace UI
    {
        class Image
        {
            
        }
    }
    namespace Game
    {
        class Image
        {
            
        }
    }
}

using MyGame.UI;
MyGame.UI.Image a = new MyGame.UI.Image;

关于修饰类访问修饰符

public——命名空间中的类默认为public

internal——只能在该程序集中使用

abstract——抽象类

sealed——密封类

partical——分部类

万物之父中的方法

object中的静态方法

//静态方法 Equals 判断两个对象是否相等
//最终的判断权，交给左侧对象的Equals方法，
//不管值类型引用类型都会按照左侧对象Equals方法的规则来进行比较。
Console.WriteLine(Object.Equals(1,1));
//True
Test t1 = new  Test();
Test t2 = new  Test();
Test t3 = t1;
Console.WriteLine(Object.Equals(t1,t2));
//False
Console.WriteLine(Object.Equals(t1,t3));
//True

//静态方法 ReferenceEquals
//比较两个对象是否是相同的引用，主要是用来比较引用类型的对象。
//值类型对象返回值是指是false
Console.WriteLine(Object.ReferenceEquals(1,1));
//False
Console.WriteLine(Object.ReferenceEquals(t1,t2));
//False
Console.WriteLine(Object.ReferenceEquals(t1,t3));
//True

object中的成员方法

class Test
{
    public int i = 1;
    public Test2 t2 = new Test2();
    public Test Clone()
    {
        return MemberwiseClone() as Test;
    }
}
class Test2
{
    public int i = 2;
}

//普通方法GetType
//该方法在反射相关 知识点中是非常重要的方法，之后我们会具体的讲解这里返回的Type类型
//该方法的主要作用就是获取对象运行时的类型Type，
//通过Type结合反射相关知识点可以做很多关于对象的操作。
Test t = new Test();
Test type = t.GetType();

//普通方法MemberwiseClone
//该方法用于获取对象的浅拷贝对象，口语化的意思就是会返回一个新的对象
//但是新对象的引用变量会和老对象中一致。
Test t2 = t.Clone();
Console.WriteLine("克隆对象后");
Console.WriteLine("t.i = " + t.i); //1
Console.WriteLine("t.t2.i = " + t.t2.i); //2
Console.WriteLine("t2.i = " + t2.i); //1
Console.WriteLine("t2.t2.i = " + t2.t2.i); //2

t2.i = 20;
t2.t2.i = 21;
Console.WriteLine("改变克隆体信息后");
Console.WriteLine("t.i = " + t.i); //1
Console.WriteLine("t.t2.i = " + t.t2.i); //21
Console.WriteLine("t2.i = " + t2.i); //20
Console.WriteLine("t2.t2.i = " + t2.t2.i); //21

object中的虚方法

//虚方法Equals
//默认实现还是比较两者是否为同一个引用,即相当于ReferenceEquals
//但是微软在所有值类型的基类SysteValueType中重写了该方法,用来比较值相等。
//我们也可以重写该方法,定义自己的比较相等的规则

//虚方法GetHashCode
//该方法是获取对象的哈希码
// (一种通过算法算出的,表示对象的唯一编码,不同对象哈希码有可能一样,具体值根据哈希算法决定
//我们可以通过重写该函数来自己定义对象的哈希码算法,正常情况下,我们使用的极少,基本不用。

//虚方法Tostring
//该方法用于返回当前对象代表的字符串,我们可以重写它定义我们自己的对象转字符串
//该方法非常常用。当我们调用打印方法时,默认使用的就是对象的Tostring方法后打印

string

1.字符串指定位置获取

//字符串本质是char数组
string str = "唐老师";
Console.WriteLine(str[0]);
//转为char数组
char[] chars = str.ToCharArray();
Console.WriteLine(chars[1]);

for(int i = 0;i < str.Length; i++)
{
    Console.WriteLine(str[i]);
}

2.字符串拼接

str = string.Format("{0}{1}",1,3333);
Console.WriteLine(str);
//输出13333

3.正向查找字符串位置

str = "我是唐老师！";
int index = str.IndexOf("唐");
Console.Writeline(index); //输出2
//查找不到返回-1

4.反向查找指定字符串位置

str = "我是唐老师唐老师！";
int index = str.LastIndexOf("唐老师");
Console.Writeline(index); //输出5

5.移除指定位置后的字符

str = "我是唐老师唐老师！";
str.Remove(4);
Console.WriteLine(str); //还是输出我是唐老师唐老师！
str = str.Remove(4);
Console.WriteLine(str); //输出我是唐老

//执行两个参数进行移除
//参数1 开始位置
//参数2 字符个数
str = str.Remove(1,1); //输出我唐老

6.替换指定字符串

str = "我是唐老师唐老师！";
str = str.Replace("唐老师","老炮儿");
Console.WriteLine(str); //输出我是老炮儿老炮儿！

7.大小写转换

str = "fghdsjsjkdre";
str.ToUpper();
Console.WriteLine(str); //小写
str = str.ToUpper();
Console.WriteLine(str); //大写

str.ToLower();
Console.WriteLine(str); //大写
str = str.ToLower();
Console.WriteLine(str); //小写

8.字符串截取

str = "唐老师唐老师";
str = str.SubString(2);
Console.WriteLine(str); //输出师唐老师

//参数1 开始位置
//参数2 字符个数
//不会自动帮你判断是否越界，需要你自己判断越界
str = str.SubString(2，2);
Console.WriteLine(str); //输出老师

※9.字符串切割

str = "1,2,3,4,5,6,7,8";
string[] strs = str.Split(",");
for(int i = 0;i < str.Length; i++)
{
    Console.WriteLine(str[i]);
}
//输出 1 2 3 4 5 6 7 8

StringBuilder

string是特殊的引用，每次重新赋值或者拼接时会分配新的内存空间，如果一个字符串经常改变会非常浪费空间。

StringBuilder

C#提供的一个用于处理字符串的公共类

主要解决的问题是

修改字符串而不创建新的对象，需要频繁修改和拼接的字符串可以使用它，提升性能

使用前需要引用命名空间

//初始化
using System.Test
StringBuilder str = new StringBuilder("123123123");
Console.WriteLine(str);

//StringBuilder存在一个容量问题，每次往里面增加时，会自动扩容
//获取容量
Console.WriteLine(str.Capacity); //16
//获取字符常量
Console.WriteLine(str.Length); //9
//增删查改替换
//增
str.Append("4444");
Console.WriteLine(str);
Console.WriteLine(str.Capacity); //16
Console.WriteLine(str.Length);  //13

str.AppendFormat("{0}{1}",100,999);
Console.WriteLine(str); //1231234444100999
Console.WriteLine(str.Capacity); //32
Console.WriteLine(str.Length);  //19
//插入
str.Insert(0,"唐老狮");
Console.WriteLine(str); //唐老狮1231231234444100999

//删
str.Remove(0,10);
Console.WriteLine(str); //234444100999
//清空
//str.Clear();

//改
str[0] = 'A';
Console.WriteLine(str); //A34444100999
//替换
str.Replace("1","唐");
Console.WriteLine(str); //A34444唐00999

//重新赋值StringBuilder
str.Clear();
str.Append("123123");
Console.WriteLine(str); 
//判断StringBuilder是否和某一个字符串相等
if(str.Equals("12312"))
{
    Console.WriteLine("相等")
}

结构体和类的区别

区别概述：

结构体和类最大的区别时在存储空间上的，因为结构体是值，类是引用。

因此他们的存储位置一个在栈上，一个在堆上。

值和引用在赋值上的区别

结构体和类在使用上很类似，结构体甚至可以用面向对象的思想来形容一类对象。

结构体具备着面向对象思想中封装的特性，但是它不具备继承和多态的特性，因此大大减少了它的使用频率。

由于结构体不具备继承的特性，所以它不能使用protected保护访问修饰符

细节区别

1.结构体是值类型，类是由于类型。
2.结构体存在于栈中，类存在于堆中。
3.结构体成员不能使用protected访问修饰符，而类可以。
4.结构体成员变量申明不能指定初始值，而类可以。 //和c++区别，c++的结构体可以赋初值
5.结构体不能申明无参的构造函数，而类可以。
6.结构体申明有参构造函数后，无参构造不会被顶掉。
7.结构体不能申明析构函数，而类可以。
8.结构体不能被继承，而类可以。
9.结构体需要在构造函数中初始化所有成员变量，而类随意。
10.结构体不能被静态static修饰（不存在静态结构体），而类可以。
11.结构体不能再自己内部申明和自己语言的结构体变量，而类可以。

结构体的特别之处

结构体可以继承接口，因为接口时行为的抽象

如何选择结构体和类

1.想要使用继承和多态时，直接淘汰结构体，比如玩家、怪物等等
2.对象是数据集合是，优先考虑结构体，比如位置、坐标等等
3.从值类型和引用类型赋值时的区别上去考虑，比如经常被赋值传递的对象，并且改变赋值对象

抽象类和接口的区别

抽象类和抽象方法

abstract修饰的类和方法
抽象类不能被实例化
抽象方法只能在抽象类中申明是个纯虚方法，必须再子类中实现

接口

interface自定义类型
是行为的抽象
不包含成员变量
仅包含方法、属性、索引器、事件、成员都不能实现，建议不写访问修饰符，默认public

相同点

1.都可以被继承
2.都不能直接实例化
3.都可以包含方法申明
4.子类必须实现未实现的方法
5.都遵循里氏替换原则

区别

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

如何选择抽象类和接口

表示对象的用抽象类，表示行为拓展的用接口
不同对象拥有的共同行为，我们往往可以使用接口来实现
举个例子：动物是一类对象，我们自然会选择抽象类；而飞翔是一个行为，我们自然会选择接口。

posted @ 2021-09-29 09:30 tavee 阅读(129) 评论(0) 编辑收藏举报

刷新页面返回顶部

tavee

C# 核心

C# 核心

面向对象编程概念

面向对象——封装

类和对象

成员变量和访问修饰符

成员方法

构造、析构、垃圾回收

成员属性

索引器

静态成员

静态类

静态构造函数

拓展方法

运算符重载

内部类和分布类

面向对象——继承

继承的基本规则

里氏替换原则

继承中的构造函数

万物之父

拆箱装箱

密封类（不重要）

面向对象——多态

vob

抽象类和抽象函数

接口

密封方法

面向对象关联知识点

命名空间

万物之父中的方法

string

StringBuilder

结构体和类的区别

抽象类和接口的区别

公告