位置：首页 > 高级语言 > C#在线教程 > C#类

C#类

 上一篇 下一篇  

当你定义一个类时，也就是定义一个蓝图的数据类型。这实际上并不定义任何数据，但它确实定义类的名字是什么意思，即，什么类的对象将包括哪些操作可以对这样的对象来执行。对象是一个类的实例。构成一类的方法和变量被称为类的成员。

类定义

类定义以关键字class后跟类名称;和类体，封闭由一对大括号中。以下是一个类定义的一般形式：

<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 
    }
}

请注意，

  • 访问符指定访问规则的成员以及类本身，如果没有提到一个类访问类型，那么默认访问说明符是内部的。为成员默认访问是私有(private)。

  • 数据类型指定变量的类型，并返回类型指定数据，由该方法返回，如果有任何数据类型。

  • 要访问类的成员，可使用点(.)运算符。

  • 点运算符链接的对象与成员的名称。

下面的例子说明，到目前为止讨论的概念：

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // Length of a box
       public double breadth;  // Breadth of a box
       public double height;   // Height of a box
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // Declare Box1 of type Box
            Box Box2 = new Box();        // Declare Box2 of type Box
            double volume = 0.0;         // Store the volume of a box here

            // box 1 specification
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // box 2 specification
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // volume of box 1
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volume of Box1 : {0}",  volume);

            // volume of box 2
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volume of Box2 : {0}", volume);
            Console.ReadKey();
        }
    }
}

让我们编译和运行上面的程序，这将产生以下结果：

Volume of Box1 : 210
Volume of Box2 : 1560

成员函数和封装

一个类的成员函数是一个函数，有它的定义或像任何其他变量的类定义中的原型。其所操作的类，其中它是一个成员的任何对象，并且有权访问一个类用于该对象的所有成员。

成员变量是一个对象（从设计的角度来看）的属性，并执行封装它们为私有。这些变量只能使用公共成员函数访问。

让我们把上述概念来设置和获取一类不同的类成员的值：

using System;
namespace BoxApplication
{
    class Box
    {
       private double length;   // Length of a box
       private double breadth;  // Breadth of a box
       private double height;   // Height of a box
       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();        // Declare Box1 of type Box
            Box Box2 = new Box();
            double volume;


            // Declare Box2 of type Box
            // box 1 specification
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // box 2 specification
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);
       
            // volume of box 1
            volume = Box1.getVolume();
            Console.WriteLine("Volume of Box1 : {0}" ,volume);

            // volume of box 2
            volume = Box2.getVolume();
            Console.WriteLine("Volume of Box2 : {0}", volume);
           
            Console.ReadKey();
        }
    }
}

让我们编译和运行上面的程序，这将产生以下结果：

Volume of Box1 : 210
Volume of Box2 : 1560

C#中类的构造函数

类的构造函数是，每当我们创建该类的新对象时执行一类特殊的成员函数。

构造函数都会有完全相同的名字作为类，它没有任何的返回类型。下面的示例说明构造函数的概念：

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Length of a line
      public Line()
      {
         Console.WriteLine("Object is being created");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();    
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

Object is being created
Length of line : 6

默认的构造函数可以不用任何参数，但如果需要一个构造函数有参数。这样的构造函数调用参数的构造函数。这种技术帮助你在其创建时的初始值分配给一个对象作为显示在下面的例子：

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Length of a line
      public Line(double len)  //Parameterized constructor
      {
         Console.WriteLine("Object is being created, 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("Length of line : {0}", line.getLength()); 
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

Object is being created, length = 10
Length of line : 10
Length of line : 6

在C#中的析构函数

析构函数是执行每当它的类的对象超出范围的一类特殊的成员函数。析构函数将有完全相同的名称作为前缀类使用波浪号（〜），它可以没有返回值，也不能采取任何参数。

析构函数可以为退出程序之前像关闭文件，释放内存等，析构函数不能被继承或被重载之前释放的资源非常有用的。

以下举例说明析构函数的概念：

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // Length of a line
      public Line()  // constructor
      {
         Console.WriteLine("Object is being created");
      }
      ~Line() //destructor
      {
         Console.WriteLine("Object is being deleted");
      }

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

      static void Main(string[] args)
      {
         Line line = new Line();
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());           
      }
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

Object is being created
Length of line : 6
Object is being deleted

C#类的静态成员

我们可以使用static关键字定义的类成员为静态。当我们声明一个类的静态成员，这意味着无论多少许多类的对象被创建，有静态成员只有一个副本。

关键字static意味着构建一个实例存在类。静态变量用于定义常量，因为它们的值可以通过调用类，而无需创建它的一个实例进行检索。静态变量可以在成员函数或类定义之外被初始化。也可以初始化类在定义静态变量的时候。

下面的例子演示了如何使用静态变量：

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("Variable num for s1: {0}", s1.getNum());
            Console.WriteLine("Variable num for s2: {0}", s2.getNum());
            Console.ReadKey();
        }
    }
}

让我们编译和运行上面的程序，这将产生以下结果：

Variable num for s1: 6
Variable num for s2: 6

也可以声明一个成员函数为静态。这些函数只能访问静态变量。在创建对象之前静态函数是可以存在的。下面的例子演示了如何使用静态函数：

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("Variable num: {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

让我们编译和运行上面的程序，这将产生以下结果：

Variable num: 3


极客书 © 2015-2015 . 京ICP备15058027号-1 Email: