C#語法學習五(Class)

/*

面向對像(Object Oriented)的特點:繼承,封裝,多態.

類是抽像出來的，而對像則是一個實體．

對像也就是類實例化後的結果．

*/

using System;
class Person//類
{
    int name;//成員變量
    int height;//成員變量
    void eat()//成員方法
    {
        
    }
}
class test
{
    static void Main()
    {
        Person baby=new Person();//對像
        Person YaoMin=new Person();//對像
    }
}

 

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 12:46
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
class A//:object//繼承自object
{
//    public A()//:base()//構造器,名稱必需和類的名稱相同
//    {//類在實例化的時候會自動執行構造器
//        Console.WriteLine("我輕輕的來了");
//    }
    public int i;
    public string s;
    public A()
    {
        i=100;
        s="我也不知道";
    }
    //this是類中一個隱含的指針,代表的是其實例化的對像.
    public A(int i):this()//用this()在實例化的時候會先調用無慘構造器
    {
        this.i=i;
    }
    public A(string s):this()
    {
        this.s=s;
    }
    public A(int i,string s):this()
    {
        this.i=i;
        this.s=s;
    }
}
class test
{
    static void Main()
    {
        //類在實例化的時候會對其成員變量進行初始化,數值則為0,字符則為空
//        A a=new A();
//        Console.WriteLine("i=" + a.i);
//        Console.WriteLine("s=" + a.s);
        //在使用局部變量時必需對期初始化,而類的成員變量則不需要.
//        int i=0;
//        string s="aaa";
//        Console.WriteLine("i=" + i);
//        Console.WriteLine("s=" + s);
    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);
    }
}

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 01:14
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */

using System;
class A
{
    public A()
    {
        Console.WriteLine("我是類A的無慘構造器");
    }
    public A(int i)
    {
        Console.WriteLine("我是類A帶一個構數的構造器");
    }

}
class B:A
{
    //類在實例化的過程中首頁會執行其基類的無參構造器
    //並且始終是調用基類的無參構造器
    //因此我們要有一個好的習慣就是一個類都應該寫上一個空的構造器
    //如果沒有寫構造器,系統會自動的加上一個無慘的構造器
    public B()
    {
        Console.WriteLine("我是類B的無慘構造器");
    }
    public B(int i):base(i)//
    {
        Console.WriteLine("我是類B帶一個構數的構造器");
    }
}
class test
{
    static void Main()
    {
        B b=new B(100);
    }
}

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 01:27

 * 靜態構造器(static constructor)
 * 靜態構造函數是實現對一個類進行初始化的方法成員.
 * 它一般用於對靜態數據的初始化.靜態構造函數不能
 * 有參數,不能有修飾符而且不能被調用,當類被加載時,
 * 類的靜態構造函數自動被調用.
 * 靜態構造器(static constructor)
 * 1,在一個程序的執行過程中,靜態構造器最多只執行一次.
 * 2,靜態構造器在類的靜態成員初始化之後執行.或者講編譯
 * 器會將靜態成員初始化語句轉換成賦值語句放在靜態構造器
 * 執行的最開始
 * 3,靜態構造器在任何類的靜態成員被引用之前執行
 * 4,靜態構造器在任何類的實例變量被分配之前執行
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
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);
        //A a=new A();
        //A b=new A();
    }
}

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 01:44
 * 析構(destructor)
 * .net的垃圾回收機制
 * 1,程序中的值類型也就是存放在堆中的,一但出了應用
 * 範圍後就會被釋放.
 * 2,C#中對像主要是存放在托管堆上的.垃圾回收機制主要是對托管堆中的變量進行管理.
 * 其中.net給托管堆中的對像分為第0代=256k,第1代=2M
 * ,第2代=10M..
 * 3,在第2代未滿時則不會去檢查第2代的空間,同理第1代
 * 未滿時也不會去檢查第1代.
 * 4,當第0代的滿了後會釋放掉放一部份,另一部份則轉移到第1
 * 代的空間內.
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 11:15
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
/*
//析構器
一個類只能有一個析構器.
析構器不能被繼承或重載.
析構器不能被調用.他們是被自動調用的.
析構器不能帶修飾符或參數.
析構器的本質是一個finalize方法
在垃圾回收器內部有兩個數據結構:
Finalization list(終結鏈表)
Freachable queue(終結可達隊列)
在類中調用了析構器後會將此類的指針存放到Finalization list.
也就告訴程序,在回收之前要調它們的finalize方法.
.net中有一個高級線程對Freachable queue進行操作.
結論:
1,托管堆中的內存回收分別是有兩個不同的線程來執行的.
2,帶有析構器的類生命周期變長,它全們的內存空間要經過兩次回收才會是放掉
這樣也就造成程序性能低下.
3,一般情況下我們不需要用析造器.
那些情況會導致Finalize方法的調用(.net中有一個高級線程對Freachable queue進行操作.)
1,第0代對像充滿.
2,代碼顯式的調用System.CG的Collect方法.
3,Windows報告內存不足.
4,CLR卸載應用程序域.
5,CLR被關閉.
*/
using System;
class A
{
    public A()//構造器
    {
        Console.WriteLine("類A被創建");
    }
    ~A()//析構器,前面多了一個波浪符號
    {
        Console.WriteLine("類A被是放");
    }
}
class Test
{
    static void Main()
    {
        //創建類A的實例,而這個實例沒有指向任何變量,所以一創建也就馬上是放了.
        new A();
    }
}

 

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 11:41
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */

using System;
class A
{
    public A()//構造器
    {
        Console.WriteLine("類A被創建");
    }
    ~A()//析構器,前面多了一個波浪符號
    {
        Console.WriteLine("類A被是放");
    }
}
class Test
{
    static void Main()
    {
        //創建類A的實例,而這個實例沒有指向任何變量,所以一創建也就馬上是放了.
        new A();
        GC.Collect();//調用此方法馬上是放,MS強烈不要這樣做.
        new A();
    }
}

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 11:46
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
//證明第0代對像是不是256k,當執行到第21次的時候前面的對像都會被是放.


using System;
class A
{
    public A()//構造器
    {
        Console.WriteLine("類A被創建");
    }
    ~A()//析構器,前面多了一個波浪符號    {
        Console.WriteLine("類A被是放");
    }
}
class Test
{
    static void Main()
    {
        for (string s="";s!="end";s=Console.ReadLine())
        {
            new A();
            for(int i=0;i<50;i++)
            {
                byte[] b=new byte[1000];
            }
        }

    }
}

/*
 * Created by SharpDevelop.
 * User: Administrator
 * Date: 2008/8/27
 * Time: 上午 11:55
 * 通過上一節的介紹,讓我們知道最好不要使用finalization終結
 * 可是在實際程序中經常要使用到一些本地資源和非托管的資料,比如:
 * 文件
 * 網絡連接
 * 套接字
 * 互斥體
 * CLR是不能是放這些資源的,需要我們手動的寫代碼.
 * 而這時候就必需要把這些代碼放到終結器內.這樣就產生了
 * 新的問題,使用終結器會使程序性能低下,但又必需是放這些資源.
 * 這時候ms就提出了IDisposable接口.
 * publice interface IDisposable
 * {
 *     void Dispose();
 * }
 * 資源在是放的時候有兩种方法:
 * 手動是放:dispose(),close()
 * 自動是放:finalize()
 * 最後統一到非托管資源是放
 * dispose()          close()            finalize()
 *    |                  |                  |
 *    |                  |                  |
 * -----------------dispose(boolean disposing)------------
 *    |                  |                  |
 * -------disposing=true---                 |disposing=false
 *              |                           |
 *          是放托管資源                 是放排托管資源
 *          是放排托管資源
 *              |
 *          組址finalizer的調用
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */
using System;
public class MyResource:IDisposable
{
    private bool disposed=false;
    public void Dispose()
    {
        Dispose(true);
    }
    public void Close()
    {
        Dispose(true);
    }
    ~MyResource()
    {
        Dispose(false);
    }
    private void Dispose(bool disposing)
    {
        if(!this.disposed)
        {
            if(disposing)
            {
                Console.WriteLine("調用引用對像的dispose()方法");
            }
            Console.WriteLine("是放類本身所使用的非托管資源");
            
            disposed=true;
            if(disposing)
            {//禁止finalize方法的調用
                GC.SuppressFinalize(this);
            }
        }
    }
}
public class Test
{
    static void Main()
    {
//        MyResource mr=new MyResource();
//        try
//        {
//            Console.WriteLine("調用mr做一些事情");
//        }
//        finally
//        {
//            mr.Dispose();
//            //mr.Close();
//        }
        //使用using程序會自動調用try finally方法
        //using只能用於實現了dispose接口的類
        using(MyResource mr=new MyResource())
        {
            Console.WriteLine("調用mr做一些事情");
        }
        //close 和dispose方法是一樣的,至於為什麼要多一個close
        //是因為很多程序員已經習慣了用close方法
    }
}