函數(shù)重載

相同的函數(shù)名相同的簽名是錯誤的，但是相同的函數(shù)名不同的簽名是可行的。

委托

引用存儲為函數(shù)的類型。生命使用delegate關(guān)鍵字，指定一個函數(shù)的簽名，包含一個返回類型和參數(shù)列表。定義委托后，可以聲明該委托類型的變量。初始化該變量使為和該委托有相同函數(shù)簽名的函數(shù)引用使用。就可以使用委托變量來調(diào)用這個函數(shù)。對該變量的使用就如同使用函數(shù)一樣。

    有了引用函數(shù)變量，可以執(zhí)行其它方式無法完成的操作。：把委托變量作為參數(shù)傳遞給一個函數(shù)。則該函數(shù)就可以通過委托調(diào)用它引用的函數(shù)，而且在運行前不需要知道是哪個函數(shù)。

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));
}
在委托引用函數(shù)的時候需要給出的是沒有雙引號的函數(shù)名而不是函數(shù)內(nèi)部的參數(shù)。
面向?qū)ο缶幊蘯op
封裝了部分應(yīng)用程序的組件為對象。umluniversal modeling language語法研究類和對象。屬性，字段，方法
對象的生命周期：構(gòu)造階段的構(gòu)造函數(shù)，分配內(nèi)存空間，初始化類的參數(shù)。
析構(gòu)函數(shù)，對象占用的資源。
靜態(tài)和實例類對象，靜態(tài)成員，靜態(tài)屬性，靜態(tài)方法，不需要實例化對象。
接口將隱式的公共方法和屬性組合，封裝成特定功能的一個集合。
繼承：c#中的對象只能派生于一個基類。派生類不能訪問基類的私有成員。但是派生類和外部代碼都可以訪問公共成員。派生類可以訪問protected，基類和外部代碼不可訪問。同時，基

類可以定義為抽象類，這樣不能實例化，需要通過繼承類進行。
多態(tài)性：
繼承的結(jié)果是派生于基類的類在方法和屬性上面有一定的重疊。基類animal有方法eatfood(),從派生類cow和chicken進行調(diào)用
animal cow=new animal();
animal chicken=new animal();
cow.eatfood();
chicken.eatfodd();
把某個基本類型的變量賦予其派生類型的變量。
animal myanimal=mycow;
基本類型的變量轉(zhuǎn)換為派生類的變量，調(diào)用派生類的方法。
cow mycow=(cow)myanimal;
mycow.moo();
system.object是繼承層次的根。所有的對象可以看做為是類object的一個實例。
接口的多態(tài)性：
建立接口類型的變量，可以在支持該接口的對象上，使用這個變量訪問該接口提供的方法和屬性。
不使用基類的方法eatfood()而是將該方法放入接口的內(nèi)部，由于接口不提供執(zhí)行代碼，派生類cow等支持接口，但是要提供接口內(nèi)部該方法的執(zhí)行代碼：
cow mycow=new cow();
chicken mychicken=new chicken();
iconsume consumeinterface;
consumeinterface=mycow;
consumeinterface.eatfood();
consumeinterface=mychicken;
consumeinterface.eatfood();
對象之間的包含關(guān)系，集合關(guān)系，animal[] animals=new animal[5];

class myclass{};
internal class myclass{};
public class myclass{};
public abstract myclass{};
public seales myclass{};
規(guī)定派生類不能比繼承的基類可訪問性高：
public class mypubclass{};
internal class myinterclass:mypubclass{};
規(guī)定派生類繼承時如果有基類要寫在接口前面。
public class myclass:mybase,interface1,interface2{}
none internal 只能在項目內(nèi)訪問
public 可以在任何地方訪問
abstract or internal abstract 只能在當(dāng)前項目內(nèi)訪問，不能實例化，只能繼承
sealed or internal sealed 只能在當(dāng)前項目中訪問，不能派生，只能實例化
public sealed 能在任何項目訪問，不能派生，只能實例化

namespace swk
{
 public abstract class mybase{}//公共抽象類
 internal class myclass:mybase{}//內(nèi)部類
 public interface imybaseinterface{}//公共接口
 internal interface imybaseinterface2{}//內(nèi)部接口
 internal interface imyinterface:imybaseinterface,imybaseinterface2{}//內(nèi)部接口繼承了公共接口和內(nèi)部接口
 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(){};//構(gòu)造函數(shù)
 public ~myclass(){};//析構(gòu)函數(shù)
}

構(gòu)造函數(shù)的隊列
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();
構(gòu)造隊列：
system.object.object();
mybaseclass.mybaseclass();
myclass.myclass();

myclass myobj=new myclass(4);
構(gòu)造隊列：
system.object().object();
mybaseclass.mybaseclass(int i);
myclass.myclass(int i);

myclass myobj=new myclass*3,5);
構(gòu)造隊列：
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();
構(gòu)造對列：
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();
構(gòu)造隊列：
system.object.object();
mybase.mybase();
myclass.myclass(5,6);
myclass.myclass();

派生類只能繼承于一個基類，只能直接繼承于一個抽象類，可以通過繼承鏈來繼承多個抽象類。
類可以有多個接口。
 抽象類可以擁有抽象成員（沒有代碼體，必須在派生類中執(zhí)行，否則派生類本身必須也是抽象的）和非抽象成員（它們擁有代碼體，可以是虛擬的，可以在派生類中重寫）。
 接口成員必須都在使用接口的類上執(zhí)行，它們沒有代碼體。接口成員定義為公共的，傾向于外部使用，抽象類的成員可以是私有的，受保護的，內(nèi)部的或受保護的內(nèi)部成員（其中受保護的內(nèi)部成員只能在應(yīng)用程序的代碼或派生類中訪問），接口不能包含字段、構(gòu)造函數(shù)、析構(gòu)函數(shù)、靜態(tài)成員或常量。

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 認(rèn)可代碼可以訪問
private 由類中的代碼訪問
internal 項目內(nèi)部的代碼訪問
protected 類中的代碼或者派生類可以訪問

public readonly 公共只讀 readonly說明只能在構(gòu)造函數(shù)里面給初值

class myclass
{
 public string getstring()
 {
  return "hear is a string";
 }
}
virtual 可以重寫
abstract 方法必須重寫
override 重寫了以個基類的方法，當(dāng)方法被重寫，必須使用該關(guān)鍵字
extern 方法定義在其它地方

public class myclass
{
 public virtual dosomething()
 {
  //base implementation
 }
}
public class mysecondclass:myclass
{
 public override dosomething()
 {
  //secondclass implenmentation,overrides base implementation
 }
}

可以使用sealed關(guān)鍵字，說明方法不能在派生類中進一步的修改
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;//只可以在構(gòu)造函數(shù)里面初始化
  private int valint;//私有的整型函數(shù)，私有字段
  public myclass(string newname)//自定義構(gòu)造函數(shù)，初始化公共字段
  {
   name=newname;
   //
   // todo: 在此處添加構(gòu)造函數(shù)邏輯
   //
  }
  public myclass():this("defaultname")//構(gòu)造函數(shù)，在整型默認(rèn)構(gòu)造函數(shù)前使用自定義構(gòu)造函數(shù)
  {

  }
  public int valintpop//公共屬性
  {
   get
   {
    return valint;//讀取屬性
   }
   set
   {
    if(value>=0&value<=10){valint=value;}//設(shè)置屬性，超出范圍輸出異常
    else{throw(new argumentoutofrangeexception("myvalint",value,"valintpop定義在10～0之間"));}
   }
  }
  public override string tostring()//重寫tostring()
  {
   return "value:"+valint+"name:"+name;
  }

 }
}