构造函数的运用，体现类的自我维护

构造函数有很多用处，巧妙地运用构造函数能提高类的设计安全、合理和封装。

下面的类设计的不合理，要求用户在调用18行Pring方法前，先为17行赋值。

1publicclassSpace
2{
3
4publicstaticvoidMain(string[]args)
5{
6
7FilePrintpring=newFilePrint();
8//如果用户忘记调用FileName，系统将不可靠
9//pring.FileName=@"c:/text.txt";
10pring.Print();
11}
12}
13
14publicclassFilePrint
15{
16
17publicstringFileName=null;
18publicvoidPrint()
19{
20System.Console.WriteLine("Doprining{0}",FileName);
21}
22}

把代码改为下面就合理的多

1publicclassSpace
2{
3
4publicstaticvoidMain(string[]args)
5{
6
7FilePrintpring=newFilePrint(@"c:/text.txt");
8pring.Print();
9
10//代码可以更简约
11newFilePrint(@"c:/text.txt").Print();
12}
13}
14
15publicclassFilePrint
16{
17
18publicFilePrint(stringpath)
19{
20FileName=path;
21}
22
23publicreadonlystringFileName=null;
24publicvoidPrint()
25{
26System.Console.WriteLine("Doprining{0}",FileName);
27}
28}

通过构造函数，强制用户在实例化的时候给与FileName的值，调用更安全更简约。
第23行对数据成员FileName修饰为readonly表示该数据成员为只读，只读的意思是，该成员只有一次赋值的机会（声明时立即赋值或在构造函数时赋值）。readonly和const的区别是
readonly有两种赋值的机会：声明时立即赋值或在构造函数时赋值
const只有在声明时赋值

另外一个很值得注意的是，const其实就是static数据修饰，不过不能直接用static来修饰。const包括了static的含义，所以const需要通过类来访问。


我们再来看一个构造函数的运用

请仔细考虑一下代码

1publicclassSpace
2{
3
4publicstaticvoidMain(string[]args)
5{
6
7System.Console.WriteLine(newSalesContract(100).SalePrice);
8System.Console.WriteLine(newSalesContract(100,120).SalePrice);
9System.Console.WriteLine(newSalesContract(100,120,180).SalePrice);
10
11
12}
13}
14
15publicclassSalesContract:Contract//销售合同
16{
17publicSalesContract(doublecostPrice)
18:this(costPrice,costPrice)
19{}
20
21publicSalesContract(doublecostPrice,doubleminimumPrice)
22:this(costPrice,minimumPrice,minimumPrice)
23{}
24
25publicSalesContract(doublecostPrice,doubleminimumPrice,doublesalePrice)
26{
27CostPrice=costPrice;
28MinimumPrice=minimumPrice;
29SalePrice=salePrice;
30}
31
32privatedoubleMinimumPrice;//最低价
33publicdoubleSalePrice;//销售价格
34
35publicboolCheckPrice()//价格检查
36{
37returnSalePrice<Math.Min(MinimumPrice,CostPrice);
38}
39internaldoublePreferentialPrice;//优惠价
40}
41
42publicclassContract//合同
43{
44
45publicstringBuyer;//买方
46publicstringSeller;//卖方
47protecteddoubleCostPrice;//成本价
48}

通过3个构造函数，用户可以方便的对ConstPrice、SalePrice、MinimunPrice进行赋值。

我们再来看一个关于构造函数的用例。

1publicclassSpace
2{
3
4publicstaticvoidMain(string[]args)
5{
6System.Console.WriteLine(newOrder("123-12").OrderNumber);
7System.Console.WriteLine(newOrder(Order.CreateOrderNumber()).OrderNumber);
8System.Console.WriteLine(newOrder(Order.CreateOrderNumber()).OrderNumber);
9}
10}
11
12publicclassOrder
13{
14
15publicOrder(stringorderNumber)
16{
17this.OrderNumber=orderNumber;
18}
19
20privatestaticintCount;
21
22publicreadonlystringOrderNumber;
23
24publicstaticstringCreateOrderNumber()
25{
26System.DateTimed=System.DateTime.Now;
27returnSystem.DateTime.Now.ToString("yMd-")+(++Count).ToString();
28}
29
30}

上面的代码看似很合理，用户可以自己定义OrderNumber也可以通过CreateOrderNumber方法，Order在构造时总是可以得到Number。

但这样的设计，暴露了对CreateOrderNumber的调用。

我们看看经过修改后的设计

1publicclassOrder
2{
3
4publicOrder(stringorderNumber)
5{
6this.OrderNumber=orderNumber;
7}
8
9publicOrder():this(CreateOrderNumber())
10{
11
12}
13
14privatestaticintCount;
15
16publicreadonlystringOrderNumber;
17
18privatestaticstringCreateOrderNumber()
19{
20System.DateTimed=System.DateTime.Now;
21returnSystem.DateTime.Now.ToString("yMd-")+(++Count).ToString();
22}
23
24}

我们添加了一个默认的构造函数Order()在第9行，又把18行的CreateOrderNumber改为private，那么这会有什么效果呢？

1publicclassSpace
2{
3
4publicstaticvoidMain(string[]args)
5{
6System.Console.WriteLine(newOrder("123-12").OrderNumber);
7System.Console.WriteLine(newOrder().OrderNumber);
8System.Console.WriteLine(newOrder().OrderNumber);
9}
10}

看到了吗？在这个代码中，如果用户给与了Number则使用用户给与的值，否则，Order能自动给与值。向用户封装了CreateOrderNumber的存在。这就是类设计的一个很重要的原则：自我维护。