C＃高级（二）类

一、类的概述

 

类，是创建对象的模板，每个对象都包含数据，并且提供了处理和访问数据的方法。换言之，类，定义了每个对象，也就是“实例”包含什么数据和功能。

比如我们定义一个“医生”类，并且实例化一个。我们看下面的代码：

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class Doctor
5.     {
6.         public Doctor(){}
7.         public Doctor(string name,byte age)
8.         {
9.             this._name=name;
10.             this._age=age;
11.         }
12.         private string _name;
13.         private byte _age;
14.         public string Name
15.         {
16.             get{return this._name;}
17.             set{this._name=value;}
18.         }
20.         public byte Age
21.         {
22.             get{return this._age;}
23.              set{this._age=value; }
24.         }
26.         public string doSth()
27.         {
28.             return "我会给人治病喔～～";
29.         }
30.         public static string doAnth()
31.         {
32.             return "执行的另一个静态方法";
33.         }
34.     }
36.     public class OneDoctor
37.     {        
38.         static void Main()
39.         {
40.              Doctor dc=new Doctor();
41.              dc.Name="李四";
42.              dc.Age=25;
43.             Doctor dc2=new Doctor("张三",35);
44.             Console.WriteLine(dc.Name);
45.             Console.WriteLine(dc.Age);
46.             Console.WriteLine(dc2.Name);
47.             Console.WriteLine(dc2.Age);
48.             Console.WriteLine(dc.doSth());
49.             Console.WriteLine(Doctor.doAnth());
50.          }
51.     }
52. }

       

在这个例子中，public class Doctor 便是声明了一个类。_name和_age是其两个属性。doSth()是其的一个方法（即对象的行为）。 Doctor dc=new Doctor() 用来实例化了一个Doctor类，也就类似实例化了一个对象，产生了一个新医生。Doctor dc2=new Doctor("张三",35);是实例化的另外一个类，也就是另外一个医生。

在Doctor类中，public Doctor(){}  public Doctor(string name,byte age) 这两个方法叫做 构造函数。是用来初始化类的，在每个类被实例化的时候，会自动调用。

public string Name

              {

                     get{return this._name;}

                     set{this._name=value;}

              }

这段代码是用来设置和获取类的属性的。也就类似java中的 getName 和 setName 方法。只是在C＃中这变得更容易了。

 

注意一点：类是存储在托管堆上的引用类型。

 

二、方法

 

       1、  方法概述

方法和C语言中的 函数共享同一个理念。一直以来，我们在用的Main()方法就是个例子。还有上例中public string doSth() 也是一个方法。其中，public是 类的修饰符，string是方法的返回值，也可以没有返回值，即 void ，doSth是方法名称。()括号必须有，在括号中可以有参数，如Doctor类的构造函数 public Doctor(string name,byte age) 就有两个参数。方法体则必须用一对{}括起来。

方法的调用，则需要先实例化类，然后调用类的某个方法。上例中Doctor dc=new Doctor();来实例化了类，然后 dc.doSth() 就是调用了Doctor类的方法。

如果方法是静态的，即 static，则不需要实例化类，直接使用 类名.方法名 就可以调用了。如上例中 Console.WriteLine(Doctor.doAnth()); 即是直接调用了静态的doAnth方法。

 

2、方法的参数

       参数可以通过引用或者值传递 给方法。具体有什么区别呢？

       我们来看个例子。

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class OneDoctor
5.     {
6.         static  void FunctionTest(int [] arr, int x)
7.         {
8.             arr[0]=100;
9.             x=10;
10.         }
12.         static void Main()
13.         {
14.             int [] arrTemp={0,1,2,3,4};
15.             int y=30;
16.             Console.WriteLine(arrTemp[0]);
17.             Console.WriteLine(y);
18.             FunctionTest(arrTemp, y);
19.             Console.WriteLine(arrTemp[0]);
20.             Console.WriteLine(y);
21.          }
22.     }
23. }

 

本例的输出结果是0，30，100，30 因为数组是引用类型，在调用方法前后，引用类型的修改会保留下来，而值类型的修改不会保留下来。

 

3、ref 参数。

我们把 上例中的方法修改为 static void FunctionTest(int [] arr, ref int x) 这样，调用的时候 也加上 ref 即：functionTest(arrTemp, ref y); 执行后的结果就是0，30，100，10。

ref 关键字是强迫参数通过引用传递。

注意：在调用有ref参数的方法时，必须将参数要传递的参数提前初始化。但在调用out参数的方法时，就不必提前初始化。

 

4、out 参数

在上例中，我们稍作修改。

1. static void FunctionTest(out int x) 
2.         {
3.             x=100;
4.         }
6.         static void Main()
7.         { 
8.                 int y;
9.                 FunctionTest(out y);
10.                 Console.WriteLine(y);
11.         }

在Maim()函数中调用FunctionTest之前，y并没有初始化。但其输出结果确实100；因为这样属于引用传递，值的修改会被保留下来。

5、方法的重载

所谓重载就是指 方法名相同，而参数不同（参数类型，参数个数）看下面一个例子

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class test
5.     {
6.         static int FunctionTest(int x) 
7.         {
8.             return x+100;
9.         }
10.     
11.         static string FunctionTest(string str) 
12.         {
13.             return str;
14.         }
16.         static int FunctionTest(int x,int y) 
17.         {
18.             return x+y;
19.         }
21.         static void Main()
22.         {
23.                 Console.WriteLine(FunctionTest(10) );
24.                 Console.WriteLine(FunctionTest("gosoa.com.cn") );
25.                 Console.WriteLine(FunctionTest(5,20));
26.         }
28.     }
29. }

 

在这里例子中，有三个方法functionTest 其参数都不一样。在调用的时候，系统会根据传递的参数自动选择调用哪个方法的。这就是方法的重载。

在这里注意，重载的条件是，必须参数类型不同，或者参数个数不同。