C#-base-new-sealed-abstract-interface的用法:

通过base 关键字访问基类的成员： 

　　　 调用基类上已被其他方法重写的方法。 
　　　 指定创建派生类实例时应调用的基类构造函数。 
　　　 基类访问只能在构造函数、实例方法或实例属性访问器中进行。 
　　　 从静态方法中使用 base 关键字是错误的。 

范例1

using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 /// 
 public class student
 {
  protected string sname="mary";
  protected int sID=23698;
  public virtual void print()
  {
   Console.WriteLine ("Name="+sname);
   Console.WriteLine ("ID="+sID);

  }
 }
 public class people :student
 {
  protected string psex="girl";
  public override void print()
  {
   base.print ();
   Console.WriteLine ("SEX="+psex);

  }

 }
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   people people1=new people ();
   people1.print ();

  }
 }
}

范例2:

2:sealed
使用密封类可以防止对类的继承。C#还提出了密封方法（sealedmethod） 的概念，以防止在方法所在类的派生类中对该方法的重载。对方法可以使用sealed 修饰符，这时我们称该方法是一个密封方法。 

不是类的每个成员方法都可以作为密封方法密封方法，必须对基类的虚方法进行重载，提供具体的实现方法。所以，在方法的声明中，sealed 修饰符总是和override 修饰符同时使用。请看下面的例子代码： 

using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 /// 
 class class1 
 { 
  public virtual void print( ) 
  { 
   Console.WriteLine("the class1 print") ; 
  } 
  public virtual void print1( ) 
  {
   Console.WriteLine("the class1 print1") ;
  } 
 } 
 class class2 :class1
 { 
   public sealed override void print( ) 
  { 
   Console.WriteLine("the class2 print") ;
  } 
  public override  void print1( ) 
  {
   Console.WriteLine("the class2 print1") ;
  } 
 }
 class class3 :class2
 { 
  public override void print1( ) 
  { 
   Console.WriteLine("the class3 print1") ; 
  } 
  
 } 
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   class3 myclass3=new class3 ();
   
   myclass3.print1 ();
   

  }
 }
}

范例3:

3:base new 
使用 new 修饰符隐藏基类成员, 和通过base 关键字访问基类的成员：
使用 new 修饰符可以显式隐藏从基类继承的成员。若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它。
using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 /// 
 public class baseclass
 { 
  public static  int x = 55 ; 
  public  int y = 22 ; 
  public void print()
  {
   Console.WriteLine (x);
   Console.WriteLine (y);
  }
 }
 public class baseclass1 :baseclass
 {
  public new static int x=12;
  public new void print()
  {
      base.print ();
   Console.WriteLine (x);

  }
 }
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   baseclass1 mybaseclass=new baseclass1 ();
   mybaseclass.print ();

   

  }
 }
}
继承与访问修饰符 

　　 访问修饰符是一些关键字，用于指定声明的成员或类型的可访问性。类的继承中有四个访问修饰符： public protected internal private。使用这些访问修饰符可指定下列五个可访问性级别： public, protected internal, internal, protected, private。 
声明的可访问性  意义  
public  访问不受限制。  
protected  访问仅限于包含类或从包含类派生的类型。  
internal  访问仅限于当前项目。  
protected internal  访问仅限于从包含类派生的当前项目或类型。  
private  访问仅限于包含类型。

范例4:

私有成员的可访问域只包括声明该成员的类型的程序文本。在下面的示例中 
class A 
{ 
int x ; 
static void F(B b) { 
b.x = 1 ; // 对 
} 
} 
class B: A 
{ 
static void F(B b) { 
b.x = 1 ; // 错误 
} 
}  

　　类 B 继承类 A 的私有成员 x。因为该成员是私有的，所以只能在 A 的"类体"中对它进行访问。因此，对 b.x 的访问在 A.F 方法中取得了成功，在 B.F 方法中却失败了。 

类  类类型的直接基类必须至少与类类型本身具有同样的可访问性。  
接口  接口类型的显式基接口必须至少与接口类型本身具有同样的可访问性。  
委托  委托类型的返回类型和参数类型必须至少与委托类型本身具有同样的可访问性。  
常数  常数的类型必须至少与常数本身具有同样的可访问性。  
字段  字段的类型必须与至少字段本身具有同样的可访问性。  
方法  方法的返回类型和参数类型必须至少与方法本身具有同样的可访问性。  
属性  属性的类型必须至少与属性本身具有同样的可访问性。  
事件  事件的类型必须至少与事件本身具有同样的可访问性。  
索引器  索引器的类型和参数类型必须至少与索引器本身具有同样的可访问性。  
运算符  运算符的返回类型和参数类型必须至少与运算符本身具有同样的可访问性。  
构造函数  构造函数的参数类型必须至少与构造函数本身具有同样的可访问性。 

范例5:

base new用法:

using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 /// 
 class caculatemul
 {
  protected string caculatetype="乘法";
  public caculatemul()
  {
          Console.WriteLine ("下面进行乘法运算");
  }
  public virtual void caculate (int a,int b)
  {
   int result=a*b;
   Console.WriteLine("{0}*{1}={2}",a,b,result);

  }
 }
 class caculateadd :caculatemul
 {
  protected new string caculatetype="加法";
  public caculateadd() :base()
  {
   Console.WriteLine ("下面进行加法运算");
  }
  public override void caculate(int a,int b)
  {
   Console.WriteLine ("以下为{0}的计算结果",base.caculatetype );
   base.caculate (a,b);
   Console.WriteLine ("以下为{0}的计算结果",caculatetype);
   int result=a+b;
   Console.WriteLine ("{0}+{1}={2}",a,b,result);

  }
 }

 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   // 
   caculateadd mycaculateadd=new caculateadd ();
   mycaculateadd.caculate (25,6);
   Console.ReadLine ();

  }
 }
}

范例6:abstract抽象类的用法:

using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 ///
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   double l;
   Console.WriteLine ("请输入边长");
   l=double.Parse (Console.ReadLine ());
   squareclass square=new squareclass ("正方形",l);
   square.getresult ();

   

  }
 }
 abstract class templateclass
 {
  public double l=0;
  public templateclass(string shape,double r)
  {
   this.theshape (shape);
   this.l =r;

  }
  private void theshape(string shape)
  {
   Console.WriteLine ("目前测量的形状为{0}",shape);
  }
  public void getresult()
  {
   length(l);
   area(l);
   volume(l);

  }
  abstract protected void length(double l);
  abstract protected void area(double l);
  abstract protected void volume(double l);

 }
 class squareclass :templateclass
 {
  public squareclass(string shape,double l) :base(shape,l)
  {
  }
  protected override void length(double l)
  {
   double squarelength;
   squarelength=4*l;
   Console.WriteLine ("边长为{0}的正方形的周长为{1}",l,squarelength);

  }
  protected override void area(double l)
  {
   double area;
   area=Math.Pow (l,2);
   Console.WriteLine ("边长为{0}的正方形面积为{1}",l,area);
  }
  protected override void volume(double l)
  {
   double volume;
   volume=Math.Pow (l,3);
   Console.WriteLine ("边长为{0}的正方形体积为{1}",l,volume);

  }

 }
}
范例7:using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 ///
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   double a,b;
   Console.WriteLine ("please input the first numebr");
   a=double.Parse (Console.ReadLine ());
   Console.WriteLine ("please input the second number");
   b=double.Parse (Console.ReadLine ());
   caculate mycaculate=new caculate (a,b);
   mycaculate.getresult ();

   

  }
 }
 abstract class myabstract
 {
  double a,b;
  public myabstract(double a,double b)
  {
            this.a =a;
   this.b =b;
  }

  public void getresult()
  {
   add(a,b);
   sub(a,b);
   mul(a,b);
   divide(a,b);
   
   
  }
  abstract protected void add(double a,double b);
  abstract protected void sub(double a,double b);
  abstract protected void mul(double a,double b);
  abstract protected void divide(double a,double b);
  
 }
 class caculate :myabstract
 {
  public caculate(double a,double b) :base(a,b)
  {
  }
  protected override void add(double a,double b)
  {
   double result;
   result=a+b;
   Console.WriteLine ("{0}+{1}={2}",a,b,result);
  }
  protected override void sub(double a,double b)
  {
   double result=a-b;
   Console.WriteLine ("{0}-{1}={2}",a,b,result);
  }
  protected override void mul(double a,double b)
  {
   double result=a*b;
   Console.WriteLine ("{0}*{1}={2}",a,b,result);
  }
  protected override void divide(double a,double b)
  {
   if(b==0)
   {
    Console.WriteLine ("input erro");
   }
   else
   {
    double result=a/b;
    Console.WriteLine ("{0}/{1}={2}",a,b,result);
   }
  }
 
 }
}
抽象类包含了一以上的抽象方法，这些方法只提供函数名称与签名，由继承的派生类来实现，派生类必须使用"override"重写抽象类的方法并且实现抽象类的所有方法。

范例8:interfac-接口的用法:

using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 ///
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   double a,b;
   Console.WriteLine ("please input the first number");
   a=double.Parse (Console.ReadLine ());
   Console.WriteLine ("please input the second numebr");
   b=double.Parse (Console.ReadLine ());
   
   caculate mycaculate=new caculate ();
   Icaculate myIcaculate=mycaculate as Icaculate ;//使用关键字 “as”将mycaculate塑造成为接口类型。
   myIcaculate.add (a,b);
   myIcaculate.sub (a,b);
   myIcaculate.mul (a,b);
   myIcaculate.divide (a,b);

   

  }
 }
 interface Icaculate
 {
  void add(double a,double b);
  void sub(double a,double b);
  void mul(double a,double b);
  void divide(double a,double b);

 }
 class caculate :Icaculate
 {
  public void add(double a,double b)
  {
   double result;
   result=a+b;
   Console.WriteLine ("{0}+{1}={2}",a,b,result);
  }
  public void sub(double a,double b)
  {
   double result;
   result=a-b;
   Console.WriteLine ("{0}-{1}={2}",a,b,result);
  }
  public void mul(double a,double b)
  {
   double result;
   result=a*b;
   Console.WriteLine ("{0}*{1}={2}",a,b,result);
  }
  public void divide(double a,double b)
  {
   double result;
   if(b==0)
   {
    Console.WriteLine ("error ");
   }
   else
   {
    result=a/b;
    Console.WriteLine ("{0}/{1}={2}",a,b,result);
   }
  }
 }
 
}

范例9:继承多个接口：
using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 ///
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   double a,b;
   Console.WriteLine ("please input the first number");
   a=double.Parse (Console.ReadLine ());
   Console.WriteLine ("please input the second numebr");
   b=double.Parse (Console.ReadLine ());
   
   caculate mycaculate=new caculate ();
   Icaculate myIcaculate=mycaculate as Icaculate ;//使用关键字 “as”将mycaculate塑造成为接口类型。
   
   mycaculate.add (a,b);
   mycaculate.sub (a,b);
   mycaculate.mul (a,b);
   mycaculate.divide (a,b);

   

  }
 }
 interface Icaculate
 {
  void add(double a,double b);
  void sub(double a,double b);
  

 }
 interface Icaculate1
 {
  void mul(double a,double b);
  void divide(double a,double b);
 }
 class caculate :Icaculate,Icaculate1
 {
  public void add(double a,double b)
  {
   double result;
   result=a+b;
   Console.WriteLine ("{0}+{1}={2}",a,b,result);
  }
  public void sub(double a,double b)
  {
   double result;
   result=a-b;
   Console.WriteLine ("{0}-{1}={2}",a,b,result);
  }
  public void mul(double a,double b)
  {
   double result;
   result=a*b;
   Console.WriteLine ("{0}*{1}={2}",a,b,result);
  }
  public void divide(double a,double b)
  {
   double result;
   if(b==0)
   {
    Console.WriteLine ("error ");
   }
   else
   {
    result=a/b;
    Console.WriteLine ("{0}/{1}={2}",a,b,result);
   }
  }
 }
 
}

范例10:：
 通过接口可以实现多重继承，这样接口里面有想同的方法名称，是不可避免的，那么如果出现这样的问题我怎么解决那，下面我门就来看一个范例，通过这个范例，我们就可以清楚地掌握解决这种问题的方法了，
using System;

namespace ConsoleApplication6
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 ///
 
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //
   // TODO: 在此处添加代码以启动应用程序
   //
   double a,b;
   Console.WriteLine ("please input the first number");
   a=double.Parse (Console.ReadLine ());
   Console.WriteLine ("please input the second numebr");
   b=double.Parse (Console.ReadLine ());
   
   caculate mycaculate=new caculate ();
   Icaculate myIcaculate=mycaculate as Icaculate ;//使用关键字 “as”将mycaculate塑造成为接口类型。
   
   mycaculate.add (a,b);
   mycaculate.sub (a,b);
   mycaculate.add  (a,b);
   mycaculate.sub (a,b);

   

  }
 }
 interface Icaculate
 {
  void add(double a,double b);
  void sub(double a,double b);
  

 }
 interface Icaculate1
 {
  void add(double a,double b);
  void sub(double a,double b);
 }
 class caculate :Icaculate,Icaculate1
 {
  public void add(double a,double b)
  {
   double result;
   result=a+b;
   Console.WriteLine ("{0}+{1}={2}",a,b,result);
  }
  public void sub(double a,double b)
  {
   double result;
   result=a-b;
   Console.WriteLine ("{0}-{1}={2}",a,b,result);
  }
   void Icaculate.add (double a,double b)//注意：这里不能声明成"public"类型的方法。 
  {
   double result;
   result=a*b;
   Console.WriteLine ("{0}*{1}={2}",a,b,result);
  }
  void Icaculate.sub (double a,double b)//注意：这里不能声明成"public"类型的方法。
  {
   double result;
   if(b==0)
   {
    Console.WriteLine ("error ");
   }
   else
   {
    result=a/b;
    Console.WriteLine ("{0}/{1}={2}",a,b,result);
   }
  }
 }
 
}