虚方法、抽象类

   public class ApprovalSettingController : BaseController
    {
        //定义一个对象
        private readonly IApprovalSettingRepository _approvalSettingRepository;

        /// <summary>
        /// 使用子类的构造函数继承父类的构造函数，把参数传递给父类的构造函数数，为对象，
        /// _approvalSettingRepository赋值，构造函数主要是为了给对象赋值
        /// </summary>
        /// <param name="loginName"></param>
        public ApprovalSettingController(string loginName)
            : base(loginName)
        {
            if (!string.IsNullOrEmpty(loginName))
            {
                _approvalSettingRepository = (IApprovalSettingRepository)_serviceFactory.GetRepository<ApprovalSetting>(_dbContext);
            }
        }
    }

 

虚方法：

1、virtual方法表示此方法可以被重写, 也就是说这个方法具有多态.父类中的方法是通用方法,可以在子类中重写以重新规定方法逻辑. 
2、virtual方法可以直接使用,和普通方法一样 
3、不是必须重写的. 子类可以使用base.方法 的方式调用, 无论有没有在子类使用override去重写

virtual关键字只是明确标示此方法可以被重写, 其实它和一般的方法没有什么区别 
相应的 
sealed关键字标示此方法不可以被重写

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

1.虚方法可以有实现体，抽象方法不能有实现体。

2.抽象方法
    要求派生类必须重载这个方法；

虚方法
    告诉编译器，这个方法可以重写。
    当基类的方法与派生类的方法重名时，
    可以选择派生类的方法从基类继承并重写，
    还是，把基类的方法隐藏起来。

本段来自CSDN博客:http://blog.csdn.net/lzp_lrp/article/details/8972509

 

当类中的方法声明前加上了virtual修饰符，我们称之为C#虚拟方法 ，反之为非虚。使用了virtual修饰符后，不允许再有static、abstract或override修饰符。对于非虚的方法，无论被其所在类的实例调用，还是被这个类的派生类的实例调用，方法的执行方式不变。而对于虚方法，它的执行方式可以被派生类改变，这种改变是通过方法的重载来实现的。

下面的例子说明了C#虚拟方法与非虚方法的区别。

例子：

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和C#虚拟方法 G.类B则提供了一个新的非虚的方法F,从而覆盖了继承的F;类B同时还重载了继承的方法G.那么输出应该是:

A.F

B.F

B.G

B.G

注意到本例中,方法a.G()实际调用了B.G,而不是A.G.这是因为编译时值为A,但运行时值为B,所以B完成了对方法的实际调用。

 

 

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

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修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

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

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

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

 

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);
    }
}

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

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