C#学习核心篇笔记

一、面向对象的概念

1、基本概念

面向对象是对现实世界理解和抽象的编程方法，把相关的数据和方法组织为一个整体来看待

二、面向对象——封装

1、类和对象

//声明类
    class A
    {
        //特征——成员变量
        int a;

        //行为——成员方法
        void Func()
        {
        }
        //保护特征——成员属性
        int B
        {
            set 
            {
                //在这里修改成员变量
             }
            get 
            { 
                //在这里得到成员变量
                return 0; 
            }          
        }
        //构造函数
        public A()
        {
        }
        //索引器
        //运算符重载
        //静态成员
    }
    //实例化 
    A a = new A();

2、成员变量和访问修饰符

(1)、成员变量

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

（2)、访问修饰符

public 公共的，自己内部和外部都可以访问和使用
private 私有的，只能自己内部可以访问和使用，不写访问修饰符，默认为private
protected 保护的，自己内部和子类才能访问和使用

3、成员方法

(1)、成员方法的声明

声明在类语句块中
是用来描述对象的行为
规则和函数声明规则相同
受到访问修饰符规则的影响
返回值参数不做限制
成员方法不要加static关键字

(2)、成员方法的使用

必须先实例化出对象，才能使用对象中的成员方法

4、构造函数和析构函数

(1)、构造函数

在实例化对象时 会调用的用于初始化的函数，如果不写，默认存在一个无参构造函数
写法：
没有返回值
函数名和类名必须相同
没有特殊需求时，一般是public的
构造函数可以被重载
this代表当前调用该函数的对象自己
自己写了有参构造，则默认的无参构造会失去

(2)、构造函数的特殊写法

可以通过this重用构造函数
访问修饰符 构造函数名（参数列表）：this(参数1，参数2……)

public A(int a )
{
}
public A(int a,int c) : this(a)
{
}

(3)、析构函数

当引用类型的堆内存被回收时，会调用该函数
对于需要手动管理内存的语言（如C++），需要在析构函数中做一些内存回收处理
C#中存在自动垃圾回收机制GC，所以一般很少用到析构函数

(4)、GC原理

5、成员属性

(1)、基本概念

用于保护成员变量
为成员属性的获取和赋值添加逻辑处理
解决public、private、protected的局限性
属性可以让成员变量在外部只能获取不能修改 或者 只能修改不能获取

(2)、成员属性的基本语法

访问修饰符	属性类型	属性名(一般用帕斯卡命名法，每个单词首个字母大写）
{
	set
	{
		//可以在设置之前添加一些逻辑
	}
	get
	{
		//可以在返回之前添加一些逻辑规则
		//意味着 这个属性可以获取的内容
	}
}

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

默认不加 会使用属性声明时的访问权限
加的访问修饰符要低于属性的访问权限
不能让get和set的访问权限都低于属性的权限
作用：
用于数据的加密解密

(4)、get和set可以只用一个

只有一个的时候就没有必要加访问修饰符
一般情况下 只会出现只有get的 基本不会出现只有set的

(5)、自动属性

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

public float Height
{
	get;
	set;
}

6、索引器

(1)、基本概念

让对象可以像数组一样通过索引访问其中元素，使程序看起来更直观、更容易编写

(2)、索引器语法

访问修饰符	返回值	this[参数类型 参数名，参数类型 参数名.....】
{
	内部得写法和属性相同
	set{]
	get{}
}
//例子
class Person
{
	private string name;
	private int age;
	private Person[] friends;
	//索引器
	public Person this[int index]
	{
		get
		{
			//可以写逻辑 根据需求来处理这里面的内容
			return friends[index];
		}
		set
		{
			//可以写逻辑 根据需求来处理这里面的内容
		}
	}
	//索引器可以重载
	public Person this[int i ,int j]
	{
		get{}
		set{]
	}
}
//索引器的使用
Person p=new Person();
p[0]=new Person();

7、静态成员

(1)、基本概念

静态关键字 static
用static修饰的 成员变量、方法、属性等
称为静态成员
静态成员的特点是：直接用类名点出使用

(2)、注意要点

写法：
static public float PI=11111
存储空间：
静态成员和程序同生共死，静态成员会有一个自己唯一的一个小房间，在任何地方使用都是用的小房间里面的内容，改变了它也是改变了小房间里的内容
静态函数中，不能使用非静态成员
非静态函数，可以使用静态成员
作用：
静态成员：常用唯一变量的声明 方便别人获取的对象声明
静态方法：常用的唯一方法声明 比如 相同规则的数学计算相关函数
常量和静态变量的区别
const（常量）可以理解为特殊的static（静态）
相同点：他们都可以通过类名点出使用
不同点：
const必须初始化，不能修改 static没有这个规则
const只能修饰变量 static可以修饰很多
const一定是写在访问修饰符后面的 static没有这个规则

8、静态类和静态构造函数

(1)、静态类

概念：
用static修饰的类
特点：
只能包含静态成员 不能实例化
作用：
将常用的静态成员写在静态类中，方便使用
静态类不能实例化，更能体现工具类的唯一性 Console就是一个静态类

(2)、静态构造函数

概念：
在构造函数上加static
特点：
静态类和普通类都可以用
不能使用访问修饰符
不能有参数
只会自动调用一次
作用：
在静态构造函数中初始化静态变量

9、扩展方法

(1)、基本概念

概念：
为现有的非静态 变量类型 添加新方法
作用：
提升程序拓展性
不需要在对象中重新写方法
不需要继承来添加方法
为别人封装的类型写额外的方法
特点：
一定是写在静态类中
一定是个静态函数
第一个参数为拓展目标
第一个参数用this修饰

(2)、基本语法

访问修饰符 static 返回值 函数名（this 扩展类名 参数名，参数类型 参数名，参数类型 参数名，…）
后面加粗的参数，才会成为扩展方法的参数

10、运算符重载

(1)、基本概念

概念：
让自定义类和结构体都能够使用运算符
使用关键字：
operator
特点：
一定是一个公共的静态方法
返回值写在operator前
逻辑处理自定义
注意：
条件运算符需要成对实现
一个符号可以多个重载
不能使用ref和out

(2)、基本语法

public static 返回类型 operator 运算符（参数列表）

(3)、实例

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

(4)、可重载和不可重载的运算符

可重载运算符：
算数运算符：+、-、*、/、% 、++、–
逻辑运算符：!
位运算符：|、&、^、~、<<、>>
条件运算符：>、<、>=、<=
不可重载运算符：
逻辑与逻辑或：&&、||
索引符：[]
强转运算符：()
特殊运算符： 点. 三目运算符？： 赋值符号=

11、内部类和分部类

（1）、内部类

概念：
在一个类中再声明一个类
特点：
使用时要用包裹着点出自己
作用：
亲密关系的变现
注意：
访问修饰符作用很大

（2）、分部类

概念：
把一个类分成几个部分声明
关键字：
partial
作用：
分部描述一个类
增加程序的扩展性
注意：
分部类可以写在多个脚本文件中
分部类的访问修饰符要一致
分部类不能有重复成员

（3）、分部方法

概念：
将方法的声明和实现分离
特点：
不能加访问修饰符 默认私有
只能在分部类中声明
返回值只能是void
可以有参数但不用 out关键字

三、面向对象——继承

1、继承的基本原则

（1）基本概念

特点：
1、单根性 子类只能有一个父类
2、传递性 子类可以间接继承父类的父类
3、子类会继承父类的所有特征和方法
基本语法：
class B:A
类B继承类A

（2）访问修饰符的影响

public 公共的，自己内部和外部都可以访问和使用
private 私有的，只能自己内部可以访问和使用，不写访问修饰符，默认为private
protected 保护的，自己内部和子类才能访问和使用
internal 内部的，只有在同一个程序集的文件中，内部类型或者是成员才可以访问

（3）子类和父类的同名成员

C#允许子类存在和父类同名的成员，但是不建议使用

2、里氏替换原则

（1）基本概念

任何父类出现的地方，子类都可以替代
父类容器装子类对象
作用：方便进行对象存储和管理

（2）基本实现

	class Father
    {

    }
    class Son : Father
    {

    }
    Father father = new Son();

（3）is和as

is：
判断一个对象是否为指定类对象
返回值：bool 是为真，不是为假
as：
将一个对象转换为指定类对象
返回值：指定类对象
成功返回指定类对象 失败返回null

3、继承中的构造函数

（1）基本概念

特点：
当声明一个子类对象时，先执行父类的构造函数、在执行子类的构造函数
注意：
父类的无参构造很重要
子类可以通过base关键字 代表父类 调用父类构造函数

（2）父类的无参构造很重要

子类实例化时，默认自动调用的是父类的无参构造，所以如果父类无参构造被顶掉 会报错
可以通过base调用指定父类构造

4、万物之父和装箱拆箱

（1）万物之父

关键字：
object
概念：
object是所有类型的基类，他是一个类（引用类型）
作用：
可以利用里式替换原则，用object容器装所有对象
可以用来表示不确定类型，作为函数参数类型

（2）装箱拆箱

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

5、密封类

（1）基本概念

作用：
让类无法再被继承
关键字：
sealed

四、面向对象——多态

1、Vob

（1）基本概念

让继承同一父类的子类们，在执行相同方法时有不同的表现

（2）实现

重载，也叫做编译时的多态
运行时的多态：vob、抽象函数、接口
virtual 虚函数
override 重写
base 父类（用于保留调用父类的函数）

2、抽象类和抽象方法

（1）抽象类

概念：
被抽象关键字abstract修饰的类
特点：
不能被实例化的类
可以包含抽象方法
继承抽象类，必须重写其抽象函数

（2）抽象函数

概念：
又叫纯虚方法，用抽象关键字abstract修饰的方法
特点：
只能在抽象类中声明
没有方法体
不能是私有的
继承后必须实现，用override重写

3、接口

（1）概念

接口时行为的抽象规范，是一种自定义类型
关键字：
interface
声明规范：
不包含成员变量
只包含方法、属性、索引器、事件
成员不能被实现
成员可以不用写访问修饰符，不能是私有的
接口不能继承类，但是可以继承另一个接口
使用规范：
类可以继承多个接口
类继承接口后，必须实现接口中所有成员
特点：
它和类的声明类似
接口是用来继承的
接口不能被实例化，但是可以作为容器存储对象

（2）实例

interface IFly
    {
        void Fly();
    }

    class Animal : IFly
    {
        public void Fly()
        {
            throw new NotImplementedException();
        }
    }

4、密封方法

（1）基本概念

用密封关键字sealed修饰的重写函数
作用：
让虚方法或者抽象方法之后不能在被重写
特点：
和override一起出现

五、面向对象关联知识点

1、命名空间

（1）基本概念

用来组织和重写代码的
作用：
就像是一个工具包，类就像是一件一件的工具，都是声明在命名空间中

（2）使用

//引用命名空间
    using Test;

    namespace Test
    {
        //类
    }

（3）一些注意点

不同命名空间允许有同名类
命名空间可以包裹命名空间

2、万物之父中的方法

（1）静态方法

Equls() 判断两个对象是否相等
ReferenceEquals() 比较两个对象是否相同的引用，主要用来比较引用类型的对象

（2）成员方法

GetType() 获取对象运行时的类型
MemberwiseClone() 拷贝并返回一个新的对象，新的对象的引用变量和老对象中一致

(3）虚方法

Equals() 用于引用类型的比较
GetHashCode() 获取对象的哈希码
ToString() 返回当前对象代表的字符串

3、String

（1）常用方法

//一、字符串指定位置获取
            string str = "你好啊";
            Console.WriteLine(str[1]);
            //转为char数组
            char[] chars = str.ToCharArray();

            //二、字符串拼接
            str = string.Format("{0}{1}", 1, 3333);

            //三、正向查找字符位置
            int index = str.IndexOf("好");

            //四、反向查找指定字符串位置
            index = str.LastIndexOf("n");

            //五、移除指定位置后的字符
            str.Remove(2);
            //从位置1开始，移除后面两个字符
            str.Remove(1, 2);

            //六、替换指定字符串
            str.Replace("你","我");

            //七、大小写替换
            str.ToUpper();
            str.ToLower();

            //八、字符串截取
            //从位置2开始，往后截取3个字符
            str.Substring(2,3);

            //九、字符串切割
            str.Split(',');

（2）注意点

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

4、Stringbuilder

（1）基础概念

C#提供的一个用于处理字符串的公共类
主要解决问题：
修改字符串而不创建新的对象，需要频繁修改和拼接的字符串可以使用它，可以提升性能
使用前需要引用命名空间

（2）使用

//1、初始化
            StringBuilder str = new StringBuilder("123456789");
            //容量
            Console.WriteLine(str.Capacity);
            //字符串长度
            Console.WriteLine(str.Length); 
            //增
            str.Append("555");
            str.AppendFormat("{0}{1}", 1111, 2222);
            //插
            str.Insert(1, "1111");
            //删
            str.Remove(1, 5);
            //清空
            str.Clear();
            //查
            Console.WriteLine(str[5]); 
            //改
            str[5] = 'a';
            //替换
            str.Replace("1", "555");

5、结构体和类的区别

（1）区别概述

结构体是值类型，存在栈上 ，不能继承和多态，无法使用protected访问修饰符
类是引用类型，存在堆上，可以继承和多态

（2）细节区别

结构体声明变量不能指定初始值 类可以
结构体不能声明无参的构造函数，类可以
结构体不能声明析构函数，类可以
结构体不能被静态static修饰，类可以
结构体不能再自己内部声明和自己一样的结构体变量，类可以
结构体需要在构造函数中初始化所有成员变量，类随意
结构体声明有参构造函数后，无参构造不会被顶掉

（3）结构体的特别之处

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

（4）如何选择结构体和类

需要继承和多态 直接选类
对象是数据集合 优先结构体
经常被赋值传递的对象，并且改变赋值对象时原对象不想跟着变化，就用结构体

6、抽象类和接口的区别

（1）抽象类和抽象方法

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

（2）接口

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

（3）相同点

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

（4）区别

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

（5）如何选择抽象类和接口

表示对象的用抽象类，表示行为拓展的用接口
不同对象拥有的共同行为，我们往往可以 用接口来实现

六、补充知识点

1、Uml类图

2、七大原则

（1）七大原则总体实现目标

高内聚、低耦合
使程序模块的可重用性，移植性增强

（2）七大原则具体内容

单一职责 类被修改的几率很大，因此应该专注于单一的功能
开闭原则 对扩展开发，对修改关闭
里氏替换原则 任何父类出现的地方，子类都可以替代
依赖倒转原则 要依赖于抽象，不要依赖于具体的实现
迪米特原则 一个对象应该对其他对象尽可能少的了解
接口分离原则 一个接口尽量只提供一个对外的功能
合成复用原则 尽量使用对象组合，而不是继承来达到复用的目的