C#学习笔记 面试提要

冒泡

 for (int m = 0; m < arr.Length; m++)

 {

     for (int n = 0; n < arr.Length - 1 - m; n++)

     {

         if (arr[n] > arr[n+1])

         {

             int temp = arr[n];

             arr[n] = arr[n + 1];

             arr[n+1] = temp;

         }

     }

 }

选择

for (int m = 0; m < arr.Length; m++)

{

    int index = 0;

    for (int n = 1; n < arr.Length - m; n++)

    {

        if (arr[index] < arr[n])

        {

            index = n;

        }

    }

    if (index != arr.Length - 1 - m)

    {

        int temp = arr[index];

        arr[index] = arr[arr.Length - 1 - m];

        arr[arr.Length - 1 - m] = temp;

    }

}

委托是函数的容器

是用来传递函数的方法

Action是可以传n个参数的委托  1-16个参数

Func是可以穿n个参数 并且有返回值的委托 1-16个参数

命名空间 工具包

类 工具

函数 工具能做的事情

#region 折叠代码

#endregion

有符号的整形变量  能存储一定范围内的正负数 包括0的变量类型

sbyte -128 - 127  占一个字节 0000 0000 标粉的那一位 是符号位 所以 能表示正负

short -32768 - 32768 占两个字节

int  -21亿 -  21亿 占四个字节

long -9百万兆 - 9百万兆 占八个字节

无符号的整型变量 一定范围内 0和正数的变量类型 

byte 0- 255 占一个字节 

ushort 0- 65535 占两个字节

uint 0- 42亿 占四个字节

ulong 0 - 18百万兆 占八个字节

浮点数 小数

float 存储7/8位 有效数字 根据编译器的不同可能不一样   占四个字节

float = 0.1234567f 

加f是因为c#默认的小数是double

有效数字 是从左到右 从非0数开始算有效数字

double

double 存储15-17位 有效数字 根据编译器的不同可能不一样 占八个字节

decimal 存储27-28位 有效数字 根据编译器的不同可能不一样 占十六个字节

decimal = 0.1231321321321321m;

特殊类型

bool   占一个字节

char 用来存储单个字符的变量类型  占二个字节

char c = 'a';

char c = '然';可以中文一个字符

string 用来存储多个字符 没有上限 长度可变

string s = “string”;

1byte = 8bit 1byte = 0000 0000 8个数 就叫8位 一个字节

1kb = 1024 byte

1mb = 1024kb

1gb = 1024mb

1tb = 1024gb

通过sizeof 可以知道变量类型所占的空间 单位 字节

常量必须初始化

常量不能被修改

const

string s = @“\\\\” 取消转义字符

值类型 数字类型  默认值 是0 bool 默认值是 false

引用类型 的默认值是null

隐式转换 大范围装小范围

decimal 不能隐式转换

无符号不能装有符号 有符号不能隐式转换为无符号

有符号能装无符号的 范围要在有符号的范围内

浮点数能装任何类型的整数 很大的数会转成科学计数法

char可以隐式转换为整型 其实是转为int 然后int可以转为其他int可转的 对于short byte等小的范围 无法表现为隐式转换

double -》 float -》整形（有符号 无符号）-》char

decimal -》 整形（有符号 无符号）-》char

显式转换

高精度转低精度 括号强制转换 可能会出现范围问题

浮点数会丢失精度

浮点强转整形时 会直接抛弃小数

parse法 将字符串类型转成对应的类型 字符串必须转换成对应的类型

int I = int.parse("asdf");

Convert法 更准确的将各个类型进行转换 填写的变量要正确 会四舍五入

int I = Convert.ToInt("123123");

toint16 是转为short touint 是ushort

toint32 是转为int  同上

toint64 是转为long 同上

float是tosingle

double是todouble

decimal  todecimal

还有 变量类型.ToString();

进行字符串拼接时+++ 自动调用了tostring

异常捕获

try

{

    //希望进行异常捕获的代码

}catch (Exception ex) {

    //如果出错 则会执行catch的代码

}finally {

    //不论有没有出现异常 都会执行的代码

}

默认的整数是 int 如果要得数是小数 则在运算时 要有浮点数的特征 f/m

乘除取余 高于加减 算术运算符的优先级

调换 交换

            int a2 = 99;

            int b2 = 87;

            a2 = a2 + b2;//a2 = 99 + 87

            b2 = a2 - b2;//b2 = 99 + 87 - 87

            a2 = a2 - b2;//a2 = 99 + 87 - 99

 //99999秒转为 多少天多少时多少分钟多少秒来显示

 int daySec = 60 * 60 * 24;

 int hourSec = 60 * 60;

 int minSec = 60;

 int day = 99999 / daySec;//int会抛弃除不尽的小数 正好除不尽的小数是不足一天的秒数

 int hour = 99999 % daySec /hourSec;//取余出来的余数 就是不足一天的秒数 用来除hoursec 正好就是几个小时 同时int会抛弃除不尽的小数

 int min = 99999 % hourSec /minSec;//同上 取余就是不足一小时的秒数 再除于minSec 正好是几分钟

 int sec = 99999 % minSec;

字符串拼接

直接用+号拼接 注意的是

string s ＝ “”+1+2+3+4

输出1234

string s ＝1+2+3+4

输出 10

string s = "1";

s += 1 + 2 + 3 + 4;

输出

110

string.format({0},{1},{2},1,2,3)后面的东西可以是任意的变量类型 占位符

console.writeLine({0},{1},{2},1,2,3)  也一样可以用占位符

条件运算符 优先级低于算数运算符

逻辑运算符＜条件运算符＜算数运算符＜！

！＞&&＞||

逻辑运算符的短路规则

只要满足条件判断左边的内容 则右边的内容不重要

如逻辑与 有假则假 左边假 右边不用看

逻辑或 有真则真 左边真 右边不用看

位运算符

转为2进制后 对位运算

位与 类似逻辑与 有0则0

位或 类似逻辑或 有1则1

异或 相同为0不同为1

位取反 0变1 1变0

左移 向左移几位就在右侧补几个0

右移 向右移几位 就删最右侧几个数

异或加密

位运算与buff

三目运算符

int year = int.Parse(Console.ReadLine());

//年份能被400整除 或

//年份能被4整除但不能被100整除

Console.WriteLine(year % 400 ==0 || year % 4 == 0 && year % 100!=0 ? "闰年" :"平年");

switch

贯穿

int num = int.Parse(Console.ReadKey().KeyChar.ToString());//获取输入的一个字符 转为string之后 再转为int

//如果直接获得char 是直接获取ascii码所以要转成string

斐波那契数列

int index = 0;

int result = 0;

int n1 = 1;

int n2 = 1;

while (index < 20)

{

    index++;

    if (index == 1)

    {

        result = n1;

    }

    else if (index == 2)

    {

        result = n2;

    }

    else

    {

        result = n1 + n2;

        //这里要注意的是 把n1 n2 后移了

        n1 = n2;

        n2 = result;

    }

}

Console.WriteLine(result);

//1-100的素数

int num = 2;

while (num < 100)

{

    int i = 2;

    while (i < num)

    {

        if (num % i ==0)

        {

            //不是素数

            break;

        }

        i++;

    }

    if (i == num)

    {

        //是素数

        Console.WriteLine("{0}是素数", num);

    }

    num++;

}

static bool IsPrime(int num)

{

    for (int i = 2; i < num; i++)

    {

        if (num % i == 0) {

            return false;

        }

    }

    return true;

}

//水仙花数

for (int i = 100; i < 1000; i++)

{

    int hundred = i / 100;

    int ten = i % 100 /10;

    int ge = i % 10;

    if (hundred * hundred * hundred + ten* ten * ten + ge * ge * ge == i)

    {

        Console.WriteLine(i);

    }

}

   //九九乘法表

   for (int i = 1; i <= 9; i++)

   {

       for (int j = 1; j <= i; j++)

       {

           Console.Write("{0} x {1} = {2}  ",j,i,j*i);

       }

       Console.WriteLine();

   }

复杂数据类型

枚举

E 或 E_ 开头

枚举不能声明在函数中

数组

数组 增加元素 要全部元素挪过去之余 还要将

newarr = arr;//把引用的地址也转过去

二维数组的行长度arr.getlength(0)

二维数组的列长度arr.getlength(1)

数组声明初始化后 就不能在原有的基础上增加数组的长度或删除数组长度了

引用类型有 string  数组  类  相互赋值 是两者指向同一个值（地方）

值类型 其他的类型 结构体  值类型 相互赋值 把内容拷贝给对方

值类型和引用类型存储在内存区域不同

值类型存储在栈空间  系统分配 自动回收 小而快

引用类型 存储在堆空间  手动申请 释放 大而慢

string是特殊的引用类型 重新赋值时 会在堆中重新分配空间 拼接或重新赋值时 都会产生内存垃圾 对性能造成影响

函数的作用

1 封装代码

2 提升代码复用率

3 抽象行为

ref和out

解决值类型和引用类型 在函数内部改值或重新声明 能够影响外部传入的值 让其也能被修改

使用就是 在声明参数前 加上ref或out 关键字

区别就是 ref 使用前 必须初始化

out在内部必须赋值

原因就是 必须要让变量有值

默认参数

Static void Speak(string str  = "nihao"){}

如果普通参数和默认参数混在一起 默认参数 必须在普通参数后面

变长参数

最多出现一个params 并且必须出现在最后

params 后面必须跟的是数组

public void xxx(params int[] arr){

}

函数的重载

名字一样的函数 但是 参数的类型或者参数的顺序不一样

作用

1 减少函数名的数量 避免命名空间的污染

2 提升程序的可读性

递归函数

正确的递归的函数

1 必须有结束调用的条件

2 用于条件判断的 条件 必须改变 能够达到停止的目的

先拼凑出普通逻辑 然后 再拼凑出 递归逻辑 然后再加入条件做跳出

结构体

用来表现存在关系的数据集合

结构体申明的变量 不能直接初始化 

可以包含别的结构体 不能包含自己

面向对象

面向对象是一种对现实世界理解和抽象的编程方法

把相关的数据和方法组织为一个整体来看待

从更高的层次来进行程序开发

更贴近事物的自然运行模式

万物皆对象

用程序来抽象 形容对象

用面向对象的思想来编程

提高代码复用率

提高开发效率
提高程序可拓展性

清晰的逻辑关系

面向对象 

三大特性

封装  用程序语言来描述对象

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

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

七大原则

里氏替换原则

类是对象的模板 蓝图 可以通过类 创建出对象

Person p;

Person p = null; //这两种都没有在堆上开辟空间 只在栈上面开辟了一个空间 里面是空的 没有存地址

Person p3 = new Person(); //这种是栈上有地址 堆上有空间

构造函数

如果先实现了有参构造函数 而没有实现无参构造函数 则会失去默认的无参构造

public Person():this(){}

this()意思是先去调用 一个无参的构造函数 在this()中加参数 意思就是先调用有参的构造函数

析构函数

在引用类型的堆内存被回收的时候会被调用 当 垃圾 真正被回收 才会调用 很少用

~Person(){

}

垃圾回收

垃圾回收的过程就是遍历堆 heap 上动态分配的所有对象

通过识别它们是否被引用来确定哪些对象是垃圾 哪些对象仍要被使用

所谓的垃圾 就是没有被任何变量，对象引用的内容

垃圾回收的算法

引用计数

标记清除

标记整理

复制集合

GC. Collect(); 手动触发GC

GC只负责堆heap内存的回收

引用类型都是存在堆heap中的 所以它的分配和释放都通过垃圾回收机制来管理

stack栈上的内存都是由系统来自动管理的

值类型在栈stack中分配内存  它们有自己的生命周期 不用对他们进行管理 会自动分配和释放

c# 中内存回收的机制的大概原理

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

代的概念

代是垃圾回收机制使用的一种算法  （分代算法）

新分配的对象都会配置在第0代内存中

每次分配都可能会进行垃圾回收以释放内存（0代内存满时）

在1次内存回收过程开始时，垃圾回收器会认为堆中全是垃圾 会进行以下两步

1 标记对象 从根（静态字段 方法参数 ）开始检查引用对象 标记后为可达对象 未标记的为不可达对象

不可达对象就是垃圾

2 搬迁对象 压缩栈 （挂起执行托管代码线程） 释放未标记的对象  搬迁可达对象 修改引用地址

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

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

0代内存满了有用的放进1代  触发0代垃圾回收 放进一代 一代满了  有用的放进2代  

触发 1代 0代垃圾回收 二代满了 触发0代 1代 2代 垃圾回收机制

为什么大对象都放在2代内存 因为大对象的释放需要消耗较多的性能 不轻易释放

成员属性  主要对成员变量有保护作用

类里面

get

set

方法就是成员属性

可以做加密

set的时候 加5 （加密） set里面value就是传入的内容

get的时候 减5 (解密)

这样内存里存的值就不会被轻易拿出来

自动属性

没有什么特殊处理的时候

public int Height{

//不用去去声明 成员变量  直接声明 成员属性

get;

set;

}

索引器

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

索引器里面可以写逻辑

//相当于有一个快捷的方法来使用 类里面 的元素 规则自己定

//访问时 和数组一样

//比较适合类中有数组的时候使用

class Person{

Person[] friends;

public Person this[int index]{

get{

return friends[index];

}

set{

friends[index] = value;

}

}

}

使用：

Person p = new Person();

p[0] = new Person();

Console.WriteLine(p[0]);

静态成员

static

程序开始时 就会分配内存空间 给静态成员 直到程序结束 内存空间才会被释放

静态成员和程序同生共死

每一个静态成员都会有自己唯一的“内存小房间”

这让静态成员有唯一性

在任何地方用的都是小房间里的内容 改变它也是改变小房间内的内容

内存里面有专门的静态区域

静态函数中 不能使用非静态成员  要实例化对象 由对象使用

静态成员 方便别人使用

静态方法 常用的 唯一的方法声明

常量是特殊的静态？

常量要初始化

静态可以不初始化

常量不能改  静态可以改

const 只能修饰变量

static 可以修饰很多东西

相同就是都可以通过    类名。出来

单例

        class Test

        {

            private static Test t = new Test(); //利用了 静态的唯一性

            private Test() { //外部不能实例化

            }

            public static Test T

            {

                get

                {

                    return t;//保护了 t 对象 不能被修改

                }

            }

        }

静态类

将常用的静态类 写在静态类中 方便使用

静态类 不能被实例化 更能体现工具类的唯一性

静态构造函数

在构造函数前 加上static修饰

特点

静态类和普通类都可以有

不能使用访问修饰符

不能有参数

只会自动调用一次  （在第一次使用的时候 被调用）

作用

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

拓展方法

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

相当于为一些数值类型 或者 类什么的 新加一些自定的工具方法

作用

提升程序拓展性

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

不需要继承来添加方法

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

特点

一定是写在静态类中

一定是个静态函数

第一个参数为拓展目标

第一个参数用this 修饰

public static void SpeakValue(this int value){

//value 是传进来的实例化的对象

}

运算符重载  让自定义类和结构体对象可以进行运算

一定是个 公共的静态方法

返回值写在operator 前面

逻辑处理 自定义

不能使用ref out

一个符号可以多个重载

条件运算符需要成对实现

operator

参数里面 必须有一个是原类型

public static Point operator + (Point p1,Point p2){

return p1;

}

逻辑与 && 逻辑或 ||

索引符[]

强转运算符()

特殊运算符

点.  三目运算符?: 赋值符号=

内部类

在一个类里声明另一个类

为了表现亲密关系

使用时 要用外面的类 来。出内部的类

分部类

partial

将声明和实现分开两个地方来写

继承

一个类A继承一个类B

类A将会继承类B的所有成员

A类将拥有B类的所有特征和行为

单根性  子类 只能有一个父类

传递性 子类可以简接继承 父类的父类

里式替换原则

如何父类出现的地方 子类都可以替代

Father son = new Son();

父类容器 装载子类对象

is判断一个对象是否是指定类对象 返回一个bool

as 将一个对象转换为指定类对象 成功返回对象 不成功返回null

继承中 构造函数

声明一个子类对象时

先执行父类的构造函数  调用的是父类的无参构造函数

再执行子类的构造函数

父类的构造函数 很重要

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

class Father

{

    public Father(int i ) { }

}

class Son : Father

{

    public Son(int i):base(i) { }

}

子类在实例化对象的时候是必须调用父类的构造函数的 所以 base用来使用一个指定的父类构造函数

万物之父

object 是所有类型的基类

object与引用类型 用is 判断 用as转换

object与值类型 用（）强转

object与string 用tostring  或者 as

装箱拆箱

用object存 值类型 叫装箱  object o = 1f；  把值类型用引用类型来存储 栈内存会迁移到堆内存中

把object转为值类型 叫拆箱 float f1 = (float) o2;  把引用类型的值类型取出来 堆内存会迁移到栈内存中

好处 不确定类型时 可以方便参数的存储和传递

坏处 存在内存迁移 增加性能消耗

密封类

sealed

让类无法被继承

保证最底层子类不被继承

保证程序的规范性  安全性 结构性

多态

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

目的

同一父类的对象 执行相同行为 方法的时候有不同的表现

解决的问题 

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

多态vob

编译时的多态是 函数重载 （确实是多态 但是不能以多态来理解 真正的多态是 运行时多态）

运行时 多态 是 vob 抽象函数 接口

v virtual 虚函数

o override  重写

b base 父类

class Father{

public virtual void Atk（）{

}//虚函数 虚函数就是用来给子类重写的

}

class Son{

//重写虚函数

public override void Atk（）{

base.Atk();

//base代表父类 可以用过base来保留父类的行为

}

}

virtual 和 override 必须配对使用

抽象类

abstract

 不能被实例化

可以包含抽象方法

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

抽象方法

只能在抽象类中声明

没有方法体

不能是private

继承后必须实现 用override 重写

整体框架时 会使用

孙子可以不实现抽象方法

接口

接口时抽象行为的  基类

interface

接口是行为的抽象规范

不包含成员变量

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

成员不能被实现

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

接口不能继承类 但是可以继承另一个接口

类可以继承多个接口

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

和类的声明类似

接口是用来继承的

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

接口里的修饰符 默认public

实现接口的地方 必须是public

接口也遵循里氏替换原则 也即是说 可以用同一个行为接口来获取 不同的对象 （都继承该接口的）

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

等到类继承时 再实现接口

显示实现接口

当一个类继承两个接口

但是接口里面存在着同名的方法时

不能写 访问修饰符

interface Iatk{

void atk();

}

interface Isuperatk{

void atk();

}

class Person{

void Iatk.atk(){

}

void Isuperatk.atk(){

}

//显示实现接口的语法  接口名.方法名

}

继承类

对象间的继承 包括特征行为等等

继承接口

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

密封方法

sealed

让虚方法或者抽象方法不能被重写

和override 一起出现

public sealed override void Eat(){

}

//加了sealed 就不能被重写了

命名空间

（工具包）  类就是工具

命名空间是用来组织和重用代码的

命名空间可以同名写多个

using  引用命名空间

不同命名空间允许有同名类

引用两个命名空间的同名类时 要使用 指明出处的语法 XXX.xxx

internal 只能在该程序集里使用

Object

静态方法

Equals()  判断两个 对象 是否相等 最终的判断权 交给左侧对象的Equals方法

不管值类型 引用类型都会按照左侧对象的equals方法进行比较

RefereceEquals

比较两个对象是否是相同的引用 主要是用来比较引用类型的对象

值类型对象返回值始终是false

成员方法

GetType  需要结合反射

获取对象运行时的类型Type

普通方法

MemberwiseClone

该方法用于获取对象的浅拷贝对象 口语化的意思就是返回一个新的对象

但是新对象的引用变量会和老对象一致

浅拷贝 一个类里的值类型会直接变成新的  但是引用类型的变量 还是指向拷贝之前的那个

假如一个类里有一个值类型 这个值类型是放在堆里面的

虚方法

Equals

默认实现是比较两者是否是同一个引用 即相当于ReferenceEquals

但是微软在所有值类型的基类System.ValueType 中重写了该方法 用来比较值相等

我们也可以重写该方法 定义自己的比较相等的规则

GetHashCode

该方法是获取对象的哈希码

哈希码 一种算出来的 用于表示对象的唯一编码 不同对象的哈希码有可能一样

可以通过重写该方法来重新定义哈希码的算法

ToString

该方法用于返回当前对象代表的字符串 我们可以重写它定义我们自己的对象转字符串规则

调用打印方法的时候 默认就是调用的对象的Tostring方法打印出来的

string

字符串本质是char数组

String str = "1231";

int I  = str.IndexOf("1");//正向查找字符位置  0

int I  = str.LastIndexOf("1");//正向查找字符位置 3

String str2  = str.Remove(1);//移除指定位置后的字符  12

String str2  = str.Remove(1，1);//移除指定位置后的字符  121

String str3 = str.Replace("12","56");//替换  5631

ToUpper 转换大写

ToLower 转换小写

String str4 = str.Substring(1);//截取从指定位置开始之后的字符串  31

String str4 = str.Substring(1，1)；

str = "1,2,3,4,5,6,7,8,9";

string [] strs = str .Split(",");

strs[0] = "1";

String 和 string

Int32 和 int

Int16 和short

Int 64 和 long 区别是什么 没有区别 后者是前者的别名

stringbuilder

一开始就有容量和长度 长度没达到最大容量时 更改或增加stringbuilder不会产生垃圾

stringbulider是一个字符数组

增

append

删

remove（0，3）

改

str[0]＝“i”   string不能这样改 stringbuilder可以

查

equals

string和stringbuilder的区别

string相对于stringbuilder更容易产生垃圾 每次修改拼接都会产生垃圾

string相对于stringbuilder更加灵活 因为提供了更多的方法

需要频繁更改的时候选择stringbuilder

需要使用string的一些特殊方法的时候使用string

结构体和类的区别

结构体和类最大的区别是存储空间上的 结构体是值类型 在栈空间  类是引用类型 在堆空间

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

结构体没有继承 所以不能用protected

结构体成员变量不能指定初始值 类可以

结构不能声明无参的构造函数 类可以

结构体声明有参构造函数之后 无参构造不会被覆盖 类会被覆盖

结构不能声明析构函数 类可以

结构体不能被继承 类可以

结构体需要在构造函数中初始化所有成员变量 类随便

结构体不能被static修饰 类随意

结构体不能再内部声明和自己一样的结构体变量 类可以

结构体可以继承接口 因为接口是行为的规范

string

如何选择结构体和类

有继承和多态的 直接选择类

对象是数据集合的 考虑结构体 如位置 坐标等

从值类型和引用类型上面去考虑

   （ 经常被传递赋值 但是源对象不想跟着改变时就用结构体）？

抽象类和接口的区别

都可以被继承

都不能直接实例化

都可以包含方法声明

子类必须实现未实现的方法

都遵循里氏替换原则（父类装子类）

抽象类中有构造函数 接口中没有

只能继承一个抽象类 可以继承多个接口

抽象类中可以有成员变量 接口中不能

抽象类中可以声明成员方法 虚方法 抽象方法 静态方法  接口中只能声明没有实现的抽象方法

抽象类中方法可以使用访问修饰符 接口中建议不写 默认public

抽象类与接口的选择

表示对象的用抽象类 表示行为的用接口

面向对象七大原则

高内聚 低耦合  将东西内聚予一个类 尽量少跟别的类产生关系

单一职责原则  做类里面应该做的事情 专注于单一功能 只处理自己应该处理的内容

开闭原则  对拓展开放（可以拓展新功能） 对修改关闭（不允许修改源代码） 例如 子类继承父类后重写 新加功能尽量是加处理 而不是改代码

里氏替换原则  任何父类出现地方 子类都可以代替  父类容器装子类

依赖倒装原则  依赖抽象 不要依赖具体的实现 依赖抽象（接口）

迪米特原则 一个对象应当对其他对象 尽可能少的了解   降低耦合性  尽量少用别的类和自己关联

接口隔离原则  不应该强迫别人依赖他们不需要的方法 一个接口不需要提供太多的行为 应该尽量只提供一个对外的功能 不要一个接口n个行为

合成复用原则  尽量使用对象组合 而不是继承来达到复用的目的 尽量用组合复用的形式

UML

Unified Modeling Language

统一建模语言

ArrayList  尽量少用

ArrayList 是一个系统为我们封装好的类

它的本质是一个object类型的数组

ArrayList类帮助我们实现了很多方法

比如数组的增删查改

add   addrange

remove() 从头开始找 找到之后开始删

removeAt() 指定位置

Contains  查看元素是否存在   返回bool

indexof 正向查找元素的索引 返回 int

lastindexof 反向查找元素的索引

insert 插入

Count 长度

Capacity 容量

for遍历 和foreach遍历

因为是object数组 所以有时候要as出想要的对象来用

arraylist和数组的区别

arraylist本质是一个object数组

arraylist可以不用一开始就定长 单独使用数组是定长的

数组可以指定存储类型 arraylist是object类型

数组的增删需要我们自己实现 arraylist有api

arraylist使用的时候可能存在装箱拆箱 数组使用时 不是object数组就不存在这个问题

数组长度是length arraylist长度是 count

Stack 栈

在c# 里面栈是一个 object数组 封装了特殊的存储规则

栈存储容器 先进后出

增删改查

push

pop

peek 查看栈顶的内容

contains 栈里面是否存在

没有改的方法

clear 清空

stack.count 长度

没有提供索引器 所以不能用for遍历

只能用foreach 遍历 顺序也是从栈顶到栈底

还可以转成object数组 然后在遍历 ToArray();

队列

先进先出

本质也是一个object数组

enqueue 入队

dequeue 出队

没办法改 只能清空

哈希表 hashtable

散列表 是基于键的哈希代码组织起来的 键值对

它的主要作用是提高数据查询的效率

使用键来访问集合的元素

键值都是object类型的

不能出现相同的键

只能通过键去删除 remove

contains和containskey一样

containsValue 存在某个值

只能改键对应的值 没办法改值

Hashtable hashtable = new Hashtable();

foreach (object item in hashtable.Keys)

{

    Console.WriteLine("键",item);

    Console.WriteLine("值", hashtable[item]);

}

遍历出来是没有规律的

foreach (object item in hashtable.Values)

{

    Console.WriteLine("值", item);

}

泛型

泛型实现了类型参数化 达到代码重用目的

通过类型参数化来实现同一份代码操作多种类型

泛型相当于 类型占位符

定义类或者方法时使用替代符代表变量类型

当真正使用类或者方法时再具体指定类型

使用泛型可以一定程度避免装箱拆箱

Class xxx<T> //T可以是任意字母 建议是大写字母

interface xxx<T>

函数名 <T> (参数列表)

泛型占位字母可以有多个 用逗号分开

class Test<T>

{

    public T value;

    public void TestFun<T>(T value)

    {

        Console.WriteLine(value);

    }

}

Test<int> t = new Test<int>();

t.value = 1;

t.TestFun(1);

 public T TestFun2()

 {

     return default(T);//作为返回值

 }

public void TestFun3<T>()

{

    T value = default(T);//做逻辑处理

}

泛型约束

让泛型的类型有一定的约束

值类型     where T:struct //T是泛型字母

class Test<T> where T :struct

{

public T value;

public void TestFun<K>(K v) where K :struct{

}

}

Test<int> t2 = new Test<int>();

t2.value = 2;

t2.TestFun<float>(13.4f);

引用类型     where T:class //T是泛型字母

class Test3<T> where T : class

{

    public T value;

    public void TestFun<K>(K v) where K : class

    {

    }

}

Test3<object> t3 = new Test3<object>();

t3.value = new object();//其实什么都可以的 因为是object

t3.TestFun(new Random());

存在公共无参构造函数     where T:new() //T是泛型字母

class Test4<T> where T : new()//是这个T必须要有公共无参的构造函数

{

    public T value;

  

}

是指传进去的东西 必须有无参的构造函数

某个类本身或者其派生类     where T:类名 //T是泛型字母

class Test5

{

}

class Test6: Test5

{

}

class Test4<T> where T : Test5

{

    public T value;

  

}

Test4<Test5> t4 = new Test4<Test5>();

Test4<Test6> t5 = new Test4<Test6>();

某个接口的派生类型     where T:接口名 //T是泛型字母

    class Test8:IFly {

    }

    class Test7<T> where T:IFly

    {

    }

Test7<Test8> t7 = new Test7<Test8>(); //要传一个 是继承了这个接口的引用类型（类）

另一个泛型类型本身或者派生类型     where T:另一个泛型字母 //T是泛型字母

class Test10<T,U> where T : U

{

    //U是T的类型本身或者是T的派生类

    public void TestFunc<K,C>() where K:C

    {

        //C是K的类型本身或者是C的派生类

    }

}

约束的组合使用

class Test11<T> where T : Test9,new()

{

    //逗号隔开 多个约束联合

}

class Test12<T,K> where T : Test9, new() where K : new()

{

    //多个泛型反别有多个不同约束

}

用泛型实现一个单例基类

    class SingleBase

    {//最基础的单例

        private static SingleBase instance = new SingleBase();

        private SingleBase() {}

        public static SingleBase Instance { get { return instance; } }

    }

    class SingleBaseT<T> where T:new()//因为单例必须在基类里new出来 所以必须在此加泛型约束

    {//用泛型实现的单例 缺点是在外面可以new一个单例 但是作为程序员 应该知道 单例不能在外面new 后续有解决方法

        public static T instance = new T();

        public static T Instance { get { return instance; } }

    }

常用泛型数据结构类

List

List的本质是一个可变类型的泛型数组

List类帮助我们实现了很多方法

如增删查改 跟arraylist的方法一样

遍历 foreach

Dictionary

Dictionary 是一个拥有泛型的Hashtable    很像hashtable

她也是基于键的哈希代码组织起来的键/值对

键值对类型从Hashtable的object变为了可以自己制定的泛型

值可以一样 键不能一样

通过键查看值

dict[2]

dict["2"]

是否存在

containsKey  //通过键查找

containsValue //通过值查找

遍历 foreach

Dictionary<int, string> dict = new Dictionary<int, string>();

            foreach (int item in dict.Keys) { }

            foreach (string item in dict.Values) { }

 foreach (KeyValuePair<int, string> item in dict) { Console.WriteLine(item.Key+item.Value);}

还有迭代器

顺序存储和链式存储

线性表 是一种线性结构 是由n个具有相同特性的数据元素的有限序列

比如数组 arraylist stack queue 链表

顺序存储 用一组连续的存储单元依次存储线性表各个数据元素 stack queue list arraylist 数组

只要是数组 都是顺序存储 没办法更改容量

链式存储 也叫链接存储

单向链表 双向链表 循环链表

用一组任意的存储单元存储线性表中的各个数据元素

单向链表 像火车头 有个钩子 钩着车厢 下一个车厢又有个钩子勾着下一个车厢

双向链表 有两个钩子

单向链表

class LinkedNode<T>

{

    public T value;

    public LinkedNode() {

    }

    public LinkedNode(T value)

    {

        this.value = value;

    }

    public LinkedNode<T> nextNode;

}

class LinkedList<T>

{

    public LinkedNode<T> head;

    public LinkedNode<T> last;

    public void Add(T value)

    {

        LinkedNode<T> node = new LinkedNode<T>(value);

        if (head == null)

        {

            head = node;

            last = node;

        }

        else

        {

            last.nextNode = node;

            last = node;

        }

    }

    public void Remove(T value) {

        if (head == null)

        {

            return;

        }

        if (head.value.Equals(value))

        {

            head = head.nextNode;

            if (head == null)

            {

                last = null;

            }

        }

        LinkedNode<T> node = head;

        while (node.nextNode != null)

        {

            if (node.nextNode.value.Equals(value))

            {

                node.nextNode = node.nextNode.nextNode;

                break;

            }

        }

    }

}

顺序存储和链式存储的优缺点

增：链式存储 计算上 优于顺序存储 中间插入时链式不用像顺序一样移动位置

删：链式存储 计算上 优于顺序存储 中间删除时链式不用像顺序一样移动位置

改 顺序存储 使用上 优于链式存储 数组可以直接通过下标得到元素 链式需要遍历

查 顺序存储 使用上 优于链式存储 数组可以直接通过下标得到元素 链式需要遍历

双向链表

class LinkedNode<T>

{

    public T value;

    public LinkedNode<T> frontNode;

    public LinkedNode<T> nextNode;

   

    public LinkedNode(T value){

        this.value = value;

    }

}

class LinkedList<T>

{

    private int count;

    private LinkedNode<T> head;

    private LinkedNode<T> tail;

    public int Count { get;set;}

    public LinkedNode<T> Head

    {

        get

        {

            return head;

        }

    }

    public LinkedNode<T> Tail

    {

        get

        {

            return tail;

        }

    }

    public void Add(T value)

    {

        LinkedNode<T> node = new LinkedNode<T>(value);

        if (head == null)

        {

            head = node;

            tail = node;

        }

        else

        {

            //顺序别搞错了

            tail.nextNode = node;

            node.frontNode = tail;

            tail = node;

        }

        ++count;

    }

    public void RemoveAt(int index)

    {

        if (index >= count || index <0)

        {

            return;

        }

        int tempCount = 0;

        LinkedNode<T> tempNode = head;

        while (true)

        {

            if (tempCount == index)

            {

                if (tempNode.frontNode != null)

                {

                    tempNode.frontNode.nextNode = tempNode.nextNode;

                }

                if (tempNode.nextNode != null)

                {

                    tempNode.nextNode.frontNode = tempNode.frontNode;

                }

                if (index == 0)

                {

                    head = head.nextNode;

                }

                if (index == count - 1)

                {

                    tail = tail.frontNode;

                }

                break;

            }

            ++tempCount;

            tempNode = tempNode.nextNode;

        }

     }

}

LinkedList

LinkedList本质是一个可变类型的泛型双向链表

尾增

addlast

头增

addFirst

某节点后

addafter（node,value）

addbefore(node,value)

删

removefirst 移除头

removelast 移除尾

remove（value） value是节点里的值

clear 清空列表

查

.First 头节点

.Last 尾节点

遍历找节点

find（value）value是节点里的值

contains  是否存在

改

先得到节点 然后再改变值

泛型栈和泛型队列

跟栈和队列差不多

数组 list dictionary stack queue linkedlist

如何选择

数组 list linkedlist

数组固定不变的一组数据

list 经常改变 经常通过下标查找

linkedlist 不确定长度 经常插入 查找不多

stack 一些适用先进后出的规则的数据

queue 一些适用 先进先出的规则的数据

键值对 需要频繁查找的 有对应关系的数据