相同的函數名相同的簽名是錯誤的，但是相同的函數名不同的簽名是可行的。
委托
引用存儲為函數的類型。生命使用delegate關鍵字，指定一個函數的簽名，包含一個返回類型和參數列表。定義委托後，可以聲明該委托類型的變量。初始化該變量使為和該委托有相同函數簽名的函數引用使用。就可以使用委托變量來調用這個函數。對該變量的使用就如同使用函數一樣。
有了引用函數變量，可以執行其它方式無法完成的操作。：把委托變量作為參數傳遞給一個函數。則該函數就可以通過委托調用它引用的函數，而且在運行前不需要知道是哪個函數。
delegate double ProcessDelegate(double param1,double param2);
static double Multiply(double param1,double param2){return param1*param2;}
static double Divide(double param1,double param2){return param1/param2;}
Main(string[] args)
{
string MainParam1,MainParam2;
ProcessDelegate process;
process=new ProcessDelegate(Multiply};
Console.WriteLine("{0}",process(MainParam1,MainParam2));
ProcessDelegate process2=new ProcessDelegate(Divide);
Console.WriteLine("0",process1(MainParam1,MainParam2));
}
在委托引用函數的時候需要給出的是沒有雙引號的函數名而不是函數內部的參數。
面向對象編程oop
封裝了部分應用程序的組件為對象。UMLUniversal Modeling Language語法研究類和對象。屬性，字段，方法
對象的生命周期：構造階段的構造函數，分配內存空間，初始化類的參數。
析構函數，對象占用的資源。
靜態和實例類對象，靜態成員，靜態屬性，靜態方法，不需要實例化對象。
接口將隱式的公共方法和屬性組合，封裝成特定功能的一個集合。
繼承：C#中的對象只能派生於一個基類。派生類不能訪問基類的私有成員。但是派生類和外部代碼都可以訪問公共成員。派生類可以訪問protected，基類和外部代碼不可訪問。同時，基
類可以定義為抽象類，這樣不能實例化，需要通過繼承類進行。
多態性：
繼承的結果是派生於基類的類在方法和屬性上面有一定的重疊。基類Animal有方法EatFood(),從派生類Cow和Chicken進行調用
Animal cow=new Animal();
Animal Chicken=new Animal();
cow.EatFood();
Chicken.EatFodd();
把某個基本類型的變量賦予其派生類型的變量。
Animal myAnimal=mycow;
基本類型的變量轉換為派生類的變量，調用派生類的方法。
Cow mycow=(Cow)myAnimal;
mycow.Moo();
System.Object是繼承層次的根。所有的對象可以看做為是類Object的一個實例。
接口的多態性：
建立接口類型的變量，可以在支持該接口的對象上，使用這個變量訪問該接口提供的方法和屬性。
不使用基類的方法EatFood()而是將該方法放入接口的內部，由於接口不提供執行代碼，派生類Cow等支持接口，但是要提供接口內部該方法的執行代碼：
Cow myCow=new Cow();
Chicken myChicken=new Chicken();
IConsume consumeinterface;
consumeinterface=myCow;
consumeinterface.EatFood();
consumeinterface=myChicken;
consumeinterface.EatFood();
對象之間的包含關系，集合關系，Animal[] animals=new Animal[5];
class myclass{};
internal class myclass{};
public class myclass{};
public abstract myclass{};
public seales myclass{};
規定派生類不能比繼承的基類可訪問性高：
public class mypubclass{};
internal class myinterclass:mypubclass{};
規定派生類繼承時如果有基類要寫在接口前面。
public class myclass:MyBase,InterFace1,InterFace2{}
none internal 只能在項目內訪問
public 可以在任何地方訪問
abstract Or internal abstract 只能在當前項目內訪問，不能實例化，只能繼承
sealed Or internal sealed 只能在當前項目中訪問，不能派生，只能實例化
public sealed 能在任何項目訪問，不能派生，只能實例化
namespace swk
{
public abstract class mybase{}//公共抽象類
internal class myclass:mybase{}//內部類
public interface Imybaseinterface{}//公共接口
internal interface Imybaseinterface2{}//內部接口
internal interface Imyinterface:Imybaseinterface,Imybaseinterface2{}//內部接口繼承了公共接口和內部接口
internal Sealed class myComplexclass:myclass,Imyinterface{}
class Class1
{
static void main(string[] args)
{
MyComplexclass myobj=new MyComplexclass();
Console.writeLine(myobj.ToString());
}
}
}
class myclass
{
public myclass(){};//構造函數
public ~myclass(){};//析構函數
}
構造函數的隊列
class mybaseclass
{
public mybaseclass(){}
public mybaseclass(int i){}
}
class myclass:mybaseclass
{
public myclass(){}
public myclass(){int i}
public myclass(){int i,int j}
}
myclass myobj=new myclass();
構造隊列：
System.object.Object();
mybaseclass.mybaseclass();
myclass.myclass();
myclass myobj=new myclass(4);
構造隊列：
System.Object().Object();
mybaseclass.mybaseclass(int i);
myclass.myclass(int i);
myclass myobj=new myclass*3,5);
構造隊列：
System.Object.Object();
mybaseclass.mybaseclass();
myclass.myclass(int i,int j);
public class mybase
{
public mybase(){}
public mybase(){int i}
}
public class myclass:mybase
[
public myclass():base(i);
public myclass(int i);
public myclass(int i,int j);
}
myclass myobj=new myclass();
構造對列：
System.Object.Object();
mybase.mybase(int i);
myclass.myclass();
public class mybase
{
public mybase(){};
public mybase(int i){};
}
public class myclass:mybase
{
public myclass():this(5,6){}
public myclass(int i){};
public myclass(int i,int j){}
}
myclass myobj=new myclass();
構造隊列：
System.Object.Object();
mybase.mybase();
myclass.myclass(5,6);
myclass.myclass();
派生類只能繼承於一個基類，只能直接繼承於一個抽象類，可以通過繼承鏈來繼承多個抽象類。
類可以有多個接口。
抽象類可以擁有抽象成員（沒有代碼體，必須在派生類中執行，否則派生類本身必須也是抽象的）和非抽象成員（它們擁有代碼體，可以是虛擬的，可以在派生類中重寫）。
接口成員必須都在使用接口的類上執行，它們沒有代碼體。接口成員定義為公共的，傾向於外部使用，抽象類的成員可以是私有的，受保護的，內部的或受保護的內部成員（其中受保護的內部成員只能在應用程序的代碼或派生類中訪問），接口不能包含字段、構造函數、析構函數、靜態成員或常量。
namespace
{
public class myclass{public int myclassint;}
struct mystruct{public int mystruct;}
class class1
{
static void Main(string[] args)
{
myclass mc1=new myclass();
myclass mc2=mc1;
mc1.myclassint=10;
mc2.myclassint=20;
mystruct mys1=new mystruct();
mystruct mys2=mys1;
mys1=10;
mys2=20;
}
}
}
myc1=20;
myc2=20;
mys1=10;
mys2=20;
public 認可代碼可以訪問
private 由類中的代碼訪問
internal 項目內部的代碼訪問
protected 類中的代碼或者派生類可以訪問
public readonly 公共只讀 readonly說明只能在構造函數裡面給初值
Class myclass
{
public string getString()
{
return "hear is a string";
}
}
virtual 可以重寫
abstract 方法必須重寫
override 重寫了以個基類的方法，當方法被重寫，必須使用該關鍵字
extern 方法定義在其它地方
public class myclass
{
public virtual DOSomething()
{
//base implementation
}
}
public class mysecondclass:myclass
{
public override DOSomething()
{
//SecondClass implenmentation,overrides base implementation
}
}
可以使用Sealed關鍵字，說明方法不能在派生類中進一步的修改
public class mysecondclass:myclass
{
public Sealed DOSomething()
{
//SecondClass implenmentation,overrides base implementation
}
}
對於屬性的定義：get set
public class myclass
{
private int myint;
public int MyintPop
{
get{return myint;}
set{if(value<10&&value>3)myint=value;else throw(new ArgumentOutOfRangeException("MyintPop",value,"MyintPop值要在0~10之間"));}
}
}
using System;
namespace Try
{
/// <summary>
/// myClass 的摘要說明。
/// </summary>
public class myClass//自定義一個類，公共，可以由任何代碼使用
{
public readonly string name;//只可以在構造函數裡面初始化
private int valint;//私有的整型函數，私有字段
public myClass(string newName)//自定義構造函數，初始化公共字段
{
name=newName;
//
// TODO: 在此處添加構造函數邏輯
//
}
public myClass():this("DefaultName")//構造函數，在整型默認構造函數前使用自定義構造函數
{
}
public int ValIntPop//公共屬性
{
get
{
return valint;//讀取屬性
}
set
{
if(value>=0&value<=10){valint=value;}//設置屬性，超出范圍輸出異常
else{throw(new ArgumentOutOfRangeException("MyValInt",value,"ValIntPop定義在10～0之間"));}
}
}
public override string ToString()//重寫ToString()
{
return "value:"+valint+"Name:"+name;
}
}
}
