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

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

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

　　

/*
 * ${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：

  /*
   * ${res:XML.StandardHeader.CreatedByYangbo}
   * 用户： ${YangBo}
   * 日期: 10/13/2011
   * 时间: 11:03
   * 
   */
  using System;
  namespace ClassTestDemo.StaticClass
  {
      public static class TemperatureConverte
      {
          /// <summary>
          /// 摄氏度转华氏度
          /// </summary>
          /// <param name="centigrade">摄氏温度</param>
          /// <returns>返回华氏温度</returns>
          public static Double CentigradeToFahrenheit(string centigrade )
          {
              Double Celsious=Convert.ToDouble(centigrade);
              Double Fahren=(Celsious* 9 / 5)+ 32;
              return Fahren;
          }
          
          public static Double FahrenheitToCentigrade(string fahrenheit)
          {
              Double Fahren=Convert.ToDouble(fahrenheit);
              Double Celsious= (Fahren-32)* 5 / 9;
              return Celsious;
          }    
      }
      
      public  class TempertureChange
      {
          public  Double CentigradeToFahrenheit(string centigrade )
          {
              Double Celsious=Convert.ToDouble(centigrade);
              Double Fahren=(Celsious* 9 / 5)+ 32;
              return Fahren;
          }
          
          public  Double FahrenheitToCentigrade(string fahrenheit)
          {
              Double Fahren=Convert.ToDouble(fahrenheit);
              Double Celsious= (Fahren-32)* 5 / 9;
              return Celsious;
          }
      }
      
      public class MainClss
      {
          public static void Main()
          {
              // Error code,不能创建类的实例
              TemperatureConverte tc=new ClassTestDemo.StaticClass.TempertureChange;
              
              //通过静态类来实现(此处为示例代码，不完整)
              Console.WriteLine("请输入摄氏温度!")
              string cel=System.Console.ReadLine();
              Double Fc=TemperatureConverte.CentigradeToFahrenheit(cel):
              Console.WriteLine("请输入华氏温度!")
              string Fat=System.Console.ReadLine();
              Double Ff=TemperatureConverte.FahrenheitToCentigrade(fat);
              
              //通过类TempertureChange来实现转换
              TempertureChange TC=new TempertureChange();
              TC.CentigradeToFahrenheit(23);
              TC.FahrenheitToCentigrade(32);
              
          }
      }
  }

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

• 抽象类与普通类

• 　　抽象类不能被实例化，其它的与普通类相似，与普通类相比，抽象类有抽象方法，并且抽象方法只能声明在抽象类中，抽象方法不能有具体实现，必须在它的的派生类中实现，这一点又和接口（Interface）相同。需要注意的是，当抽象类作为基类时，其派生类必须实现抽象类的所有抽象方法。抽象类从基类继承虚方法时，可以用抽象方法重写虚方法。

• 此时的抽象类应用场景：

• 　提供多个派生类可共享的基类公共定义，例如，类库可以定义一个作为其多个函数的参数的抽象类 ，实例3：

• /*
   * ${res:XML.StandardHeader.CreatedByYangbo}
   * 用户： ${YangBo}
   * 日期: 10/13/2011
   * 时间: 14:31
   * 
   */
  using System;
  namespace MyAbstratClass
  {
      public class AbstractClss 
      {
          public abstract class AbClass:VirtualClass
          {
              //抽象方法没有实现，所以方法后面是”分号“
              public abstract void DoSomeThing(string dosome);
              
              //利用抽象方法重写虚方法
              public abstract override int NumAdd(int num1, int num2)
              {
                  return base.NumAdd(num1, num2);
              }
          }
          
          public class Home:AbClass
          {
              public override void DoSomeThing(string dosome)
              {
                  Console.WriteLine("派生类实现了抽象基类的抽象方法");
              }
          
          }
          
          public class VirtualClass
          {
              public virtual Int32 NumAdd(Int32 num1,Int32 num2)
              {
                  return num1+num2;
              }
          }

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

• 前面我们说过，静态类是密封的，那它就有密封类的特点不能继承。也就是不能作为基类，如果想取消基类的虚效果，可以这样写：实例4：

              public sealed override int NumAdd(int num1, int num2)
              {
                  return base.NumAdd(num1, num2);
              }

  分布类（partial class）

• 关键字partial 可以将结构，类，接口，方法的定义拆分到多个.cs源文件。遵守的原则是：

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

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

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

• 下面的part1和part2代码的作用是一样的。实例5：

• code part1:

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

  code part2: 
  

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

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