class A{
  public A(){}
  public A(string a):this(){}//表示调用上面的无参构造,this就表示调用本类的方法
  public A(int a):this("123"){}      //表示调用上面的string参数类型的构造
}

Animal类中的shout方法改成以下代码：
public virtual void shout(){...}

Dog类中的shout方法改成以下代码：
public override void shout(){...}//即覆写掉父类的属性或方法
//如果Dog还有子类，想继续覆写就不用再在Dog类中的方法加virtual关键字了，直接使用override就行了
如：Dog类中还有一个子类Dog1，覆写Dog中的shout方法
直接在Dog1中加下一代吗即可：
public override void shout(){...}

public abstract class  Animal{
	public abstract void shout();//抽象方法也要使用abstract关键字，抽象类不能直接实例化，需要子类继承并且子类必须覆写抽象类的抽象方法（即在方法返回值前面加上override关键字，此时就不需要在抽象方法前面加上virtual关键字了）
}
注意：抽象类中也可以写普通方法

public 返回值类型 属性名称{get;set；}
如下代码：
public string name{get;set;}

如下代码：
interface IFly{
   public void Fly();//这里的public可以省略，因为接口中的方法或属性只能是public权限 
} 

class A:B,C{

}

class Program{
	struct Location//结构体
	{
		public int X;
		public int Y;

		public Location(int x,int y){this.X=x;this.Y=y}//此处不允许定义无参构造
	}
	static void Test(Location loc){
		loc.X=1;
		loc.Y=1;
	}
	static void main(string[] args){
		Location loc=new Location(0,0);
		Test(loc);
	}
}

//1
static T Sum<T>(List<T> nums) where T:struct//这里的where是对泛型的约束，struct表示数值型
{
	T sum =default(T);//表示给sum赋初值（即数值型默认的值）
	return sum;
}
//2
class Test{
　　public void X();
}
static void TestFunc<T>() where T:Test,new(){//如果这里不加new()，下面不能使用new T()；如果这里
不加Test约束，下面不能调用Test类
　　T t=new T();
t.X();

}

public static bool operator ==(Location lhs,Locations rhs){
	return false;
}

//1.IDisposable是一个自动释放资源的接口，里面有一个Dispose方法
//在读写流或者需要使用close()关闭的地方使用using()结合此接口使用
static void Main(string args[]){
	using(StreamWriter sq=new StreamWriter(new FileStream("777.txt",FileMode.Create,FileAccess.Write))){
		sq.WriteLine("123");
	}
}//此时在执行using的时候，在using语句执行完毕之前会自动执行IDisposable接口的Dispose方法从而自动释放资源

class Program
{
	//1.声明委托类型
	delegate bool Function(int num);
	static Function BigThan10=delegate(int n){//此处的n与上面的num一一对应
　　　　　　return n>=10;
　　　　　　};

	//2.修改形参列表
	static List<int> Traverse(List<int> nums,Function function){
		var list=new List<int>();

		foreach(var num int nums){
			if(function(num)){
				list.Add(num);
			}
		}
		return list;
	}
	//3.传入委托
	static void Main(string[] args){
		Traverse(new List<int>(){1,2,3,4,5},BigThan10);//传入委托
		Console.WriteLine();
		Console.ReadLine();
	}
}

//语法：(type var,...)=>{...}//加类型
	(var,...)=>{...}//不加类型
	var=>{...}//一个参数的时候
	()=>{...}//没有参数的时候
//17中的第三部传入委托也可以也成
Traverse(new List<int>(){1,2,3,4,5},delegate(int n){return n>=10;});//显然这样写有点啰嗦，

使用Lambda表达式可以简化成：
(1)　　Traverse(new List<int>(){1,2,3,4,5},(int n)=>{return n>=10;});
(2)　　Traverse(new List<int>(){1,2,3,4,5},(n)=>{return n>=10;});
(3)如果只有一个参数括号也不用写了：Traverse(new List<int>(){1,2,3,4,5},n=>{return n>=10;});

Traverse(new List<int>(){1,2,3,4,5},n=> n>=10);//将return也去掉

（1）Action<> 例：List<T>.ForEach()
（2）Func<> 例List<T>.Sum()
（3）Predicate<> 例 List<T>.FindAll()
　　　　　　　例 List<T>.Find()

var list=new List<int>(){1,2,3,4,5,6};
list.Foreach(i=>{Console.WriteLine(i)});//这里的i表示list集合中的一个个值

class Program
{
//1.声明委托类型
static Func<int, bool> BigThan10 = delegate(int n)
{
return n>=4;
};

//2.修改形参列表
static List<int> Traverse(List<int> nums, Func<int, bool> function){
var list=new List<int>();

foreach(var num in nums){
if(function(num)){
list.Add(num);
}
}
return list;
}
//3.传入委托
static void Main(string[] args)
{
var list=new List<int>(){1,2,3,4,5,6};
var n=Traverse(list, BigThan10);
n.ForEach(i=>Console.WriteLine(i));
Console.ReadLine();

}
}