Kelas C#

Takrif kelas

Takrif kelas bermula dengan kata kunci kelas, diikuti dengan nama kelas. Badan kelas, tertutup dalam sepasang pendakap kerinting. Berikut ialah bentuk umum definisi kelas:

<access specifier> class  class_name 
{
    // member variables
    <access specifier> <data type> variable1;
    <access specifier> <data type> variable2;
    ...
    <access specifier> <data type> variableN;
    // member methods
    <access specifier> <return type> method1(parameter_list) 
    {
        // method body 
    }
    <access specifier> <return type> method2(parameter_list) 
    {
        // method body 
    }
    ...
    <access specifier> <return type> methodN(parameter_list) 
    {
        // method body 
    }
}

Nota:

• Pengecam akses <penentu akses> . Jika tidak dinyatakan, pengecam akses lalai digunakan. Pengecam akses lalai untuk kelas ialah dalaman dan untuk ahli adalah peribadi.

• Jenis data <jenis data> menentukan jenis pembolehubah, jenis pulangan <jenis pulangan>

• Jika anda ingin mengakses ahli kelas, anda mahu menggunakan pengendali titik (.).

• Pengendali titik memautkan nama objek dan nama ahli.

Contoh berikut menggambarkan konsep yang dibincangkan setakat ini:

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:

Box1 的体积： 210
Box2 的体积： 1560

Fungsi Ahli dan Enkapsulasi

Fungsi ahli kelas ialah fungsi yang mempunyai definisi atau prototaipnya dalam definisi kelas, sama seperti pembolehubah lain. Sebagai ahli kelas, ia boleh beroperasi pada mana-mana objek kelas dan boleh mengakses semua ahli kelas objek.

Pembolehubah ahli ialah sifat objek (dari perspektif reka bentuk), dan ia dirahsiakan untuk mencapai pengkapsulan. Pembolehubah ini hanya boleh diakses menggunakan fungsi ahli awam.

Mari kita gunakan konsep di atas untuk menetapkan dan mendapatkan nilai ahli kelas yang berbeza dalam kelas:

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // 长度
       private double breadth;  // 宽度
       private double height;   // 高度
       public void setLength( double len )
       {
            length = len;
       }

       public void setBreadth( double bre )
       {
            breadth = bre;
       }

       public void setHeight( double hei )
       {
            height = hei;
       }
       public double getVolume()
       {
           return length * breadth * height;
       }
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();		 // 声明 Box2，类型为 Box
            double volume;				 // 体积


            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Box1 的体积： {0}" ,volume);

            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Box2 的体积： {0}", volume);
           
            Console.ReadKey();
        }
    }
}

Apabila kod di atas disusun dan dilaksanakan, ia akan menghasilkan keputusan berikut :

Box1 的体积： 210
Box2 的体积： 1560

Pembina dalam C#

pembina kelas ialah fungsi ahli khas kelas yang dilaksanakan apabila objek baharu kelas dicipta.

Nama pembina betul-betul sama dengan nama kelas, ia tidak mempunyai sebarang jenis pulangan.

Contoh berikut menggambarkan konsep pembina:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()
      {
         Console.WriteLine("对象已创建");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();    
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:

对象已创建
线条的长度： 6

Default Pembina daripada tidak mempunyai sebarang parameter. Tetapi jika anda memerlukan pembina dengan parameter yang boleh mempunyai parameter, pembina jenis ini dipanggil pembina berparameter. Teknik ini boleh membantu anda menetapkan nilai awal kepada objek semasa menciptanya Sila lihat contoh berikut untuk butiran:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line(double len)  // 参数化构造函数
      {
         Console.WriteLine("对象已创建，length = {0}", len);
         length = len;
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line(10.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Apabila kod di atas disusun dan dilaksanakan, ia akan menghasilkan keputusan berikut:

对象已创建，length = 10
线条的长度： 10
线条的长度： 6

Destructor dalam C#

destructor kelas ialah fungsi ahli khas kelas yang dilaksanakan apabila objek kelas keluar dari skop.

Nama pemusnah diawali dengan tilde (~) sebelum nama kelas Ia tidak mengembalikan nilai dan tidak mengambil sebarang parameter.

Pemusnah digunakan untuk melepaskan sumber sebelum menamatkan program (seperti menutup fail, melepaskan memori, dsb.). Pemusnah tidak boleh diwarisi atau dibebankan.

Contoh berikut menggambarkan konsep pemusnah:

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线条的长度
      public Line()  // 构造函数
      {
         Console.WriteLine("对象已创建");
      }
      ~Line() //析构函数
      {
         Console.WriteLine("对象已删除");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());           
      }
   }
}

Apabila kod di atas disusun dan dilaksanakan, ia akan menghasilkan keputusan berikut:

对象已创建
线条的长度： 6
对象已删除

Ahli statik kelas C#

Kita boleh menggunakan kata kunci statik Tentukan ahli kelas sebagai statik. Apabila kita mengisytiharkan ahli kelas sebagai statik, ini bermakna tidak kira berapa banyak objek kelas yang dicipta, hanya akan ada satu salinan ahli statik.

Kata kunci statik bermaksud hanya terdapat satu tika ahli ini dalam kelas. Pembolehubah statik digunakan untuk mentakrifkan pemalar kerana nilainya boleh diperolehi dengan memanggil kelas secara langsung tanpa membuat contoh kelas. Pembolehubah statik boleh dimulakan di luar fungsi ahli atau definisi kelas. Anda juga boleh memulakan pembolehubah statik dalam definisi kelas.

Contoh berikut menunjukkan penggunaan pembolehubah statik:

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();         
            Console.WriteLine("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

Apabila kod di atas disusun dan dilaksanakan, ia akan menghasilkan keputusan berikut:

s1 的变量 num： 6
s2 的变量 num： 6

Anda juga boleh mengisytiharkan fungsi ahli sebagai statik. Fungsi sedemikian hanya boleh mengakses pembolehubah statik. Fungsi statik wujud sebelum objek dicipta. Contoh berikut menunjukkan penggunaan fungsi statik:

using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public static int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s = new StaticVar();
            s.count();
            s.count();
            s.count();                   
            Console.WriteLine("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

Apabila kod di atas disusun dan dilaksanakan, ia akan menghasilkan keputusan berikut:

变量 num： 3