c#中abstract、override、new、virtual、sealed使用和示例

原文地址：http://blog.csdn.net/richerg85/article/details/7407544

abstract

     修饰类名为抽象类，修饰方法为抽象方法。如果一个类为抽象类，则这个类智能是其他某个类的基类。抽象方法在抽象类中没有函数体。抽象类中的抽象方法是没有方法体的，继承其的子类必须实现抽象类的抽象方法。

抽象类有如下特征：

• 抽象类不能实例化
• 抽象类的派生类必须实现所有抽象方法
• 抽象类中的抽象方法是没有方法体的，继承其的子类必须实现抽象类的抽象方法

 

抽象方法：

• 抽象方法是隐式的虚方法
• 只允许在抽象类中使用抽象方法声明
• 抽象方法在抽象类中没有方法体
• 在抽象方法声明中，不能使用static或者virtual修饰符

1. abstract class A //abstract 关键字在class前面
2. {
3. public abstract void run();//方法是将关键字abstract 添加到方法的返回类型的前面
4. }

abstract class A //abstract 关键字在class前面
{
    public abstract void run();//方法是将关键字abstract 添加到方法的返回类型的前面
}

 

override

    override关键字提供派生类对基类方法的新的实现，重写的基类方法必须和基类的方法有着相同的签名（函数名、返回值、参数列表相同）。

    override关键字不可以重写基类非virtual修饰的方法和static修饰的静态方法。

    派生类的override方法和基类的virtual方法必须有相同的访问权限。不能用修饰符new、static、virtual或者abstract修饰override方法。

    派生类的override方法重写的基类方法必须是virtual、abstract或者override的。

 

1. abstract class A
2. {
3. public virtual void MethodA()
4. {
5. //do something
6. }
7. public abstract void run();
8. }
9. public class B:A
10. {
11. public override void MethodA()
12. {
13. //do somthing
14. }
15. public virtual void run()
16. {
17. //do something
18. }
19. }

abstract class A
{
public virtual void MethodA()
{
     //do something
}
public abstract void run();
}
     public class B:A
{
public override void MethodA()
{
    //do somthing
}
public virtual void run()
{
    //do something
}
}

new

    c#中，new的关键字主要有三个功能：

1. 作为运算符用来创建类的一个对象。 Class obj = new Class();
2. 作为修饰符。
3. 用于在泛型声明中约束可能用作类型参数的参数类型。（这个不太清楚）

      在这里主要介绍第2个功能，作为修饰符的作用。

      new声明的方法，当使用子类的类型来调用的时候，它会运行子类的函数，而如果类型是基类的话，被隐藏的基类函数会被调用。

       而子类中函数使用override的时候，则当使用子类的类型来调用的是，它会运行子类的函数，类型是基类的时候，仍会调用子类函数。

 

 

       如下例：

1. // Define the base class
2. class Car
3. {
4. public virtual void DescribeCar()
5. {
6. System.Console.WriteLine("Four wheels and an engine.");
7. }
8. }
9. // Define the derived classes
10. class ConvertibleCar : Car
11. {
12. public new void DescribeCar()
13. {
14. System.Console.WriteLine("A roof that opens up.");
15. }
16. }
17. class Minivan : Car
18. {
19. public override void DescribeCar()
20. {
21. System.Console.WriteLine("Carries seven people.");
22. }
23. }
24. public class Program
25. {
26. public static void Main()
27. {
28. Car car1 = new Car();
29. car1.DescribeCar();
30. System.Console.WriteLine("----------");
31. Car car2 = new ConvertibleCar();
32. car2.DescribeCar();
33. System.Console.WriteLine("----------");
34. Car car3 = new Minivan();
35. car3.DescribeCar();
36. System.Console.WriteLine("----------");
37. System.Console.ReadKey();
38. }
39. }

  // Define the base class
    class Car
    {
        public virtual void DescribeCar()
        {
            System.Console.WriteLine("Four wheels and an engine.");
        }
    }
    // Define the derived classes
    class ConvertibleCar : Car
    {
        public new void DescribeCar()
        {
            System.Console.WriteLine("A roof that opens up.");
        }
    }

    class Minivan : Car
    {
        public override void DescribeCar()
        {
            System.Console.WriteLine("Carries seven people.");
        }
    }
    public class Program
    {
        public static void Main()
        {
            Car car1 = new Car();
            car1.DescribeCar();
            System.Console.WriteLine("----------");

            Car car2 = new ConvertibleCar();
            car2.DescribeCar();
            System.Console.WriteLine("----------");

            Car car3 = new Minivan();
            car3.DescribeCar();
            System.Console.WriteLine("----------");
            System.Console.ReadKey();
        }
    }

virtual

      virtual 关键字允许在派生类中重写这些对象。默认情况下，方法是非虚拟的，不可以重写非虚方法，virtual关键字不可以与static、abstract、private、override一起使用。virtual关键字又是和override紧密不可分的，如果要实现virtual方法就必须要使用override或new关键字（上文已经指出new和override产生的机理不同）。

     

 

sealed

     

        当对一个类应用sealed修饰符时，此修饰符会阻止其他类从该类继承。

    sealed 方法必须与override连用，也就是说实现sealed方法的类的父类必须实现了此方法。

    sealed关键字有两个作用：

    1 密封类不能被继承。

    2 密封方法重写基类中的方法，但其本身不能在任何派生类中进一步重写

 

   sealed实例：

1. class X
2. {
3. protected virtual void F() { Console.WriteLine("X.F"); }
4. protected virtual void F2() { Console.WriteLine("X.F2"); }
5. }
6. class Y : X
7. {
8. sealed protected override void F() { Console.WriteLine("Y.F"); }
9. protected override void F2() { Console.WriteLine("X.F3"); }
10. }
11. class Z : Y
12. {
13. // Attempting to override F causes compiler error CS0239.
14. // protected override void F() { Console.WriteLine("C.F"); }//sealed修饰的方法是不允许继承的
15. // Overriding F2 is allowed.
16. protected override void F2() { Console.WriteLine("Z.F2"); }
17. }

class X

    {
        protected virtual void F() { Console.WriteLine("X.F"); }
        protected virtual void F2() { Console.WriteLine("X.F2"); }
    }
    class Y : X
    {
        sealed protected override void F() { Console.WriteLine("Y.F"); }
        protected override void F2() { Console.WriteLine("X.F3"); }
    }
    class Z : Y
    {
        // Attempting to override F causes compiler error CS0239.
        // protected override void F() { Console.WriteLine("C.F"); }//sealed修饰的方法是不允许继承的

        // Overriding F2 is allowed.
        protected override void F2() { Console.WriteLine("Z.F2"); }
    }

整体的一个简单实例如下：

1. namespace testVirtualF
2. {
3. interface BaseInterface
4. {
5. void doWork();
6. }
7. public abstract class Base:BaseInterface
8. {
9. public virtual void work()
10. {
11. Console.WriteLine("基类---现在是上班时间");
12. }
13. public virtual void outWork()
14. {
15. Console.WriteLine("基类---现在是下班时间");
16. }
17. public abstract void play();//声明抽象方法,只能在抽象方法中
18. public abstract void doWork();//实现接口的抽象类，可以将接口方法映射到抽象方法中
19. }
20. public class Employer:Base
21. {
22. public  new void work()
23. {
24. Console.WriteLine("子类(new)---现在是上班时间");
25. }
26. public override void outWork()
27. {
28. Console.WriteLine("子类(override)---现在是下班时间");
29. }
30. public override void play()
31. {
32. Console.WriteLine("子类(override)---父类抽象方法");
33. }
34. public override void doWork()
35. {
36. Console.WriteLine("父类抽象方法--doWork");
37. }
38. }
39. class Program
40. {
41. static void Main(string[] args)
42. {
43. /*Employer emp = new Employer();
44. emp.work();
45. emp.outWork();
46. emp.play();*/
47. /*输出结果
48. * 子类(new)---现在是上班时间
49. * 子类(override)---现在是下班时间
50. */
51. /*Employer emp = new Employer();
52. Base b = (Base)emp;
53. //b.ID = "123";
54. b.work();
55. b.outWork();
56. b.play();*/
57. /*执行结果
58. * 基类---现在是上班时间
59. * 子类(new)---现在是上班时间
60. * 子类(override)---现在是下班时间
61. */
62. Base b = new Employer();
63. b.work();
64. b.outWork();
65. b.play();
66. /*执行结果
67. * 基类---现在是上班时间
68. * 子类(new)---现在是上班时间
69. * 子类(override)---现在是下班时间
70. */
71. }
72. }
73. }