|
C# 是物件導向的程式設計語言，每一個函數都屬於一個類。
Static：當一個方法被聲明為Static時，這個方法是一個靜態方法，編譯器會在編譯時間保留這個方法的實現。也就是說，這個方法屬於類，但是不屬於任何成員，不管這個類的執行個體是否存在，它們都會存在。就像入口函數Static
void Main，因為它是靜態函數，所以可以直接被調用。
Virtua：當一個方法被聲明為Virtual時，它是一個虛擬方法，直到你使用ClassName variable = new
ClassName();聲明一個類的執行個體之前，它都不存在於真實的記憶體空間中。這個關鍵字在類的繼承中非常常用，用來提供類方法的多態性支援。
overrride：表示重寫
這個類是繼承於Shape類
public override double Area 這個屬性再shape中肯定存在 但是這裡我們不想用shape中的
所以要重寫
virtual，abstract是告訴其它想繼承於他的類 你可以重寫我的這個方法或屬性，否則不允許。
一個生動的例子
:老爸表示基類（被繼承的類）
兒子表示子類（繼承的類）
老爸用virtual告訴兒子:"孩子,你要繼承我的事業,在這塊上面可以自己繼續發展你自己的"
兒子用override告訴全世界:"這個我可不是直接拿我爸的,他只是指個路給我,是我自己奮鬥出來的"
abstract：抽象方法聲明使用，是必須被衍生類別覆寫的方法，抽象類別就是用來被繼承的；可以看成是沒有實現體的虛方法；如果類中包含抽象方法，那麼類就必須定義為抽象類別，不論是否還包含其他一般方法；抽象類別不能有實體的。
執行個體解答:
interface:用來聲明介面
1.只提供一些方法規約，不提供方法主體.
如:
public interface IPerson
{
void
getName();//不包含方法主體
}
2.方法不能用public abstract等修飾,無欄位變數，無建構函式。
3.方法可包含參數。
如
public interface IPerson
{
void getAge(string
s);
}
一個例子(例1)：
public interface IPerson
{
IPerson();
//錯誤
string name; //錯誤
public void getIDcard();//錯誤
void getName();
//right
void getAge(string s); //right
}
實現interface的類
1.與繼承類的格式一致，如
public class Chinese:IPerson{}
2.必須實現 interface 中的各個方法
例2，繼承例1
public
class Chinese:IPerson
{
public Chinese(){} //添加構造
public void
getName(){} //實現getName()
public void getAge(string s){}
//實現getAge()
}
abstract:聲明抽象類別、抽象方法
1.抽象方法所在類必須為抽象類別
2.抽象類別不能直接執行個體化，必須由其衍生類別實現。
3.抽象方法不包含方法主體，必須由衍生類別以override方式實現此方法,這點跟interface中的方法類似
如
public
abstract class Book
{
public Book()
{
}
public abstract void
getPrice(); //抽象方法，不含主體
public virtual void getName()
//虛方法，可覆蓋
{
Console.WriteLine("this is a test:virtual
getName()");
}
public virtual void getContent()
//虛方法，可覆蓋
{
Console.WriteLine("this is a test:virtual
getContent()");
}
public void getDate()
//一般方法，若在衍生類別中重寫，須使用new關鍵字
{
Console.WriteLine("this is a test: void
getDate()");
}
}
public class JavaBook:Book
{
public override
void getPrice() //實現抽象方法，必須實現
{
Console.WriteLine("this is a test:JavaBook
override abstract getPrice()");
}
public override void getName()
//覆蓋原方法，不是必須的
{
Console.WriteLine("this is a test:JavaBook override
virtual getName()");
}
}
測試如下：
public class test
{
public
test()
{
JavaBook jbook=new JavaBook();
jbook.getPrice();
//將調用JavaBook中getPrice()
jbook.getName();
//將調用JavaBook中getName()
jbook.getContent();
//將調用Book中getContent()
jbook.getDate(); //將調用Book中getDate()
}
public
static void Main()
{
test t=new
test();
}
}
virtual:標記方法為虛方法
1.可在衍生類別中以override覆蓋此方法
2.不覆蓋也可由對象調用
3.無此標記的方法(也無其他標記)，重寫時需用new隱藏原方法
abstract
與virtual : 方法重寫時都使用 override
關鍵字
介面定義以大寫字母I開頭。方法只定義其名稱,在C#中，方法預設是公有方法；用public修飾方法是不允許的,否則會出現編譯錯誤；介面可以從別的介面繼承，如果是繼承多個介面，則父介面列表用逗號間隔。
介面可以通過類來實現，當類的基列表同時包含基類和介面時，列表中首先出現的是基類；類必須要實現其抽象方法；
介面使用：見代碼（轉）
interface使用
interface使用（執行個體一）
using System;
namespace Dage.Interface
{
//印表機介面
public interface IPrint
{
string returnPrintName();
}
}
//--------------------------------------------
using System;
using
Dage.Interface;
namespace Dage.Print
{
//HP牌印表機類
public class
HP: IPrint
{
public string returnPrintName()
{
return
"這是HP牌印表機";
}
}
}
//--------------------------------------------
using System;
namespace Dage.Print
{
//Eps牌印表機類
public class
Eps: IPrint
{
public string returnPrintName()
{
return
"這是Eps牌印表機";
}
}
}
//--------------------------------------------
using System;
using
Dage.Interface;
namespace Dage
{
//列印類
public class Printer
{
public Printer()
{}
public string PrintName(IPrint iPrint)
{
return iPrint.returnPrintName();
}
}
}
//--------------------------------------------
--WinFrom中調用代碼:
private void button1_Click(object sender, System.EventArgs e)
{
Printer p= new Printer();
switch (this.comboBox1.Text)
{
case
"HP":
MessageBox.Show(p.PrintName(new HP()));
break;
case "Eps":
MessageBox.Show(p.PrintName(new Eps()));
break;
default:
MessageBox.Show("沒有發現這個品牌！");
break;
}
} --------------------------------------------------------------------------------------------------------------------------------------static的用法
要理解static，就必須要先理解另一個與之相對的關鍵字，很多人可能都還不知道有這個關鍵字，那就是auto，其實我們通常聲明的不用static修飾的變數，都是auto的，因為它是預設的，就象short和long總是預設為int一樣；我們通常聲明一個變數：
int
a;
string
s;
其實就是：
auto
int a;
auto string
s;
而static變數的聲明是：
static
int a;
static string
s;
這樣似乎可以更有利於理解auto和static是一對成對的關鍵字吧，就像private，protected，public一樣；
對於static的不理解，其實就是對於auto的不理解，因為它是更一般的；有的東西你天天在用，但未必就代表你真正瞭解它；auto的含義是由程式自動控制變數的生存周期，通常指的就是變數在進入其範圍的時候被分配，離開其範圍的時候被釋放；而static就是不auto，變數在程式初始化時被分配，直到程式退出前才被釋放；也就是static是按照程式的生命週期來分配釋放變數的，而不是變數自己的生命週期；所以，像這樣的例子：
void
func()
{
int
a;
static int
b;
}
每一次調用該函數，變數a都是新的，因為它是在進入函數體的時候被分配，退出函數體的時候被釋放，所以多個線程調用該函數，都會擁有各自獨立的變數a，因為它總是要被重新分配的；而變數b不管你是否使用該函數，在程式初始化時就被分配的了，或者在第一次執行到它的聲明的時候分配（不同的編譯器可能不同），所以多個線程調用該函數的時候，總是訪問同一個變數b，這也是在多線程編程中必須注意的！
static的全部用法：
1．類的靜態成員：
class
A
{
private:
static
int
s_;
};
在cpp中必須對它進行初始化：
int
A::s_ = 0;//
注意，這裡沒有static的修飾！
類的靜態成員是該類所有執行個體的共用成員，也就是在該類的範疇內是個全域變數，也可以理解為是一個名為A::s_的全域變數，只不過它是帶有類安全屬性的；道理很簡單，因為它是在程式初始化的時候分配的，所以只分配一次，所以就是共用的；
類的靜態成員必須初始化，道理也是一樣的，因為它是在程式初始化的時候分配的，所以必須有初始化，類中只是聲明，在cpp中才是初始化，你可以在初始化的代碼上放個斷點，在程式執行main的第一條語句之前就會先走到那；如果你的靜態成員是個類，那麼就會調用到它的建構函式；
2．類的靜態函數：
class
A
{
private:
static
void func(int
);
};
實現的時候也不需要static的修飾，因為static是聲明性關鍵字；
類的靜態函數是在該類的範疇內的全域函數，不能訪問類的私人成員，只能訪問類的靜態成員，不需要類的執行個體即可調用；實際上，它就是增加了類的存取權限的全域函數：void
A::func(int)；
靜態成員函數可以繼承和覆蓋,但無法是虛函數;
3．只在cpp內有效全域變數：
在cpp檔案的全域範圍內聲明：
static
int g_ =
0;
這個變數的含義是在該cpp內有效，但是其他的cpp檔案不能訪問這個變數；如果有兩個cpp檔案聲明了同名的全域靜態變數，那麼他們實際上是獨立的兩個變數；
如果不使用static聲明全域變數：
int
g_ =
0;
那麼將無法保證這個變數不被別的cpp共用，也無法保證一定能被別的cpp共用，因為要讓多個cpp共用一個全域變數，應將它聲明為extern（外部）的；也有可能編譯會報告變數被重複定義；總之不建議這樣的寫法，不明確這個全域變數的用法；
如果在一個標頭檔中聲明：
static
int g_vaule =
0;
那麼會為每個包含該標頭檔的cpp都建立一個全域變數，但他們都是獨立的；所以也不建議這樣的寫法，一樣不明確需要怎樣使用這個變數，因為只是建立了一組同名而不同範圍的變數；
這裡順便說一下如何聲明所有cpp可共用的全域變數，在標頭檔裡聲明為extern的：
extern
int g_; //
注意，不要初始化值！
然後在其中任何一個包含該標頭檔的cpp中初始化（一次）就好：
int
g_ = 0; //
初始化一樣不要extern修飾，因為extern也是聲明性關鍵字；
然後所有包含該標頭檔的cpp檔案都可以用g_這個名字訪問相同的一個變數；
4．只在cpp內有效全域函數：
在cpp內聲明：
static
void
func();
函數的實現不需要static修飾，那麼這個函數只可在本cpp內使用，不會同其他cpp中的同名函數引起衝突；道理和如果不使用static會引起的問題和第3點一樣；不要在標頭檔中聲明static的全域函數，不要在cpp內聲明非static的全域函數，如果你要在多個cpp中複用該函數，就把它的聲明提到標頭檔裡去，否則在cpp內部聲明需要加上static修飾；在C語言中這點由為重要！ |
