当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类名的意义。也就是说，类的对象由什么构成以及可以对这个对象执行哪些操作。对象是类的实例。构成类的方法和变量称为类的成员。
定义一个类
一个类定义以关键字 class 开头，后面跟着类名；类体由一对花括号包围。下面是类定义的一般形式：
<访问限定符> class class_name {
<访问限定符> <数据类型> variable1;
<访问限定符> <数据类型> variable2;
...
<访问限定符> <数据类型> variableN;
<访问限定符> <返回类型> method1(参数列表) {
}
<访问限定符> <返回类型> method2(参数列表) {
}
...
<访问限定符> <返回类型> methodN(参数列表) {
}
}
注意：
-
访问限定符规定了成员以及类本身的访问规则。如果不指定，则类类型的默认访问限定符是
internal。成员的默认访问限定符是 private。
-
数据类型指定了变量的类型，而返回类型指定了方法返回的数据类型（如果有）。
-
点运算符链接了一个对象的名称和一个成员的名称。
下面的例子说明了目前为止所讨论的概念：
示例代码
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();
Box Box2 = new Box();
double volume = 0.0;
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Box1 的体积 : {0}", volume);
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Box2 的体积 : {0}", volume);
Console.ReadKey();
}
}
}
当上述代码被编译和执行时，它产生以下结果：
Box1 的体积 : 210
Box2 的体积 : 1560
成员函数与封装
一个类的成员函数是一个其定义或原型位于类定义内部的函数，类似于任何其他变量。它操作任何该类的对象，并且对该对象的所有类成员都有访问权限。
成员变量是一个对象的属性（从设计角度来看），它们保持私有以实现封装。这些变量只能通过公共成员函数来访问。
让我们在类中设置和获取不同类成员的值，以应用上述概念：
示例代码
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();
Box Box2 = new Box();
double volume;
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积 : {0}" ,volume);
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积 : {0}", volume);
Console.ReadKey();
}
}
}
当上述代码被编译和执行时，它产生以下结果：
Box1 的体积 : 210
Box2 的体积 : 1560
C# 构造函数
类的构造函数是类的一个特殊成员函数，在我们创建该类的新对象时会被执行。
构造函数的名称必须与类名完全相同，并且没有返回类型。下面的例子解释了构造函数的概念：
示例代码
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();
}
}
}
当上述代码被编译和执行时，它产生以下结果：
对象正在创建
线的长度 : 6
默认构造函数没有参数，但如果你需要，构造函数可以有参数。这样的构造函数被称为带参数的构造函数。这种技术有助于在创建对象时为其分配初始值，如下例所示：
示例代码
using System;
namespace LineApplication {
class Line {
private double length;
public Line(double len) {
Console.WriteLine("对象正在创建, 长度 = {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();
}
}
}
当上述代码被编译和执行时，它产生以下结果：
对象正在创建, 长度 = 10
线的长度 : 10
线的长度 : 6
C# 析构函数
析构函数是类的一个特殊成员函数，在其类的对象超出作用域时会被执行。析构函数的名称必须与类名完全相同，并且前面有一个波浪号 (~)；并且它既不能返回值也不能带有任何参数。
析构函数可以在程序退出前释放内存资源方面非常有用。析构函数不能被继承或重载。
下面的例子解释了析构函数的概念：
示例代码
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());
}
}
}
当上述代码被编译和执行时，它产生以下结果：
对象正在创建
线的长度 : 6
对象正在删除
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