c# 類學習

1、構造函數：

構造函數是允許將類實例初始化為有效狀態的特殊方法，類被實例化時，自動執行構造函數。
如代碼：

using System;
class A
{
    public A()
    {
        Console.WriteLine("運行構造函數");
    }
 }

class Test
{
    static void Main()
    {
        //實例化a時，會自動執行構造函數
        A a=new A ();
        Console.ReadLine();
    }    
 }

/**//*
 *結果為：
 *運行構造函數
 */

2、類中成員變量賦值

如果類中有成員變量時，在實例化之前，成員變量分配的空間為0，在實例化時，如果成員變量未賦初值，則成員變量值會自動變為0或Null。
如代碼：

using System;
class A
{
    public int i;
    public string s;
}

class Test
{
    static void Main()
    {
        A a=new A ();
        Console.WriteLine("i=",a.i);
        Console.WriteLine("s=",a.s);
        Console.ReadLine();
    }    
 }

/**//*
 *結果為：
 * 0
 * NUll
 */

3、類的重載

類的構造函數允許被重載，重載方法與方法重載一樣。
如代碼：

using System;
class A
{
    public int i;
    public string s;
    public A()
    {
    }
    
    //重載構造函數1
    public A(int i)
    {
        this.i=i;
    }
    
    //重載構造函數2
    public A(string s)
    {
        this.s=s;
    }
    
    //重載構造函數3
    public A(int i,string s)
    {
        this.i=i;
        this.s=s;
    }
    
}

class Test
{
    static void Main()
    {
        A a=new A();        
        Console.ReadLine();
    }
}

4、類中This用法

    This是類中隱含的指針，類被實例化時，會將實例化後的對象的地址傳遞給變量。This不代表類本身，而是指類實例化後所產生的類的對象。
如上面代碼中

如上面代碼中
    //重載構造函數1
    public A(int i)
    {        
        this.i=i;
    }
//this.i=i,表示實例化後的a。
//this.i表示a中的i,而後邊的i表示形參i

5、類中重載構造函數調用無參構造函數

類中有成員變數時,如果成員變數賦了初值,這樣每次實例化時,都會被賦初值.這樣會造成代碼冗餘的問題.我們可以定義成員變量,在無參構造函數中賦初值,其他有參構造函數都調用無參構造函數.用:this(),這樣無參函數就會先調用無參構造函數,然後在調用自己代碼。

如代碼：

using System;
class A
{
    public int i;
    public string s;
    public A()
    {
        i=100;
        s="string";
    }
    
    //重載構造函數1
    public A(int i):this()
    {
        this.i=i;
    }
    
    //重載構造函數2
    public A(string s):this()
    {
        this.s=s;
    }
    
    //重載構造函數3
    public A(int i,string s):this()
    {
        this.i=i;
        this.s=s;
    }
    
}

class Test
{
    static void Main()
    {
        A a=new A();
        Console.WriteLine("我是第一個構造器函數產生的");
        Console.WriteLine(a.i);
        Console.WriteLine(a.s);
        
        A a1=new A(1);
        Console.WriteLine("我是第二個構造器函數產生的");
        Console.WriteLine(a1.i);
        Console.WriteLine(a1.s);
        
        A a2=new A("第三個構造器函數參數");
        Console.WriteLine("我是第三個構造器函數產生的");
        Console.WriteLine(a2.i);
        Console.WriteLine(a2.s);
        
        A a3=new A(3,"第四個構造器函數參數");
        Console.WriteLine("我是第四個構造器函數產生的");
        Console.WriteLine(a3.i);
        Console.WriteLine(a3.s);
        
        Console.ReadLine();
    }
}

/**//*
結果：
我是第一個構造器函數產生的
100
string
我是第二個構造器函數產生的
1
string
我是第三個構造器函數產生的
100
第三個構造器函數參數
我是第四個構造器函數產生的
3
第四個構造器函數參數

*/

6、類的繼存

類的繼存用 "：被繼存的類 "的方式。當實例化繼存的類時，首先會執行父類的構造函數，然後在執行自己的構造函數。
如代碼：

using System;
class A
{
    public A()
    {
        Console.WriteLine("A類的無參構造函數");
    }
}

//B繼存A，A為B的父類
class B:A
{
    public B()
    {
        Console.WriteLine("B類的無參構造函數");
    }
}

class Test
{
    static void Main()
    {
        B b=new B();
        Console.ReadLine();
    }
}

/**//*
結果為:
A類的無參構造函數
B類的無參構造函數
*/

7、類繼存注意問題

7.1父類A一定要有一個無參構造函數。如果類A沒有無參構造函數時，程式會出錯。
      7.2類在沒有有參構造函數時會自動生成無參構造函數，當有有參構造函數時，類就不會自動生成無參構造函數。
      7.3當類繼存時，父類要寫明無參構造函數。如下例中類B會自動調用父類A的無參構造函數。因為類會自動生成無參構造函數。即使類B沒有寫明無參構造函數，但會自動生成，他會尋找父類的無參構造函數。
如代碼：

using System;
class A
{
    public A()
    {
        Console.WriteLine("A類的無參構造函數");
    }
    public A(int i)
    {
        Console.WriteLine("A類的一個整型參數構造函數");
    }
}

//B繼存A，A為B的父類
class B:A
{
    public B()
    {
        Console.WriteLine("B類的無參構造函數");
    }
    public B(int i)
    {
        Console.WriteLine("B類的一個整型參數構造函數");
    }
}

class Test
{
    static void Main()
    {
        B b=new B(100);
        Console.ReadLine();
    }
}

/**//*結果
 * A類的無參構造函數
 * B類的一個整型參數構造函數
*/

8、指定構造函數

類中用“Base：執行父類”的方式指定的執行的構造函數
如代碼：

using System;
class A
{
    public A()
    {
        Console.WriteLine("A類的無參構造函數");
    }
    public A(int i)
    {
        Console.WriteLine("A類的一個整型參數構造函數");
    }
}

//B繼存A，A為B的父類
class B:A
{
    public B()
    {
        Console.WriteLine("B類的無參構造函數");
    }
    //Base:執行父類指定的構造函數，此處只會執行類A的public A(int i)構造函數
    public B(int i):base(50)
    {
        Console.WriteLine("B類的一個整型參數構造函數");
    }
}

class Test
{
    static void Main()
    {
        B b=new B(100);
        Console.ReadLine();
    }
}
/**//*
A類的一個整型參數構造函數
B類的一個整型參數構造函數
*/

9、靜態構造函數
    9.1靜態構造函數是實現對一個類進行初始化的方法。它一般用於對靜態資料的初始化。靜態構造函數不能有參數，不能有修飾符，而且不能被調用，當類被載入時，類的靜態構造函數自動被調用。
    9.2特點：
        在一個程式的執行過程中，靜態構造函數最多只執行一次
        靜態構造函數在類的靜態成員初始化之後執行。或者講編譯器會將靜態成員初始化語句轉換成賦值語句放在靜態構造函數執行的最開始。
        靜態構造函數在任何類的靜態成員被引用之前執行。
        靜態構造函數在任何類的實例變更被分配之前執行。
    9.3主要作用：
        對類的靜態成員作初始化
    9.4：注意
        如果類中定義了靜態變數並賦初值，則類會自動創建一個靜態構造函數，為這個變數賦初值。如果此變數沒有賦初值，則類就不會自動創建靜態構造函數。
        靜態構造函數在變數使用之前初載入。
如代碼：

using System;
class A
{
    public static int i=100;
    static A()
    {
        Console.WriteLine("A類的靜態構造函數");
    }
    public A()
    {
        Console.WriteLine("A類的無參構造函數");
    }
}

class Test
{
    static void Main()
    {
        Console.WriteLine(A.i);
        
        Console.ReadLine();
    }
}
/**//*
 * 結果為：
 * A類的靜態構造函數
 * 100
 */

9.5 在一個程式的執行過程中，靜態構造函數最多只執行一次
如代碼：

using System;
class A
{
    public static int i=100;
    static A()
    {
        Console.WriteLine("A類的靜態構造函數");
    }
    public A()
    {
        Console.WriteLine("A類的無參構造函數");
    }
}
 class Test
{
    static void Main()
    {
        A a=new A();
        
        A a1=new A();
        Console.ReadLine();
    }
}
  /**//* 結果為：
 * A類的靜態構造函數
 * A類的無參構造函數
 * A類的無參構造函數
 */