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

c#,学习,笔记,面向对象,特征 · 浏览次数 : 46

小编点评

生成内容时需要带简单的排版，以便内容易于阅读和理解。以下是一些排版技巧： * 使用缩进：缩进字符串以使内容更易于阅读。 * 使用空格：使用空格使字符串更易于阅读。 * 使用格式：使用格式使字符串更易于阅读。 * 使用图片：使用图片使内容更易于阅读。 * 使用排版：使用排版使内容更易于阅读。 * 使用格式：使用格式使字符串更易于阅读。 * 使用标题：使用标题使内容更易于阅读。 * 使用列表：使用列表使内容更易于阅读。 * 使用表格：使用表格使内容更易于阅读。 * 使用排版：使用排版使内容更易于阅读。

正文

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[int index]
    {
        get
        {
            return friends[index];
        }
        set
        {
            //此处可以写一些控制逻辑
            friends[index]=value;
        }
    }
    //索引器的重载
    public int this[int i,int j]
    {
        get 
        {
            return array[i,j];
        }
        set
        {
            array[i,j]=value;
        }
    }
}
//使用
Person p=new Person();
p[0]=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前
逻辑处理自定义

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

注意：

条件运算符要成对实现（有>必须有<）
一个符号可以有多个重载
不能使用ref与out

//运算符重载
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("分布方法的具体实现");
    }
}

垃圾回收机制

垃圾回收，英文简称GC（Garbage Collector）

垃圾回收过程：遍历堆（Heap）上的动态分配的所有对象

通过识别它们是否被引用来确定其是否是垃圾。垃圾是指没有引用所指引的对象、变量，需要被回收释放掉占用的内存空间。

垃圾回收算法：

引用计数、标记清除、标记整理、复制集合。

注意：垃圾回收只回收heap堆上的栈中的内存由系统管理

回收机制： 三代内存

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

每一代内存满掉之后便会清理垃圾
高代连锁：1代清理会连带0代清理，2代清理连带0代和1代
清理完垃圾之后，非垃圾内容搬迁到下一代中（0代将非垃圾转移到1代内存，

1代内存将非垃圾转移到2代内存）所以2代内存存储的较为老的对象实例，还包括大的对象

一般是85kb以上的对象
0代1代的读取速度要高于1代，分配内存位置优先0代>1代>2代

手动GC:

GC.Collect();

一般在场景加载时候进行GC。

面向对象--继承

继承者（子类）继承父类（基类、超类）的特性，同时也可以有自己独特的方法性质。

只能单继承。子类只能由一个父类。

继承特性：单根性、传递性。

//继承
//老师类
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();
    }
}

里氏替换原则

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

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

is和as

is是判断一个对象是否为指定类型对象，返回值为true则为真，不是则为false

as用来将一个对象转换为指定类型对象，返回值为指定类型对象，若转换失败则返回null

继承中的构造函数

子类构造函数调用之前，先执行父类的构造函数。（爷爷-->父亲-->子类）

所以要保证父类的构造函数（尤其为无参构造函数）

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

//继承中的构造函数
class Father
{
    //父类的无参构造函数很重要！
    public Father()
    {
        
    }
    public Father(int i)
    {
        Console.WriteLine("Father的有参构造");
    }
}
class Son:Father
{
    public Son(int i):base(i)
    {
        //构造函数
    }
}

万物之父--装箱和拆箱

object 是所有类型的基类，

作用：

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

装箱：

用object存值类型。本该在栈中数值转移到堆上

拆箱

将object转换为值类型，将堆上的值类型转移到栈上（配合 is和as 使用）

优点：统一对象类型（里氏替换原则），方便对不同类型对象数值的管理

缺点：消耗性能，

//装箱拆箱
int i=5;
object obj=i;//装箱
i=(int)obj;//拆箱

*密封类（了解）

使用sealed关键字修饰的类，不可以被派生。（结扎了！）

面向对象--多态

V: virtual(虚函数)

O: override(重写)

B: base(父类)

让继承同一父类的子类们在执行相同方法有不同的表现与状态。

就是说，继承是一脉相承父类的品质，而多态是由自己的个性，尽管做的和父辈的事情相同。

解决的问题：

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
    }
}

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

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 Thing{

public string name;

}

抽象方法：没有方法体的纯虚方法，继承的子类必须实现纯虚方法。（子类必须重写该方法，子类的子类不必强制实行，但也可以继续重写。）

抽象方法与virtual（虚函数）方法区别：

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

abstract class Fruits
{
    public string name;

    //抽象方法 是一定不能有函数体的
    public abstract void Bad();

    public virtual void Test()
    {
        //可以选择是否写逻辑
    }
}
class Apple : Fruits
{
    public override void Bad()
    {

    }
    //虚方法是可以由我们子类选择性来实现的
    //抽象方法必须要实现
}

接口（重要）

概念：接口是行为的抽象规范

关键字：interface

声明规范：

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

使用规范：

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

特点：

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

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

//接口的声明
//命名规范 I+帕斯卡命名法
interface IFly
{
    void Fly();//方法
    string Name//属性
    {
        get;
        set;
    }
    int this[int index]//索引器
    {
        get;
        set;
    }
    event Action doSomthing;//事件委托
}

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

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

//接口的使用
class Animal
{
    
}
class Person:Animal,IFly
{
    //实现接口方法也可以加virtual来实现
    public virtual void Fly()
    {
        
    }
    public string Name
    {
        set;
        get;
    }
    public int this[int index]
    {
        get
        {
            return 0;
        }
        set
        {
            
        }
    }
    public event Action doSomething;
}

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

接口继承基类接口之后，不需要实现接口中的内容（抽象继承抽象，还是抽象）

等到最后类来具体实现

//接口继承接口
interface IWalk
{
    void Walk();
}
interface IMove:IFly,IMove
{
    
}
//必须实现所有相关的
//继承来的抽象内容（接口，接口的父接口中的成员）
class Test:IMove
{
    
       public int this[int index] { 
           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();
        }
}

显示实现接口

//接口的使用--当作容器 父类装子类
 interface IAtk
{
    void Atk();
}

interface ISuperAtk
{
    void Atk();
}
//显示实现接口
class Player : IAtk, ISuperAtk
{
    //遇到相同方法名字
    //显示实现接口 就是用 接口名.行为名 去实现
    void IAtk.Atk()
    {

    }

    void ISuperAtk.Atk()
    {

    }

    public void Atk()
    {

    }
}
class Progarm
{
    static void Main(string[] args)
    {
        IFly f = new Person();
		//里氏替换原则
        IMove im = new Test();
        IFly ifly = new Test();
        IWalk iw = new Test();

        IAtk ia = new Player();
        ISuperAtk isa = new Player();
        ia.Atk();
        isa.Atk();

        Player p = new Player();
        (p as IAtk).Atk();//IAtk的
        (p as ISuperAtk).Atk();//ISuperAtk的Atk
         p.Atk();//自己的Atk
    }
}

*密封方法（了解）

sealed 修饰的重写方法，子类不会被重写方法

其它关联知识点

命名空间`namespace`

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

万物之父Object中的方法

string

string 本质是char[]数组可以有

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

StringBuilder

字符串频繁拼接使用StringBuilder，不会再次频繁的创建新的对象，减少垃圾产生。

容量问题：初始时候本身有一定容量，在容量允许范围内，直接存储。

超过容量之后，会以2倍大小扩容。相对于string每一次更改便会新建对象，可减少垃圾产生。

//StringBuilder
StringBuilder str=new StringBuilder("My Name is Tony");
//获取容量
str.Capacity;
//增加
str.Append("Chang");
str.AppendFormat("{0}{1}",123,456);
//插入
str.Insert(0,"Hello");
//删除
str.Remove(0,10);
//清空
str.Clear();
//查
str[1];
//替换
str.Replace("Name"."name");
//重新赋值
str.Clear();
str.Append("Hello World");
//equals
if(str.Equals("123456"))
{
    
}

String 还是StringBuilder？

String的方法种类较多，使用更加方便和灵活，但性能上不如StringBuilder，不如StringBuilder产生垃圾少

需要频繁修改的字符串选用StringBuilder更好些。

如何优化内存？

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

结构体与类的区别

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

如何选择结构体和类：

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

抽象类与接口的区别

相同点：

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

区别：

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

如何选择抽象类与接口

表示对象的选用抽象类，表示行为拓展的用接口。不同对象的相同行为，我们可以抽象出行为，用接口来实现。

面向对象的七大原则

总目标：高内聚、低耦合

减少类内部对其它类的调用，减少模块与模块之间的交互复杂度。

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