C#多态性的小记，父类，子类，虚方法，接口

一.父类，子类的继承和虚方法重写

 

 class Program
    {
        static void Main(string[] args)
        {
            Person objperson= new Person ();//实例person类
            objperson.My();
            objperson.num();
 
            Student objstudent= new Student();//实例person类
            objstudent.My();
            objstudent.num();

        }


  public  class Person   //父类
    {
     
        public string My()  
        {
            return "我是人类";
        }
        public virtual string num()
        {
            return "我人类没有";
        }
    } 

 public class Student:Person    //子类
    {

       public override string num()
       {
           return "我学生没有";
       }


}
　

结果显示：

 

二.什么时候用抽象方法？虚方法和抽象的区别

方法里边没有抽象体，不需要对其他事物进行描述，但是其他类都有这个行为，这个时候采用抽象方法。

里面没有具体的方法体,  继承者，负责重写里面的方法

抽象方法无法实例化，抽象类只能用作基类

1、Virtual方法（虚方法）

　　virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况：

　　情况1：在父类中定义了virtual方法，但在子类中没有重写该虚方法。那么在对子类实例的调用中，该虚方法使用的是父类定义的方法。

　　情况2：在父类中定义了virtual方法，然后在子类中使用override重写该方法。那么在对子类实例的调用中，该虚方法使用的是子类重写的方法。

2、Abstract方法（抽象方法）

abstract关键字只能用在抽象类中修饰方法，并且没有具体的实现。抽象方法的实现必须在子类中使用override关键字来实现。

接口和抽象类最本质的区别：抽象类是一个不完全的类，是对对象的抽象，而接口是一种行为规范。

a)     virtual修饰的方法必须有方法实现(哪怕只有一对大括号),abstract修饰的方法不能有实现。

b)    virtual可以被子类重写,abstract必须被子类重写

c)     如果类中的某一函数被abstact修饰,则类名也必须用abstact修饰

d)    Abstract修饰的类不能被创建实例。

e)     C#中如果准备在子类重写父类的方法，则该方法在父类中必须用virtual修饰，在子类中必须用overide修饰，避免了程序员在子类中不小心重写了父类父类方法。

注：用abstract修饰的类只能被继承不能够被实例化。

 

三.接口

class Program
    {
        static void Main(string[] args)
        {
            Fly objfly=new Person();   //接口实例化
            objfly.fly();
            objfly.run();
 
            objfly= new Student(); //接口实例化
            objfly.fly();
            objfly.run();

        }


  public  class Person:Fly  //父类
    {
     
        public string My()  
        {
            return "我是人类";
        }
        public virtual string num()
        {
            return "我人类没有";
        }
       string Fly.fly()  //接口实现方法
        {
            return "我是人类，我会飞";
        }

        string Fly.run()   //接口实现方法
        {
            return "我是人类，我在工作";
        }
    } 

 public class Student:Person,Fly    //子类
    {

       public override string num()
       {
           return "我学生没有";
       }
        string Fly.fly()
        {
            return "我是学生，我会飞";
        }

        string Fly.run()
        {
            return "我是学生，我在工作";
        }
   }

  public  interface Fly
    {
        string fly();
        string run();
    }

}

结果：

 

其中接口，和继承接口的类实例化，可以做到多态，以及替换，比如定义接口对象，可以初始化为任意继承它的实体对象，而能使用的方法和属性只有接口声明的那些。

 

接口属性定义使用

 

class Program
    {
        static void Main(string[] args)
        {
            Fly objfly=new Person();   //接口实例化
            objfly.Age = 18;
            objfly.AgeNow();
            Console.WriteLine(objfly.Age.ToString());
 
            objfly= new Student(); //接口实例化
             objfly.Age = 10;
            objfly.AgeNow();
            Console.WriteLine(objfly.Age.ToString());

        }


  public  class Person:Fly  //父类
    {
     
        public string My()  
        {
            return "我是人类";
        }
        public virtual string num()
        {
            return "我人类没有";
        }
       string Fly.fly()  //接口实现方法
        {
            return "我是人类，我会飞";
        }

        string Fly.run()   //接口实现方法
        {
            return "我是人类，我在工作";
        }
        int Fly.Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }

        void Fly.AgeNow()
        {
            Console.WriteLine("我是人类年龄:" + age);
            age = age + 1;
        }
    } 

 public class Student:Person,Fly    //子类
    {

       public override string num()
       {
           return "我学生没有";
       }
        string Fly.fly()
        {
            return "我是学生，我会飞";
        }

        string Fly.run()
        {
            return "我是学生，我在工作";
        }
          int Fly.Age
        {
            get
            {
                return age;
            }
            set
            {
                age = value;
            }
        }

        void Fly.AgeNow()
        {
            Console.WriteLine("我是学生年龄:" + age);
            age = age + 1;
        }
   }

  public  interface Fly
    {

     int Age
      {
          get;
          set;
      }
        void AgeNow();
        string fly();
        string run();
    }

}

 

最后结果：