C#关于类（1）

类的定义与使用

当类编写时与C++相似class Cat(){}

当类定义时:cat Kitty = new Cat();

属性

在Java中如果定义一个私有private成员变量，在修改该成员变量时一般会定义Set()和Get()两个函数访问器来进行修改和获取

在C#中可以用属性：假如定义了一个Cat类

class Cat

{
        private string name; //此处名字暂时不管
        private int age;
public int Age//这个变量下的属性类似于一个函数

{

get

{

return age;

}

set

{

if(value < 0) age = 0;//年龄不能为负，可以在属性中进行合法性的检查

else age = vlaue; //vlaue是一个关键字，这个关键字相当于函数的参数，值就是Age的值

}

}

在使用属性赋值时方法如下：

Cat Kitty = new Cat();

Kitty.Age = 3;

Console.writeLine("我今年{0}岁了",Kitty.Age);

属性中兼顾了封装性、合法性的检查、符合变量使用的习惯

构造函数

当定义一个类的变量时，使用Cat Kitty = new Cat(); //其中Cat()就是类函数，也就是构造函数

在创建对象时，系统先为对象的成员变量分配内存，然后通过构造函数初始化对象的成员变量

每一个类中都有一个默认的构造函数，如Cat类中的默认构造函数就是Cat(),默认的构造函数不用声明。

(默认的构造函数会把整数初始化为0，字符串初始化为空。。。)

当创建对象时，系统会调用默认的构造函数，如果你不自定义(显式地写出)构造函数，系统同样会调用默认的构造函数

自定义构造函数可以带参数，也可以不带参数

如：

class Cat

{

private string name;

private int age;

public Cat(string nameTmp, int ageTmp)//有两个参数的构造函数

{

name = nameTmp;

age = ageTmp;

}

}

定义时：

Cat Kitty = new Cat("Kitty", 3);

若自定义了有参数的构造函数，还想使用默认的无参的构造函数，则要显式地定义出来：

class Cat

{

private string name;

private int age;

public Cat()//显式地定义出无参的构造函数

{

name = "";

age = 0;

}

public Cat(string nameTmp, int ageTmp)

{

name = nameTmp;

age = ageTmp;

}

}

析构函数

不用的对象要及时删除释放内存空间，在传统的面向对象设计中用类的析构函数删除对象

~Cat()

{}

类在定义的时候会生成一个默认的析构函数，因为C#是.NET程序，有非常完善的垃圾回收机制，所以一般情况下析构函数是没必要编写的

需要手动编写析构函数的地方一般是一些不需要.NET的非托管的代码

（垃圾回收器一般何时运行具有不确定性，可以调用System.Gc.Collect()进行强制运行）

静态变量(静态字段)

当类中的一个变量在类型前加上关键字static，则该成员变量为静态变量，必须由类直接调用

class Cat

{

private static int catCount = 0;

public Cat()

{

catCount++;//每次在定义一个Cat类型时都会在原有的catCount上加一

}

~Cat()

{

catCount--;//每次销毁一个Cat类型变量都会减一，其实此处析构函数并不用编写，C#有很好的回收机制

}

}

在调用时，必须要通过类来使用，如定义6个Cat类型后调用catCount：

Cat[] cats = new Cat[6];

for(int i=0; i<cats.Length; i++)

{

cats[i] = new Cat();

}

Console.WriteLine("一共有{0}只猫",Cat.catCount;); //此处直接由Cat类调用了catCount这个变量

静态函数(静态方法)

静态函数必须由类直接调用，如Math类中的Sin()函数:

static这个关键字可以写在public和private之前或之后(如：public static void Meow() 或 static public void Meow())

double sinVlaue = Math.Sin(12);

而非静态的方法就要用对象来调用。

自定义的静态方法：

class Calculate

{

public static double Add(double x, double y){return x+y;}

public static double Sub(double x, double y){return x-y;}

}

调用的时候：

double x= 2 ;

double y = 1;

double z = Calculate.Add(x, y);

const常量

const常量在定义时就需要进行赋值，且不能修改：

class Circle

{

private const double PI = 3.1415926;//此处PI其实是隐示静态的const常量，

//完整的形式是private static const double PI = 3.1415926;只是为了方便省略了，所以此处要被类使用

private double banjing;

}

在使用时：

Circle circleOne = new Circle();

Console.WriteLine("圆周率{0}",Circle.PI); //此处由const是隐示的静态字段，所有要用类来调用

Console.WriteLine("半径{0}",circleOne.banjing); //banjing字段是显示的，要用对象来调用

readonly

只读,readonly是非静态的，其在定义时可以不赋值，可以在其他任意地方赋值，但一旦赋值就不可再更改

class Hotel

{

public readonly int roomNumber;

public Hotel(int roomNumberValue)

{

roomNumber = roomNumberValue;

}

}

readonly与const不同的地方除了赋值的地方，还有使用时的方式，const必须用类调用，如Cat.PI，而readonly要用对象调用，如：

Hotel asHome = new Hotel();  

Console.WriteLine("{0}",asHome.roomNumber);

PS:

在类中，可以用该类自身定义成员变量，如在Cat类中定义一个Cat的成员变量：

class Cat

{

private int age;

private Cat Kitty;

}

(在定义类的变量时一般都是Cat Kitty = new Cat();其实在定义其他变量时也是如此，如：int count = new int();通常为了方便不写，但是类的定义必须写)