虚方法 virtual 和抽象方法 abstract 的区别

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！

               

 第一种解释：

虚方法和抽象方法都可以供派生类重写，它们之间有什么区别呢？

1. 虚方法必须有实现部分，抽象方法没有提供实现部分，抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。如：

view plain copy to clipboard print ?

1. //抽象方法   
2. public abstract class Animal   
3. {   
4.     public abstract void Sleep();   
5.     public abstract void Eat();   
6. }   
7.   
8. //虚方法   
9. public class Animal   
10. {   
11.     public virtual void Sleep(){}   
12.     public virtual void Eat(){}   
13. }  

[c-sharp] view plain copy print ?

1. //抽象方法  
2. public abstract class Animal  
3. {  
4.     public abstract void Sleep();  
5.     public abstract void Eat();  
6. }  
7.   
8. //虚方法  
9. public class Animal  
10. {  
11.     public virtual void Sleep(){}  
12.     public virtual void Eat(){}  
13. }  

//抽象方法public abstract class Animal{    public abstract void Sleep();    public abstract void Eat();}//虚方法public class Animal{    public virtual void Sleep(){}    public virtual void Eat(){}}

2. 抽象方法只能在抽象类中声明，虚方法不是。其实如果类包含抽象方法，那么该类也是抽象的，也必须声明为抽象的。如：

扫描二维码关注公众号，回复： 4957387 查看本文章

view plain copy to clipboard print ?

1. public class Animal   
2. {   
3.     public abstract void Sleep();   
4.     public abstract void Eat();   
5. }  

[c-sharp] view plain copy print ?

1. public class Animal  
2. {  
3.     public abstract void Sleep();  
4.     public abstract void Eat();  
5. }  

public class Animal{    public abstract void Sleep();    public abstract void Eat();}

编译器会报错：
Main.cs(10): 'VSTest.Animal.Sleep()' is abstract but it is contained in nonabstract class 'VSTest.Animal'
Main.cs(11): 'VSTest.Animal.Eat()' is abstract but it is contained in nonabstract class 'VSTest.Animal'

3. 抽象方法必须在派生类中重写，这一点跟接口类似，虚方法不必。如：

view plain copy to clipboard print ?

1. public abstract class Animal   
2. {   
3.     public abstract void Sleep();   
4.     public abstract void Eat();   
5. }   
6.   
7. public class Cat : Animal   
8. {   
9.     public override void Sleep()   
10.     {   
11.         Console.WriteLine( "Cat is sleeping" );   
12.     }   
13.     // we need implement Animal.Eat() here   
14.   
15. }  

[c-sharp] view plain copy print ?

1. public abstract class Animal  
2. {  
3.     public abstract void Sleep();  
4.     public abstract void Eat();  
5. }  
6.   
7. public class Cat : Animal  
8. {  
9.     public override void Sleep()  
10.     {  
11.         Console.WriteLine( "Cat is sleeping" );  
12.     }  
13.     // we need implement Animal.Eat() here  
14.   
15. }  

public abstract class Animal{    public abstract void Sleep();    public abstract void Eat();}public class Cat : Animal{    public override void Sleep()    {        Console.WriteLine( "Cat is sleeping" );    }    // we need implement Animal.Eat() here}

编译器会报错：Main.cs(14): 'VSTest.Cat' does not implement inherited abstract member 'VSTest.Animal.Eat()'，因为我们没有实现抽象类中所有抽象方法。

此种解释转自：http://www.cnblogs.com/michaelxu/archive/2008/04/01/1132633.html

第二种解释：

抽象类定义：
它的作用就是产生子类的同时给于子类一些特定的属性和方法。
abstract修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

特性：
1.抽象类不能被实例化；
2.抽象类可以包含抽象方法和抽象访问器；
3.不能用sealed修饰符修改抽象类，这意味着抽象类不能被继承；
4.从抽象类派生的飞抽象类必须包括继承的所有抽象方法和抽象访问器的实现。

总结：
~抽象方法是隐式的虚方法；
~只容许在抽象类中使用抽象方法声明；
~因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号“{}”，实现由一个重方法提供，此重方法是非抽象类的成员；
~在抽象方法声明中使用static或virtual修饰符是错误的；
~除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样；
~在静态属性上使用absteact修饰符是错误的；

~在派生类中，通过包括使用override修饰符的属性声明，可以重写抽象的继承属性。

view plain copy to clipboard print ?

1. using System;   
2. abstract class A   
3. {   
4.     public abstract void F();   
5.     protected int _x;   
6.     public abstract int X   
7.     {   
8.         get;   
9.         set;   
10.     }   
11. }   
12. class B:A   
13. {   
14.     public override void F()   
15.     {   
16.            
17.     }   
18.     public override int X   
19.     {   
20.         get{return _x;}   
21.         set{_x=value;}   
22.     }   
23. }   
24. class Test   
25. {   
26.     static void Main()   
27.     {   
28.         B b=new B();   
29.         b.X=10;   
30.         Console.Write(b.X);   
31.     }   
32. }  

[c-sharp] view plain copy print ?

1. using System;  
2. abstract class A  
3. {  
4.     public abstract void F();  
5.     protected int _x;  
6.     public abstract int X  
7.     {  
8.         get;  
9.         set;  
10.     }  
11. }  
12. class B:A  
13. {  
14.     public override void F()  
15.     {  
16.           
17.     }  
18.     public override int X  
19.     {  
20.         get{return _x;}  
21.         set{_x=value;}  
22.     }  
23. }  
24. class Test  
25. {  
26.     static void Main()  
27.     {  
28.         B b=new B();  
29.         b.X=10;  
30.         Console.Write(b.X);  
31.     }  
32. }  

using System;abstract class A{    public abstract void F();    protected int _x;    public abstract int X    {        get;        set;    }}class B:A{    public override void F()    {            }    public override int X    {        get{return _x;}        set{_x=value;}    }}class Test{    static void Main()    {        B b=new B();        b.X=10;        Console.Write(b.X);    }}

虚方法定义：
简单的说，虚方法就是可以被子类重写的方法，如果子类重写了虚方法，那么运行时将使用重写后的逻辑，如果没有重写，则使用父类中虚方法的逻辑；
virtual关键字用于修饰方法、属性、索引器或事件声明，并且允许在派生类中重写这些对象。

view plain copy to clipboard print ?

1. using   System   ;     
2.       
3.   class   A     
4.       
5.   {     
6.       
7.   public   void   F(   )     
8.   {      
9.       Console.WriteLine("A.F")   ;     
10.   }   
11.       
12.   public   virtual   void   G(   )     
13.   {     
14.       Console.WriteLine("A.G")   ;      
15.   }   
16.       
17.   }     
18.       
19.   class   B:   A     
20.       
21.   {     
22.       
23.   new   public   void   F(   )     
24.   {      
25.       Console.WriteLine("B.F")   ;     
26.   }   
27.       
28.   public   override   void   G(   )     
29.   {      
30.       Console.WriteLine("B.G")   ;    
31.   }   
32.       
33.   }     
34.       
35.   class   Test     
36.       
37.   {     
38.       
39.   static   void   Main(   )       
40.       
41.   {     
42.   B   b   =   new   B(   )   ;     
43.       
44.   A   a   =   b;     
45.       
46.   a.F(   )   ;     
47.       
48.   b.F(   )   ;     
49.       
50.   a.G(   )   ;     
51.       
52.   b.G(   )   ;     
53.       
54.   }     
55.       
56.   }   输出是：A.F   B.F  B.G  B.G  

[c-sharp] view plain copy print ?

1. using   System   ;    
2.      
3.   class   A    
4.      
5.   {    
6.      
7.   public   void   F(   )    
8.   {     
9.       Console.WriteLine("A.F")   ;    
10.   }  
11.      
12.   public   virtual   void   G(   )    
13.   {    
14.       Console.WriteLine("A.G")   ;     
15.   }  
16.      
17.   }    
18.      
19.   class   B:   A    
20.      
21.   {    
22.      
23.   new   public   void   F(   )    
24.   {     
25.       Console.WriteLine("B.F")   ;    
26.   }  
27.      
28.   public   override   void   G(   )    
29.   {     
30.       Console.WriteLine("B.G")   ;   
31.   }  
32.      
33.   }    
34.      
35.   class   Test    
36.      
37.   {    
38.      
39.   static   void   Main(   )      
40.      
41.   {    
42.   B   b   =   new   B(   )   ;    
43.      
44.   A   a   =   b;    
45.      
46.   a.F(   )   ;    
47.      
48.   b.F(   )   ;    
49.      
50.   a.G(   )   ;    
51.      
52.   b.G(   )   ;    
53.      
54.   }    
55.      
56.   }   输出是：A.F   B.F  B.G  B.G  

using   System   ;       class   A       {       public   void   F(   )    {         Console.WriteLine("A.F")   ;    }     public   virtual   void   G(   )    {        Console.WriteLine("A.G")   ;     }     }       class   B:   A       {       new   public   void   F(   )    {         Console.WriteLine("B.F")   ;    }     public   override   void   G(   )    {         Console.WriteLine("B.G")   ;   }     }       class   Test       {       static   void   Main(   )         {    B   b   =   new   B(   )   ;       A   a   =   b;       a.F(   )   ;       b.F(   )   ;       a.G(   )   ;       b.G(   )   ;       }       }   输出是：A.F   B.F  B.G  B.G

其实最重要的就是抽象方法不能实例化，要子类必须强制性的覆盖它的方法 。而虚方法则是提供了选择，可以覆盖可以不覆盖，继承基类中的虚方法。

总结比较如下：

抽象方法和虚方法的区别 ：

 ~抽象方法和虚方法的区别在于：虚拟方法有一个实现部分，并为派生类提供了覆盖该方法的选项，相反，抽象方法没有提供实现部分，强制派生类覆盖方法（否则 派生类不能成为具体类）；
~abstract方法只能在抽象类中声明，虚方法则不是；
~abstract方法必须在派生类中重写，而virtual则不必；
~abstract方法不能声明方法实体，虚方法则可以。

此种解释转自：http://www.cnblogs.com/yinhe/archive/2008/11/13/1332930.html

           

给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow