C#继承细谈

 1  static void Main(string[] args)
 2         {
 3             Ce c = new Ce();
 4             c.luoyang();
 5         }
 6 public class Ce
 7     {
 8         private string name;
 9         private int number;
10         private int count;
11 
12         public void luoyang()
13         {
14             Console.WriteLine(this);
15         }
16         public string Name
17         {
18             get
19             {
20                 return name;
21             }
22         }
23         public int Number
24         {
25             get
26             {
27                 return number;
28             }
29             set
30             {
31                 number = (value < 0) ? 0 : value;
32             }
33         }
34         public int Count
35         {
36             get
37             {
38                 return count;
39             }
40             set
41             {
42                 count = (value < 0) ? 0 : value;
43             }
44         }   
45 
46         public override string ToString()
47         {
48             return string.Format("姓名：{0},{1},{2}", Name, Number, Count);
49         }
50     }

运行结果：

若是把三个字段都初始化了，那么就显示

调用对象this，那么就会自动调用ToString（）方法，ToString()方法是string类中所独有的，只要输出对象本身就会，就会调用该方法。

步步深入2：

1             Ce a1 = new Ce("lisi", 4, 5);
2             Console.WriteLine("丝路起点，运河中心" + a1.He());

 1  public class Ce
 2     {
 3         private string name;
 4         private int number;
 5         private int count;
 6         public Ce(string n, int nu, int co)
 7         {
 8             name = n;
 9             number = nu;
10             count = co;
11             Console.WriteLine(this);
12             Console.WriteLine("西安：" + this);
13         }
14  public string Name
15         {
16             get
17             {
18                 return name;
19             }
20         }
21         public int Number
22         {
23             get
24             {
25                 return number;
26             }
27             set
28             {
29                 number = (value < 0) ? 0 : value;
30             }
31         }
32         public int Count
33         {
34             get
35             {
36                 return count;
37             }
38             set
39             {
40                 count = (value < 0) ? 0 : value;
41             }
42         }
43         public virtual int He()
44         {
45             return Count + Number;
46         }
47         public override string ToString()
48         {
49             return string.Format("姓名：{0},{1},{2}", Name, Number, Count);
50         }
51     }

运行结果：

有了第一个例子的基础，第二个例子就很容易明白啦！

若要把override去掉，则不会调用ToString()方法；则上例的运行结果为：

步步深入3：

主方法

1             Ps a2 = new Ps("zhangsan", 1, 2, 3);
2             Console.WriteLine("千年帝都，牡丹花城" + a2.He());

添加继承类

 1  public class Ps : Ce
 2     {
 3         private int number1;
 4         public Ps(string n, int nu, int co, int nu1)
 5             : base(n, nu, co)//先运行继承的那个构造函数
 6         {
 7             number1 = nu1;
 8             Console.WriteLine("hello" + this);
 9         }
10         public int Number1
11         {
12             get
13             {
14                 return number1;
15             }
16         }
17         public override int He()
18         {
19             return base.He() + Number1;
20         }
21         public override string ToString()
22         {
23             //return base.ToString();
24             return "洛阳";
25         }
26     }

上例的运行结果：

运行流程，运行构造函数的时候会先调用基类的构造函数，但是虽然在基类中但this对象仍是派生类的，所以调用的是派生类中的ToString（）；而对于方法，派生类的对象调用派生类的方法，base.方法 调用的是基类的方法,可以是任意基类的方法，例子中的可以不是he（）方法可以在基类中再加she（）方法等；之所以先调用基类的构造函数也是因为.Base;

若用return  base.ToString()则运行结果：

步步深入4

参照2012年3月2日的随笔！