范例一:

using System;
interface Employee
{
 void Startwork();
}
class Manager:Employee
{
 string _name;
 public Manager(string name)
 {
 _name=name;
 }
 public void Startwork()
 {
  Console.WriteLine(_name + " assign somebody to work");
 }
}
class Sellor:Employee
{
 string _name;
 public Sellor(string name)
 {
 _name=name;
 }
 public void Startwork()
 {
  Console.WriteLine(_name + " sell the product");
 }
}
class Test
{
 static void Main()
 {
  Employee aa=new Manager("zhang san");
  Employee bb=new Sellor("li si ");
  aa.Startwork();
  bb.Startwork();
 }
}

结果:

zhang san assign somebody to work
li si  sell the product

可以看出是将类Manager,Sellor的共同方法集中起来,组成一个新的接口(类似于类).这个接口有方法Startwork(), 此例子中可以不用接口访问, 也可以达到同样效果. 如下例子:

范例二:

using System;

class Manager
{
 string _name;
 public Manager(string name)
 {
 _name=name;
 }
 public void Startwork()
 {
  Console.WriteLine(_name + " assign somebody to work");
 }
}
class Sellor
{
 string _name;
 public Sellor(string name)
 {
 _name=name;
 }
 public void Startwork()
 {
  Console.WriteLine(_name + " sell the product");
 }
}
class Test
{
 static void Main()
 {
  Manager aa=new Manager("zhang san");
  Sellor bb=new Sellor("li si ");
  aa.Startwork();
  bb.Startwork();
 }
}

结果:

zhang san assign somebody to work
li si  sell the product

可以看出不用接口也可以达到效果, 但这个就不是多态了, 因为你无法用一个类集合来表示他们,如上例子可以用employee[]来表示他们.

范例一:
using System;

abstract class Employee         //抽象类
{
    protected string _name;
    protected  Employee(){}
    protected Employee(string name)   //抽象构造函数, 记住抽象构造函数只有在子类被实例后才可以被初始.
    {
        _name=name;
   
    }
    public abstract void StartWork();  //抽象方法, 不可有方法实体.
   


}
class Manager:Employee
{
    public Manager(string name):base(name){}  //声明manager的构造函数成员变量name同父类employ构造成员变量相同.
    public override void StartWork()
    {
        Console.WriteLine(_name+" assign work to employee");  //可以直接调用抽象基类的成员变量_name;
   
    }


}
class Sellor:Employee
{
    public Sellor(string name):base(name){}
    public override void StartWork()
    {
        Console.WriteLine(_name+" sell products");
   
    }


}
class Test
{
    public static void Main()
    {
    Manager mana=new Manager("zhanag san"); // 如果改写成为Emplolyee mana=new Manager("张山"); 这时候执行结果也是一样的. 因为Employee的类是抽象的,所以他的实例mana无法被赋予类Empolyee的, 所以还是各自的new建立的类.
    Sellor sell=new Sellor("wang liu");
    Console.WriteLine("start");
    mana.StartWork(); 
    sell.StartWork();
    }
}

结果:
start
assign work to employee
wang liu sell products

using System;
class Employee                                       //基类
{  
 protected string _name;
 public Employee(){}                    //构造函数   
public Employee(string name)     //构造函数  
 {  
     _name=name;  
  }   
public virtual void StartWork()     //虚方法: 虚方法可以声明方法实体 
  {   
    Console.WriteLine(_name+"start work");      
 }
}
class Manager:Employee
{ 
  public Manager(string name){}     //name只是在本类的成员变量.  
 public override void StartWork()  
 {  
     base.StartWork();     // 执行基类的方法.   
    Console.WriteLine("assign work to employee");   
  }
}
class Sellor:Employee
{
   public Sellor(string name){}  
 public override void StartWork() 
  {
       base.StartWork();    
   Console.WriteLine("sell products");   
    }
}
class Test
{  
 public static void Main()  
 { 
  Employee[] temp=new Employee[2];    //建立新的employ类并赋给employ类的实例temp.  
 temp[0]=new Manager("zhanag san");   //建立新类manager并赋给employ类的实例temp1. 
  temp[1]=new Sellor("wang liu"); 
  Console.WriteLine("start"); 
  foreach (Employee aa in temp)   
{    
   aa.StartWork();    //实例temp的类是employ, 他们执行方法StartWork, 但此方法是虚的, 已经被子类对应的方法override, 所以执行的是override方法.     此时的实例aa虽然是employ类,但startwork已经被子类重写. 所以父类的virtual方法已经不存在在aa的实例中了.
   } 
  }
}

结果:
start
start work
assign work to employee
start work
sell products

范例二:
如果将virtual去掉, 这个时候,aa实例的startwork方法就是类employ的方法. 而不是子类方法, 无法实现多态.
using System;

class Employee
{
    protected string _name;
    public Employee(){}
    public Employee(string name)
    {
        _name=name;
   
    }
    public void StartWork()
    {
        Console.WriteLine(_name+"start work");
   
    }



}
class Manager:Employee
{
    public Manager(string name){}
    public void StartWork()
    {
        base.StartWork();
        Console.WriteLine("assign work to employee");
   
    }


}
class Sellor:Employee
{
    public Sellor(string name){}
    public  void StartWork()
    {
        base.StartWork();
        Console.WriteLine("sell products");
   
    }


}
class Test
{
    public static void Main()
    {
    Employee[] temp=new Employee[2];
    temp[0]=new Manager("zhanag san");
    temp[1]=new Sellor("wang liu");
    Console.WriteLine("start");
    foreach (Employee aa in temp)
    {
        aa.StartWork();  //因为aa是employ类的实例, 而且方法startwork没有被重写, 所以就是employ的方法.
   
    }
    }
}

执行结果:
start
start work;
start work;


范例三:
base关键字是指的是将子类的方法或者构造函数的成员变量付给父类的方法或者构造函数的成员变量.如上例子:

using System;

class Employee
{
    protected string _name;
    public Employee(){}
    public Employee(string name)       //父类构造函数
    {
        _name=name;
   
    }
    public virtual void StartWork()    //父类成员方法.
    {
        Console.WriteLine(_name+"  start work  ");
   
    }



}
class Manager:Employee
{
    public Manager(string name):base(name){}  //base表示将子类的name的值映射到父类对应的成员变量.
    public override void StartWork()
    {
        base.StartWork();    //base指的父类方法startwork, 尽管父类方法是虚拟的, 但是还可以直接使用的,参见范例三
        Console.WriteLine("assign work to employee");
   
    }


}
class Sellor:Employee
{
    public Sellor(string name):base(name){}
    public override void StartWork()
    {
        base.StartWork();
        Console.WriteLine("sell products");
   
    }


}
class Test
{
    public static void Main()
    {
    Employee[] temp=new Employee[2];
    temp[0]=new Manager("zhanag san");
    temp[1]=new Sellor("wang liu");
    Console.WriteLine("start");
    foreach (Employee aa in temp)
    {
        aa.StartWork();
   
    }
    }
}

结果:

start
zhanag san  start work
assign work to employee
wang liu  start work
sell products

范例三:
using System;

class Employee
{
    protected string _name;
    public Employee(){}
    public Employee(string name)
    {
        _name=name;
   
    }
    public virtual void StartWork()
    {
        Console.WriteLine(_name+"  start work  ");
   
    }



}
class Manager:Employee
{
    public Manager(string name):base(name){}
    public override void StartWork()
    {
        base.StartWork();
        Console.WriteLine("assign work to employee");
   
    }


}
class Sellor:Employee
{
    public Sellor(string name):base(name){}
    public override void StartWork()
    {
        base.StartWork();
        Console.WriteLine("sell products");
   
    }


}
class Test
{
    public static void Main()
    {
        Employee emp=new Employee();
    Manager mana=new Manager("zhanag san");
    Sellor sell=new Sellor("wang liu");
    Console.WriteLine("start");
    emp.StartWork();   //写出类employ的实例emp的方法 startwork. 尽管他是virtual的, 但还是可以写出.
    mana.StartWork(); //写出类manager的实例mana的方法startwork.
    sell.StartWork();
    }
}

结果:
start
  start work    ------emp.StartWork  结果.
zhanag san  start work   ----mana 运行结果.
assign work to employee
wang liu  start work
sell products

范例一:

接口继承

using System;
interface iA
{
    void F();
}
interface iB:iA
{
    new void F();
}
interface iC:iA
{
    void G();
}
interface iBC:iB,iC
{

}
class CL:iBC
{
    public void F()
    {
    Console.WriteLine("iB.F() method");
    }
    public void G()
    {
   
    }
}
class Test
{
    static void Main()
    {
        CL a=new CL();  //CL类的实例a;
        a.F();         //类CL的方法;
        ((iA)a).F();   //接口iA的方法, 此接口iA的方法已经被iB的new void F()隐藏.所以只是iB的方法.
        ((iB)a).F();   //iB的接口方法.
        ((iC)a).F();   //iC的接口, 因为iC没有F()的方法,故导向iC的父接口iA, 虽然iC继承于iA, 但由于iA方法F()被iB的方法F()隐藏并取代. 所以调用的iA方法,其实就是iB();
        ((iBC)a).F();  //iBC接口没有方法F(),故他会向父接口iB接口中方法.
    }
}

using System;
class A
{
  public A()
  {
  Console.WriteLine("A without any parameter.");
  }
  public A(int i)
  {
  Console.WriteLine("A with a parameter.");
  }

}

class B: A
{
  public B()
  {
  Console.WriteLine("B without any parameters.");
  }
  public B (int i)
  {
  Console.WriteLine("B with a parameter");
  }

}
class classcompare
{
  public static void Main(){
   B a =new B(100);
   
   
   }

 
}

结果:

A without any parameter.
B with a parameter

说明: B 类在被调用时候一定会先执行父类的无参构造函数.

构造函数中, 如果B类继承于A类时候, 那么B类先条用父类A的构造函数:

using System;
class A
{
  public A()
  {
  Console.WriteLine("A without any parameter.");
  }
  public A(int i)
  {
  Console.WriteLine("A with a parameter.");
  }

}

class B: A
{
  public B()
  {
  Console.WriteLine("B without any parameters.");
  }
  public B (int i)
  {
  Console.WriteLine("B with a parameter");
  }

}
class classcompare
{
  public static void Main(){
   B a =new B();
   
   
   }

 
}

 

结果:

A without any parameter.
B without any parameters.

引用类型只是将指针指向内存中得存储单元, 但值类型是将内存单元复制到自己内存副本中, 也就说引用类型内存中存储值只有个, 但值类型确实有两个.引用类型主要有:类,数组,索引等.值类型有各种数据,列举等.
using System;
class vall{          //------引用类型
public int a;
public int b;


}
 struct va{        //-----值类型
 public int a;
 public int b;
 
 
 }
 class tt{
 public static void Main(){
 vall n1=new vall();
 n1.a=10;
 n1.b=15;
 vall n2=n1;                   //----只是赋值指针, 将指针指向n1.a
 Console.WriteLine(n2.a);  
 Console.WriteLine(n2.b);
 n1.a=20;
 n1.b=25;
 Console.WriteLine("the new change");
 Console.WriteLine(n2.a);
 Console.WriteLine(n2.b);
 
 va v1= new va();
 v1.a=10;
 v1.b=15;
 va v2=v1;                     //创建v2.并将v1de值赋值到v2中.
 Console.WriteLine(v2.a);
 Console.WriteLine(v2.b);
 Console.WriteLine("change new");
 v1.a=20;
 v1.b=25;
 Console.WriteLine(v2.a);
 Console.WriteLine(v2.b);
 
 
 
 
 }
 
 
 
 }

结果:
10
15
the new change
20
25
10
15
change new
10
15

   
    只能输入数字："^[0-9]*$"。

　　只能输入n位的数字："^\d{n}$"。

　　只能输入至少n位的数字："^\d{n,}$"。

　　只能输入m~n位的数字：。"^\d{m,n}$"

　　只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。

　　只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。

　　只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。

　　只能输入非零的正整数："^\+?[1-9][0-9]*$"。

　　只能输入非零的负整数："^\-[1-9][]0-9"*$。

　　只能输入长度为3的字符："^.{3}$"。

　　只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。

　　只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。

　　只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。

　　只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。

　　只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。

　　验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。

　　验证是否含有^%&’,;=?$\"等字符："[^%&’,;=?$\x22]+"。

　　只能输入汉字："^[\u4e00-\u9fa5]{0,}$"

　　验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。

　　验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。

　　验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX- XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。

　　验证身份证号(15位或18位数字)："^\d{15}|\d{18}$"。

　　验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。

　　验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为;"01"～"09"和"1"～"31"。

　　利用正则表达式限制网页表单里的文本框输入内容：

　　用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,’’) " ōnbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\u4E00-\u9FA5]/g,’’))"

　　用正则表达式限制只能输入全角字符： ōnkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,’’)" ōnbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\uFF00-\uFFFF]/g,’’))"

　　用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,’’) "onbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\d]/g,’’))"

　　用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,’’) "onbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\d]/g,’’))"

　　得用正则表达式从URL地址中提取文件名的javascrīpt程序，如下结果为page1

以下是引用片段： 　　s="http://www.9499.net/page1.htm" 　　s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2") 　　alert(s)

　　匹配双字节字符(包括汉字在内)：[^\x00-\xff]

　　应用：计算字符串的长度(一个双字节字符长度计2，ASCII字符计1)

以下是引用片段： 　　String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

　　匹配空行的正则表达式：\n[\s| ]*\r

　　匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/

　　匹配首尾空格的正则表达式：(^\s*)|(\s*$)

以下是引用片段： 　　String.prototype.trim = function() 　　{ 　　return this.replace(/(^\s*)|(\s*$)/g, ""); 　　}

　　利用正则表达式分解和转换IP地址：

　　下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascrīpt程序：

以下是引用片段：
　　function IP2V(ip)
　　{
　　re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
　　if(re.test(ip))
　　{
　　return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
　　}
　　else
　　{
　　throw new Error("Not a valid IP address!")
　　}
　　}
不过上面的

程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

以下是引用片段： 　　var ip="10.100.20.168" 　　ip=ip.split(".") 　　alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

　　符号解释：

　　\

　　将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，’n’ 匹配字符 "n"。’\n’ 匹配一个换行符。序列 ’\\’ 匹配 "\" 而 "\(" 则匹配 "("。

　　^

　　匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

　　$

　　匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

　　*

　　匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。

　　+

　　匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

　　?

　　匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。

　　{n}

　　n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 "Bob" 中的 ’o’，但是能匹配 "food" 中的两个 o。

　　{n,}

　　n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 "Bob" 中的 ’o’，但能匹配 "foooood" 中的所有 o。’o{1,}’ 等价于 ’o+’。’o{0,}’ 则等价于 ’o*’。

　　{n,m}

　　m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。’o{0,1}’ 等价于 ’o?’。请注意在逗号和两个数之间不能有空格。

　　?

　　当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，’o+?’ 将匹配单个 "o"，而 ’o+’ 将匹配所有 ’o’。

　　.

　　匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符，请使用象 ’[.\n]’ 的模式。

　　(pattern)

　　匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBscrīpt 中使用 SubMatches 集合，在Jscrīpt 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ’\(’ 或 ’\)’。

　　(?:pattern)

　　匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， ’industr(?:y|ies) 就是一个比 ’industry|industries’ 更简略的表达式。

　　(?=pattern)

　　正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，’Windows (?=95|98|NT|2000)’ 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

　　(?!pattern)

　　负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始

　　x|y

　　匹配 x 或 y。例如，’z|food’ 能匹配 "z" 或 "food"。’(z|f)ood’ 则匹配 "zood" 或 "food"。

　　[xyz]

　　字符集合。匹配所包含的任意一个字符。例如， ’[abc]’ 可以匹配 "plain" 中的 ’a’。

　　[^xyz]

　　负值字符集合。匹配未包含的任意字符。例如， ’[^abc]’ 可以匹配 "plain" 中的’p’。

　　[a-z]

　　字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ’a’ 到 ’z’ 范围内的任意小写字母字符。

　　[^a-z]

　　负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ’a’ 到 ’z’ 范围内的任意字符。

　　\b

　　匹配一个单词边界，也就是指单词和空格间的位置。例如， ’er\b’ 可以匹配"never" 中的 ’er’，但不能匹配 "verb" 中的 ’er’。

　　\B

　　匹配非单词边界。’er\B’ 能匹配 "verb" 中的 ’er’，但不能匹配 "never" 中的 ’er’。

　　\cx

　　匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ’c’ 字符。

　　\d

　　匹配一个数字字符。等价于 [0-9]。

　　\D

　　匹配一个非数字字符。等价于 [^0-9]。

　　\f

　　匹配一个换页符。等价于 \x0c 和 \cL。

　　\n

　　匹配一个换行符。等价于 \x0a 和 \cJ。

　　\r

　　匹配一个回车符。等价于 \x0d 和 \cM。

　　\s

　　匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

　　\S

　　匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

　　\t

　　匹配一个制表符。等价于 \x09 和 \cI。

　　\v

　　匹配一个垂直制表符。等价于 \x0b 和 \cK。

　　\w

　　匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

　　\W

　　匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

　　\xn

　　匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 "A"。’\x041’ 则等价于 ’\x04’ & "1"。正则表达式中可以使用 ASCII 编码。.

　　\num

　　匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符。

　　\n

　　标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

　　\nm

　　标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

　　\nml

　　如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

　　\un

　　匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

using System;
class Vehicle   //基类
{
 public int wheels;
 protected float weight;
 public  Vehicle(){;}
 public Vehicle(int w, float g){
  wheels=w;
  
  weight=g;
  
 }
 public void show(){
  Console.WriteLine("the wheels of the Vehicle are {0}",wheels);
  Console.WriteLine("the weight of the Vehicle is {0}",weight);
  
  
  }
  
 }
class Train
{
 public int num;
 private int passenger;
 private float weight;
 public Train(){
  
  ;
  
  }
 public Train(int n, int p, float w){
  num=n;
  passenger=p;
  weight=w;
  
  
  }
 public void show(){
  Console.WriteLine("the num of the train {0}",num);
  Console.WriteLine("the passenger of the train {0}",passenger);
  Console.WriteLine("the weight of the train {0}",weight);
  
  
  
  }
 
 }
 
class Car:Vehicle{   //car 扩展于基类
    int passenger;
    public Car(int w, float g, int p):base(w,g) {   //注意这个语法
     wheels=w;
     weight=g;
     passenger=p;
     
     
     
     }
     new public void show(){
      Console.WriteLine("the wheels of the car is {0}",wheels);
      Console.WriteLine("the weight of the car is {0}",weight);
      Console.WriteLine("the passenger of the car is {0}",passenger);
      
      
      }

 

}

class Tes
{
 public static void Main(){
  Vehicle v1=new Vehicle(4,5);
  Train T1=new Train();
  Train T2=new Train(10,100,100);
  Car  C1=new Car(4,2,4);
  v1.show();
  T1.show();
  T2.show();
  C1.show();
  
  
  
  
  }
 
 
 
 
 }

关于static的解析:

 

1. this的用法: this是一个变量,如果他在类中,代表这个类就是在class a{}中.如果在方法后者构造函数中就代表这个方法或者函数.如在 int f(){this}, void m(){this}. 一句话, 在那里就代表是那个.

2. static 和 instant, static是类中分给的一个固定存储单元. 所以他属于类的. instant是变化的, 如果实例化一个对象, 那么他就属于这个对象. 但实例化的对象不能访问static的类.但他们都可以被本类中有用 如:

   class a{

     int a;

    static int b;

    void M(){

    a=1;  //有效

    b=1;  //有效

 

}

}

   class b

{

   a t=new a(); //实例化一个类,也叫创建一个对象 t.

    t.a=2;   //有效.

    t.b=2;    // 无效.

    a.a=3;  //无效;

    a.b=3; // 有效

}

public意思是指变量可以被继承的类和new的实例条用.作用于全域.

private 只能在基类中使用. 继承的,实例后的都不可以.

using System;
class Vehicle
{
 public int wheel; //公有变量wheel,
 private float weight: //私有变量weight
 public void F(){
 wheel=4;   //合法调用
 weight=2.2;  //合法调用.
 
 }

}
class Train
{
 public int num;   //公有变量 num
 private int passenger; //私有变量passenger
 public void F(){
 num=4; //合法
 passenger=100; //合法
 Vehicle v= new Vehicle();
 v.wheel=4;  //合法, 调用到Vehicle的类中变量.
 v.weight=2.2;  //不合法. 因为vehicle中的weight是私有的.
 
 }
 

}
class Car:Vehicle  //car的类继承自vehicle类.
{
 int passenger;  
 public void K(){   
 wheel=6;  //合法.
 weight=4.2  //不合法. //因为vehicle里面的是私有.
 
 
 }

}

using System;
class Excep
{
 static void F(){
 try{
 G();
 }
 catch(Exception e){
 Console.WriteLine("Exception in F():{0}", e.Message); //显示e的内容是G
 e=new Exception("F");
 throw e;   // 抛出重新赋值的e.
 }
}
 static void G(){
 throw new Exception("G");
 
 
 
 }
 static void Main(){
 try{
 F();
 }
 catch(Exception e){
 Console.WriteLine("Exception in Main:{0}",e.Message);  //显示e的内容是F
 
 }
 
 
 }
 

 

 

}

首先，我要指出的是，在 C# 中，int 其实就是 System.Int32，即都是32位的。

其次，(int) 和 Convert.ToInt32 是两个不同的概念，前者是类型转换，而后者则是内容转换，它们并不总是等效的。我们很清楚 C# 提供类型检查，你不能把一个 string 强制转换成 int，隐式转换就更加不可能，例如如下的代码就行不通了：

string text = "1412";
int id = (int)text;

因为 string 和 int 是两个完全不同并且互不兼容的类型。说到这里，你可能会问什么才算是兼容的呢？其实，能够使用 (int) 进行强类型转换的只能是数值类型了，例如 long、short、double等，不过进行这种转换时你需要考虑精度问题。

然而，我们很清楚上面的代码中 text 实际上储存的是一个数值，我们希望把这个数值提取出来并以 int 的形式储存起来以便日后的运算使用，那么你就需要进行内容转换了。内容转换也叫内容解释，我们把上面的代码稍稍修改就可以达到目的了：

string text = "1412";
int id = Convert.ToInt32(text);

除此之外，你还可以使用 Int32.Parse 和 Int32.TryParse 来进行解释。

另外，你发现 Convert.ToInt32 有很多重载版本，例如 Convert.ToInt32(double value);，当我们用这个版本来把一个 double 转换成 int 时，ToInt32 会检查被转换的数值是否能够用 int 表示，即是否会发生“越界”，如果是就会抛出 OverflowException，否则就会为你转换，但使用 (int) 进行强制转换，如果被转换的数值大于 Int32.MaxValue，那么你将得到一个错误的结果，例如下面的代码：

double d = Int32.MaxValue + 0.1412;
int i = (int)d;

不过无论你进行什么数值转换，精度问题都是必须考虑的。

如果转换成16位的整数可以用: Convert.ToInt16();

 

例子:

using System;
class ChangeTime
{
  public static void Main(){
      Console.WriteLine("pls set your time:");
      string hour=Console.ReadLine(); //readline的函数是string类.
      int bb=Convert.ToInt16(hour); // 将string类转成int类.
      if (bb>24 || bb<0){
      Console.WriteLine("input wrong");
      return;  //推出程序.
}
      if (bb%12!=bb){
      bb-=12;
             
      }
     
      Console.WriteLine("the change time:{0}",bb);
 
}
}

using System;
public class Inboxing
{
  static void Main(){
   int x=10;
   object ōbj=x;   //装箱, 将int的值赋给对象obj.
   if (obj is int){
   Console.WriteLine("the x value is inboxing");
  
   }
   x=20;  //x已经被声明过了, 所以这里不用再写成int x=20;
   Console.WriteLine("int: {0}",x);
   Console.WriteLine("object: {0}",obj);
   }
}

 

开箱:

using System;
public class Outboxing
{
  static void Main(){
   int x=10;
   object ōbj=x;
   int j=(int)obj; //开箱, 先将obj转换成int, 再将其赋给j. 这里不能写成 int j=obj, 这样会有错误的抛出: error CS0266: Cannot implicitly convert type 'objec 'int'. 

   if (obj is int){
   Console.WriteLine("the x value is inboxing");
  
   }
  
   x=20;
   Console.WriteLine("int: {0}",x);
   Console.WriteLine("object: {0}",obj);
   Console.WriteLine("j:{0}",j);
   }
}

 

using System;
public class MyClass   //类的表示, 类和函数区别是有class关键字,且无().
{
  public int InstantMethod(){  //函数需要定义函数类型, 如此函数是int的类型.
  Console.WriteLine("call the instant method");
  return 0;  //表示退出此函数时,返回值为0.
  
  }
  public int StaticMethod(){
  Console.WriteLine("call the static method.");
  return 0;
 
  }

}

 delegate int MyDelegate();  //定义一个代理.类型为int
 
 public class Test
 {
    static void Main(){
    MyClass c=new MyClass();  //创建一个新MyClass的类.
    MyDelegate d=new MyDelegate(c.InstantMethod); //创建一个新的MyDelegate代理, 并指定代理的方法为MyClass里面的InstantMethod, 这里的c.InstantMethod不能写成c.InstantMethod().
    d(); //执行此代理.
    d=new MyDelegate(c.StaticMethod);
    d();
   
    }
 
 }

using System;
class Array
{
 static void Main(){
 int[] arr=new int[5]; //这里的5是定义初始化的数组个数. 表示arr被分给5个整数的数组.
 for (int i=0;i<arr.Length;i++)
 {
 arr[i]=i*i; //arr的下标表示那个数组, arr[0]表示第一个,arr[1]表示第二个.第五个就是arr[4].
 
 }
 for (int i=0;i<arr.Length;i++)
 {
 Console.WriteLine("arr[{0}]={1}",i,arr[i]);
 }
 
 }