Csharp中的关键字示例及代码演示之类

前面说了C#中的结构，那说类的时候，先说说类与结构的相同点吧

　　类是一种构造，通过这样的构造将其它类型的变量，方法，事件组合在一起构成自己的自定义类型（包含数据和行为），类只能实现单继承，但是可以实现多借口继承。实例1：

View Code

/*
 * ${res:XML.StandardHeader.CreatedByYangbo}
 * 用户： ${YangBo}
 * 日期: 10/13/2011
 * 时间: 9:05
 * 
 */

using System;
namespace ClassTestDemo
{
    public class MyGril:People,IWalk,IEat
    {
        private String name;
        public string name{get;set;}
        
        private Int32 age;
        public Int32 Age
        {
            get
            {
                return Age;
            }
            set
            {
                if (age>0&&age<200) {
                    Age=value;}
            }
            
        }
        public MyGril(string name,Int32 age)
        {
            this.age=age;
            this.name=name;
        }
        
        public void GetInfo(string name,Int32 age)
        {
            Console.WriteLine("I'm {0},and {1} years old",name,age);
        }
        
        public void Walk()
        {
            Console.WriteLine("MyGril can walk of frist in her life");
        }
        public void Eat()
        {
            Console.WriteLine("MyGril is crying so huury,Mabey Her wang to eat some");
        }
        
        
        
    }
    
    public class People
    {
        public interface IWalk
        {
            void Walk();
        }
        
        public interface IEat
        {
            void Eat();
        }
    }
    
}

　　如果有Static关键字，表明这个类是静态类，它们在使用时，在内存中保存一个副本，并且在访问该类的时候只能通过自身访问。　

　　使用静态类的优点：

　　　　编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实例。

　　　　静态类可以使你的实现更简单，迅速，因为不必创建实例就可以调用该类中的静态方法，字段，属性，事件

　　　　静态成员常用于不会随着对象状态的变化而变化的数据或计算，请参见实例2　

　　静态类有以下特点：

它们仅包含静态成员。(可以声明静态构造函数以分配初始值或某个状态)
它们不能被实例化。（私有构造函数阻止静态类被实例化）
它们是密封的。（不能被继承）

它们不能包含实例构造函数　实例2：

View Code

 1 /*
 2  * ${res:XML.StandardHeader.CreatedByYangbo}
 3  * 用户： ${YangBo}
 4  * 日期: 10/13/2011
 5  * 时间: 11:03
 6  * 
 7  */
 8 using System;
 9 namespace ClassTestDemo.StaticClass
10 {
11     public static class TemperatureConverte
12     {
13         /// <summary>
14         /// 摄氏度转华氏度
15         /// </summary>
16         /// <param name="centigrade">摄氏温度</param>
17         /// <returns>返回华氏温度</returns>
18         public static Double CentigradeToFahrenheit(string centigrade )
19         {
20             Double Celsious=Convert.ToDouble(centigrade);
21             Double Fahren=(Celsious* 9 / 5)+ 32;
22             return Fahren;
23         }
24         
25         public static Double FahrenheitToCentigrade(string fahrenheit)
26         {
27             Double Fahren=Convert.ToDouble(fahrenheit);
28             Double Celsious= (Fahren-32)* 5 / 9;
29             return Celsious;
30         }    
31     }
32     
33     public  class TempertureChange
34     {
35         public  Double CentigradeToFahrenheit(string centigrade )
36         {
37             Double Celsious=Convert.ToDouble(centigrade);
38             Double Fahren=(Celsious* 9 / 5)+ 32;
39             return Fahren;
40         }
41         
42         public  Double FahrenheitToCentigrade(string fahrenheit)
43         {
44             Double Fahren=Convert.ToDouble(fahrenheit);
45             Double Celsious= (Fahren-32)* 5 / 9;
46             return Celsious;
47         }
48     }
49     
50     public class MainClss
51     {
52         public static void Main()
53         {
54             // Error code,不能创建类的实例
55             TemperatureConverte tc=new ClassTestDemo.StaticClass.TempertureChange;
56             
57             //通过静态类来实现(此处为示例代码，不完整)
58             Console.WriteLine("请输入摄氏温度!")
59             string cel=System.Console.ReadLine();
60             Double Fc=TemperatureConverte.CentigradeToFahrenheit(cel):
61             Console.WriteLine("请输入华氏温度!")
62             string Fat=System.Console.ReadLine();
63             Double Ff=TemperatureConverte.FahrenheitToCentigrade(fat);
64             
65             //通过类TempertureChange来实现转换
66             TempertureChange TC=new TempertureChange();
67             TC.CentigradeToFahrenheit(23);
68             TC.FahrenheitToCentigrade(32);
69             
70         }
71     }
72 }

如果类的声明中有Abstract,表明该类为抽象类

抽象类与普通类
　　抽象类不能被实例化，其它的与普通类相似，与普通类相比，抽象类有抽象方法，并且抽象方法只能声明在抽象类中，抽象方法不能有具体实现，必须在它的的派生类中实现，这一点又和接口（Interface）相同。需要注意的是，当抽象类作为基类时，其派生类必须实现抽象类的所有抽象方法。抽象类从基类继承虚方法时，可以用抽象方法重写虚方法。
此时的抽象类应用场景：
　提供多个派生类可共享的基类公共定义，例如，类库可以定义一个作为其多个函数的参数的抽象类，实例3：

View Code

 1 /*
 2  * ${res:XML.StandardHeader.CreatedByYangbo}
 3  * 用户： ${YangBo}
 4  * 日期: 10/13/2011
 5  * 时间: 14:31
 6  * 
 7  */
 8 using System;
 9 namespace MyAbstratClass
10 {
11     public class AbstractClss 
12     {
13         public abstract class AbClass:VirtualClass
14         {
15             //抽象方法没有实现，所以方法后面是”分号“
16             public abstract void DoSomeThing(string dosome);
17             
18             //利用抽象方法重写虚方法
19             public abstract override int NumAdd(int num1, int num2)
20             {
21                 return base.NumAdd(num1, num2);
22             }
23         }
24         
25         public class Home:AbClass
26         {
27             public override void DoSomeThing(string dosome)
28             {
29                 Console.WriteLine("派生类实现了抽象基类的抽象方法");
30             }
31         
32         }
33         
34         public class VirtualClass
35         {
36             public virtual Int32 NumAdd(Int32 num1,Int32 num2)
37             {
38                 return num1+num2;
39             }
40         }

密封类(sealed class)和分部类(partial class)

前面我们说过，静态类是密封的，那它就有密封类的特点不能继承。也就是不能作为基类，如果想取消基类的虚效果，可以这样写：实例4：
View Code
```
1             public sealed override int NumAdd(int num1, int num2)
2             {
3                 return base.NumAdd(num1, num2);
4             }
```
分布类（partial class）
关键字partial 可以将结构，类，接口，方法的定义拆分到多个.cs源文件。遵守的原则是：

partial 关键字指示可在命名空间中定义该类、结构或接口的其他部分。所有部分都必须使用 partial 关键字。在编译时，各个部分都必须可用来形成最终的类型。各个部分必须具有相同的可访问性，如 public、private 等。

如果将任意部分声明为抽象的，则整个类型都被视为抽象的。如果将任意部分声明为密封的，则整个类型都被视为密封的。如果任意部分声明基类型，则整个类型都将继承该类。

指定基类的所有部分必须一致，但忽略基类的部分仍继承该基类型。各个部分可以指定不同的基接口，最终类型将实现所有分部声明所列出的全部接口。在某一分部定义中声明的任何类、结构或接口成员可供所有其他部分使用。最终类型是所有部分在编译时的组合。
下面的part1和part2代码的作用是一样的。实例5：
code part1:

View Code

1 public partial class MyClass: ICloneable,IComparable
2         {
3             //ICloneable,IComparable是接口
4         }
5         public partial class MyClass: Home
6         {
7             //Home 是一个示例类
8         }

code part2:

View Code

1 public partial class MyClass: ICloneable,IComparable,Home
2         {
3             //ICloneable,IComparable是接口,Home 是一个示例类
4         }

关于类先写这么多，希望大家拍砖！