C#

C#中分为值类型和引用类型

值类型：构造体struct，基本类型，储存在栈中

引用类型：类，string等是引用类型，对象储存在堆中，引用变量存储在栈中。

C#中的内存：

1，栈：存放变量，速度快，容量小，由系统管理

2，堆：存放对象，可自己分配内存使用。

3，常量区：存放常量，

4，静态区：存放只有一份的东西

5:，代码区：代码会编译成二进制，保存到代码区。

析构函数和构造方法

Class Test{

Class Person{

public Person(){Console.WriteLine("构造方法");}

~Person(){Console.WriteLine("析构函数");}

}

public static void main(string[] args){

Person p=new Person();

Console.WriteLine("主函数");

}

}

输出结果为：

构造方法

主函数

析构函数

析构函数没有权限修饰符，返回值，也没有参数，不能自己调用，是为了释放内存，由系统调用。

虚函数：相当于java中的子类对父类的方法重写

在C#中需要用特殊的写法，如果是想要实现多态的话，那么应该这么写

Class Base{

public virtual void Read(){Console.WriteLine("Base Read")}

}

Class Sub：Base{

public override void Read(){Console.WriteLine("Sub Read")}

}

子类替换父类的方法

public new void Read(){Console.WriteLine("Sub Read"}//需要加new关键字

如果父类是抽象类，需要重写的也是抽象方法的话，需要添加关键字abstract

父类的方法由于是抽象方法，不能写实现，子类重写去实现该方法需要添加override关键字。

C#中的单例

class Person{

private Person(){}

private static Person _instance;

public static Person GetInstance(){

if(_instance==null){//添加判断是有必要的，可以重复使用一个对象

_instance=new Person();

}

return  _instance;

}

}

递归：就是方法内部调用方法。

例如：数字累加：1+2+3+4+....+100=5050

public static int Compute(int i){

if(i>1){

return Compute(i-1)+i;

}else{

return 1;

}

}

C#中的属性，它的getter和setter是写在一起的。get访问器和set访问器也可以是private的，但是两个都为private就没有意义了。

class Person{

private string name;

public string Name{

get(){ //get访问器

return name;

}

set(){ //set访问器

name = value;

}

}

}

在使用的时候：

Person p=new Person();

p.Name="张三";   //相当于使用了get访问器

接口：

定义接口的属性一般这样

interface Person{

int Age{set；get；}//属性的定义也可以只有其中一个。

public void Speak()；//定义的方法也不能由接口自己实现

}

如果一个类继承另一个类，又实现了接口，那么首先在冒号后面填写父类，后面填写接口。

索引器：

class Array{

private int  _array[ ]；

public Array( ){

_array[ ]=new int[100];

}

public int this[int index]{

set{

_array[index]=value;

}

get{

return _array[index];

}

}

}

泛型：

提高代码重用性，可以约束数据类型，但是不能再泛型类中使用算数运算符，因为泛型类不能确定类型。

用<T>来表示任意泛型类型。

泛型可以提供多个参数的泛型如：

<T，S，U，V>

S/U/V：第二三四种类型

T：type

K/V：key/value

N：number

C#中的集合

List：是一种强类型的列表

List<string> list = new List<string>();

list.Add(string s); //添加元素

list.Insert(int index , string s); //插入元素

list.Remove(string s); //移除包含的元素

list.RemoveAt(int index ); //移除指定位置的元素

list.Count; //返回集合的元素数量

list.contains(string s); //返回boolean值，判断是否含有指定元素

list.Clear(); //清空集合

arr[0]; //可以通过List对象直接用数组的形式来表示

C#中的ArrayList：

它的效率比List低，而且类型不确定的话，会出很多问题，一般并不推荐使用。

ArrayList  arr = new  ArrayList();

它不要求ArrayList使用泛型，可以在集合中添加任意的数据类型，在取出元素可以通过数组的形式来取出，但是需要强制类型转换，ArrayList统一存的是Object类型。

string s = (string)arr[0]；

C#中的字典

C#中的字典和java中的Map一样，用键值对来存储数据，它是无序的。

Dictionary<string，int>  dic = new  Dictionary<string ，int>()；

dic.Add("年龄"，30)；

获取元素可以直接用数据的形式表示

int  age = dic["年龄"]；//这一点比java操作方便

dic.Add(string key，object value);

dic.Remove(string key);

dic.Clear();

int num = dic.Count;

bool b1 = dic.ContainsKey(string key)；

bool b2 = dic.ContainsValue(Object value);

bool b3 = dic.TryGetValue(string key ，out int s);//尝试通过一个key来获取value，并且会保存到out输出参数的变量s中

C#中的栈和队列

栈：后进先出。像是人一个一个掉进井里，然后最后一个掉进去的先出来。

Stack<string> s = new Stack<string>();

s.Push("A"); //入栈

string str = s.Pop(); //出栈，取出最后最上层的元素。

 

队列：先进先出。像是排队买东西，先进先出。

Queue<string> q = new Queue<string>();

q.Enqueue("A");//入列

q.Dequeue();//出列，没有参数，会取出第一个入列的元素。

C#中的委托

public delegate void Some(string s);//委托的关键字delegate，需要写在namespace之中，一般不写在类里面。用于进程通信

public class Sub{

private string name;

public Some some;

public void SubDo(){

some(name);//执行委托的方法

}

public Sub(string name){

this.name = name；

}

}

public class Base{

public void BaseDo(){

Sub s = new Sub("小明")；

s.some= new Some(Buy); //声明委托变量，参数是需要委托执行的方法

s.SubDo(some1)；

Some some2 = new Some(Sell);

Some some = some1+some2; //可以用+/-来增减委托。some1和some2的顺序不同，执行方法的次序也不同。

s.SubDo(some);

}

public void Buy(string name){

Console.WriteLine(name+"买东西")；

}

public void Sell(string name){

Console.WriteLine(name+"出售东西")；

}

}

class Mainclass{

public static void main(string[] args){

Base b = new Base();

b.BaseDo();

}

}

事件：event

class Student{

public event  Some some；//声明了事件的委托

}

在使用委托的时候

Student s=new Student();

s.some += new Some(A);//必须用+=号来赋值。