好吧，本来想用git的，可能门槛太高，没弄明白怎么用。那我就简单挑需要注意的重点写下吧。

重载：方法名必须相同、参数列表必须不同，返回值类型可以相同也可以不同。

重写：方法名、参数列表和返回值都必须相同。

构造函数：和类名相同，如果不写，编译器会自动生成一个无参的构造函数。

作用：对象的初始化，不能显示调用，只能在创建时用new来调用。

静态构造函数：第一次实例化该类的时候调用，之后不再初始化。

注意非静态的构造函数如果有继承关系，子类构造函数调用的时候会先初始化父类。

如果有两个类

public class Base
{
a:static int number = 1;
b:int number2 = 2;
c:static Base()
d{

}
e:public Base()
f:{

}

}
public class Child : Base
{
g:static int number = 1;
h:int number2 = 2;
i:static Child()
j:{

}
k:public Child()
l:{

}

}

实例化Child的时候，初始化顺序 

g i j h k a c d b e f i 

里氏替换：子类可以替换父类位置，父类不能替换子类。

子类可重写父类方法：

如果没有重写，声明的是哪个类就调用哪个类型的方法。如果有重写，无论声明的是哪个类都调用子类方法。

class father
{
public virtual void dosth()
{
Console.WriteLine("father do");
}
public void dosth1()
{
Console.WriteLine("father do1");
}

}

class sun:father
{
public override void dosth()
{
//base.dosth();
Console.WriteLine("sun do");
}

public new void dosth1()
{
Console.WriteLine("sun do1");
}

}

//重写

father f = new sun();
f.dosth();
//sun do

//无重写

father f = new sun();
f.dosth1();
//father do1

抽象类不能密封。不能用static修饰。

抽象类中可以包括抽象成员也可以有非抽象成员。

抽象成员必须在抽象类中。

抽象方法不能有任何方法实现。

如果抽象类实现接口则可以把接口中的方法映射到抽象类中作为抽象方法让子类去实现，也看在抽象类中直接实现该方法。

类不能new的情况，static，构造函数私有化，抽象类

抽象类实现了把可变与不可变分离

接口是一种特殊的抽象类。定义规则，降低耦合。

没有一定关系，侧重单一的某种能力。多继承，没有具体实现，只有方法声明。

可以有方法、属性、索引器、事件。不能有字段、常量、域、构造函数、析构函数、静态成员。

接口不具备继承的任何特点，它仅仅声明能够调用的方法。

接口里没有构造函数，抽象类里有构造函数，虽然不能实例化。

抽象类:

abstract class MobileStorage
{
public abstract void Read();
public abstract void Write();
}

class MobileDisk : MobileStorage
{
public override void Read()
{
Console.WriteLine("移动硬盘正在读取");
}

public override void Write()
{
Console.WriteLine("移动硬盘正在写入");
}
}

class UDisk : MobileStorage
{
public override void Read()
{
Console.WriteLine("U盘正在读取");
}

public override void Write()
{
Console.WriteLine("U盘正在写入");
}
}

class Computer1
{
MobileStorage ms;
public MobileStorage Ms
{
get { return ms; }
set { ms = value; }
}

public void CpuRead()
{
ms.Read();
}
public void CpuWrite()
{
ms.Write();
}

}

MobileStorage ms = new  UDisk();

Computer1 computer = new Computer1();
computer.Ms = ms;
computer.CpuRead();
computer.CpuWrite();

接口:

interface IFlyable
{
void Fly();
}
interface ISpeak
{
void Speak();
}

class Bird
{
public double Wings
{ get; set; }
public void EatAndDrink()
{
Console.WriteLine("Bird类会吃喝方法");
}
}

class Bird1 : IFlyable
{
public void Fly()
{
Console.WriteLine("鸟飞的方法");
}
void IFlyable.Fly()
{
Console.WriteLine("接口的飞方法");
}
}

class MaQue : Bird, IFlyable
{
public void Fly()
{
Console.WriteLine("麻雀会飞");
}
}

IFlyable obj = new MaQue();
obj.Fly();

Bird bird = (Bird)obj;
bird.EatAndDrink();

//MaQue类型本身具备bird的方法和飞的方法。如果声明的什么类型，就只能访问到什么类型的方法。

new MaQue().EatAndDrink();
new MaQue().Fly();

Bird1 bd1 = new Bird1();
bd1.Fly(); //鸟飞的方法

IFlyable ifly = new Bird1(); //如果接口的方法显示声明了，就会执行接口的方法。
ifly.Fly(); //接口飞的方法

抽象类和接口：

interface interfaceRun
{
void Run();
}

abstract class abserson : interfaceRun
{
static string name;

public static void Hello()
{
Console.WriteLine("hello");
}

public void how()
{
Console.WriteLine("how");
}

protected abstract void smile();

public abstract void Run();

}

class xiaohai : abserson
{
public override void Run()
{
Console.WriteLine("xiaohai run");
}

protected override void smile()
{
Console.WriteLine("xiaohai smile");
}

public new void how()
{
Console.WriteLine("xiaohai how");
}

}

xiaohai xh = new xiaohai();
xh.Run();
xh.how();

abserson.Hello();//调用抽象类中非抽象成员

好了，知识点差不多就这么些，简单运用做下练习。

一个是火车购票：用了抽象、简单工厂、反射。

一个是简单的小游戏：后台存储数据用了EF。

http://files.cnblogs.com/files/buzhidaojiaoshenme/%E7%81%AB%E8%BD%A6%E8%B4%AD%E7%A5%A8.rar

http://files.cnblogs.com/files/buzhidaojiaoshenme/%E5%B0%8F%E6%B8%B8%E6%88%8F.rar

C#相关知识小结