登录
目录
当前位置： 首页 > 文档资料 > 学习 C# 中文教程 >

Classes

优质
小牛编辑
126浏览
2023-12-01

定义类时，可以为数据类型定义蓝图。 这实际上并没有定义任何数据，但它确实定义了类名的含义。 也就是说，该类的对象包括什么以及可以对该对象执行什么操作。 对象是类的实例。 构成类的方法和变量称为类的成员。

定义一个类

类定义以关键字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
   }
}

注意 -

  • 访问说明符指定成员的访问规则以及类本身。 如果未提及，则类类型的默认访问说明符为internal 。 成员的默认访问权限是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＃构造函数

类constructor是类的特殊成员函数，只要我们创建该类的新对象，就会执行该函数。

构造函数与类的名称完全相同，并且它没有任何返回类型。 下面的例子解释了构造函数的概念 -

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

default constructor函数没有任何参数，但如果需要，构造函数可以有参数。 这种构造函数称为parameterized constructors 。 此技术可帮助您在创建对象时为其分配初始值，如以下示例所示 -

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＃析构函数

destructor是类的特殊成员函数，只要其类的对象超出范围，就会执行该函数。 destructor与具有前缀波形符（〜）的类具有完全相同的名称，并且它既不能返回值也不能接受任何参数。

在退出程序之前，析构函数对于释放内存资源非常有用。 析构函数不能被继承或重载。

以下示例解释了析构函数的概念 -

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。 当我们将类的成员声明为static时，这意味着无论创建了多少个类的对象，都只有一个静态成员的副本。

关键字static表示对于类只存在一个成员实例。 静态变量用于定义常量，因为可以通过调用类来检索它们的值，而无需创建它的实例。 静态变量可以在成员函数或类定义之外初始化。 您还可以在类定义中初始化静态变量。

以下示例演示static variables的使用 -

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

您还可以将member function声明为static 。 这些函数只能访问静态变量。 甚至在创建对象之前就存在静态函数。 以下示例演示static functions的使用 -

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
免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn