接口、抽象类、抽象方法、虚方法 的区别

                               接口、抽象类、抽象方法、虚方法 的区别

接口、抽象类、抽象方法、虚方法:

 

这四个名词时非常容易混淆的：

 

首先说一下接口 与抽象类 的异同：

相同点：

1.他们都不能实例化自己，也就是说都是用来被继承的。

2.抽象类中的抽象方法和接口方法一样，都不能有方法体

不同点：

1.抽象类里可以有字段，接口中不能有字段.

2.抽象类中的普通方法可以有方法体，而接口方法没有方法体。

3.接口中的方法不能有访问修饰符，抽象类中的抽象方法被继承，需要override重写 .

4.接口更像是一种规范，一种约束。

5.一个子类只能继承一个抽象类，但却可以继承多个接口。

 

接下来是抽象方法 和虚方法 的异同：

其实可以把抽象方法看做是没有方法体的虚方法。

 

相同点：

 

1.抽象方法和虚方法都可以被重写。

 

不同点：

 

1.abstract 和virtual的关键字不同

 

2.抽象方法一定没有方法体，而虚方法可以有方法体。

 

下面写个例子说明一下：

view plaincopy to clipboardprint?
/// <summary>  
/// 一个手机的抽象类  
/// </summary>  
public abstract class Mobilephone   
{  
    private string _logo;  
    public string Logo  
    {  
        get { return _logo; }  
        set { _logo = value; }  
    }  
    public abstract void Call();  
    public virtual void Callagain()   
    {  
        Console.WriteLine("我再打一个电话");  
    }  
}  
 
/// <summary>  
/// 定义一个实体类，继承了一个抽象类及多个接口  
/// </summary>  
public class Nokia :Mobilephone,IClock,Ilistenmusic  
{  
    public override void Call()  
    {  
        Console.WriteLine("NOKIA打电话没问题");  
    }  
    public void clock()  
    {  
        Console.WriteLine("NOKIA的手机也有闹钟功能");  
    }  
    public void listenmusic()  
    {  
        Console.WriteLine("NOKIA的手机还能听歌");  
    }  
    public override void Callagain()   
    {  
        Console.WriteLine("算了，还是不打了");  
    }  
}  
/// <summary>  
/// 下面定义了两个接口，为了说明可以继承多个接口  
/// </summary>  
public interface Ilistenmusic   
{  
    void listenmusic();  
}  
public interface IClock   
{  
    void clock();  
} 

 

 

再补充一个小例子，

这里有到很有意思的面试题，说名了new关键字和override的区别:

 

view plaincopy to clipboardprint?
class Program  
    {  
        static void Main(string[] args)  
        {  
            B5 b5 = new B5();  
            b5.MethodB();  
        }  
    }  
    public class A5  
    {  
        public virtual void MethodA()  
        {  
            Console.WriteLine("A5.MethodA");  
            Console.Read();  
        }  
        public virtual void MethodB()  
        {  
            MethodA();  
        }  
    }  
    public class B5 :A5  
    {  
        public new void MethodA()   
        {  
            Console.WriteLine("B5.MethodA");  
            Console.ReadLine();  
        }  
    } 

 

最后的答案是:"A5.MethodA"

 

示例说明：

 

new是覆盖override是重载。  
   
  “覆盖”并不意味着“删除”  
   
  示例  
  using   System;  
  class   A  
  {  
        public   void   F()    
        {  
              Console.WriteLine("A.F");    
        }  
  }  
  class   B:   A  
  {  
        new   public   void   F()    
        {    
              Console.WriteLine("B.F");    
        }  
  }  
  class   Test  
  {  
        static   void   Main()    
        {  
              B   b   =   new   B();  
              b.F();  
              A   a   =   b;    
              a.F();  
        }  
  }  
  输出为  
  B.F  
  A.F  
   
  但“重载”意味着“删除”，这就是“覆盖”和“重载”的区别。  
   
  示例  
  using   System;  
  class   A  
  {  
        public   virtual   void   F()    
        {  
              Console.WriteLine("A.F");    
        }  
  }  
  class   B:   A  
  {  
        public   override   void   F()    
        {    
              Console.WriteLine("B.F");    
        }  
  }  
  class   Test  
  {  
        static   void   Main()    
        {  
              B   b   =   new   B();  
              b.F();  
              A   a   =   b;    
              a.F();  
        }  
  }  
  输出为  
  B.F  
  B.F