C# - 类
定义类时，实际上是为数据类型定义了一个蓝图。这实际上并不定义任何数据，但它定义了类名的含义。也就是说，类的对象由什么组成，以及可以对该对象执行哪些操作。对象是类的实例。构成类的方法和变量称为类的成员。
定义类
类定义以关键字 class 开头，后跟类名;类主体用一对花括号括起来。以下是类定义的一般形式 -
<access specifier> class class_name {
// 成员变量
<access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// 成员方法
<access specifier> <return type> method1(parameter_list) {
// 方法主体
}
<access specifier> <return type> method2(parameter_list) {
// 方法主体
}
...
<access specifier> <return type> methodN(parameter_list) {
// 方法主体
}
}
注意 −
访问说明符指定成员以及类本身的访问规则。如果没有指定，则类类型的默认访问说明符为 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 类型的 Box1
Box Box2 = new Box(); // 声明 Box 类型的 Box2
doublevolume = 0.0; // 在此处存储盒子的体积
// 盒子 1 的规格
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// 盒子 2 的规格
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// 盒子 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Box1 的体积 : {0}",volume);
// 盒子 2 的体积
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(); // 声明 Box1 类型为 Box
Box Box2 = new Box();
double volume;
// 声明 Box2 类型为 Box
// 盒子 1 的规格
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// 盒子 2 的规格
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// 盒子 1 的体积
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积:{0}",volume);
// 盒子 2 的体积
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积:{0}",volume);
Console.ReadKey();
}
}
}
当编译并执行上述代码时，它会产生以下结果 -
Box1 的体积:210 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
