【C#】——多态

概述

• 多态是对象可以表现多个类型的能力，多态性意味着有多重形式，多态性往往表现为“一个接口，多个功能”
• 静态多态性：函数的响应是在编译时发生的
• 动态多态性：函数的响应是在运行时发生的
• 接口多态性
• 继承多态性
• 通过抽象类实现多态性

实现

一、虚方法

• 定义：父类中的方法声明中加上virtual修饰符，则称为虚方法
• 作用：子类可以对父类中的 虚方法进行重写，虚方法是多态性的一种体现
• 用virtual关键字修饰父类方法，用override关键字修饰子类方法，实现了方法重写
• 如下例所示

public class Person
	    {
	        public Person(string name, char gender, int age)  //构造函数
	        {
	            this._name = name;
	            this._gender = gender;
	            this._age = age;
	        }
	        private string _name;
	        public string Name
	        {
	            get { return _name; }
	            set { _name = value; }
	        }
	        private char _gender;
	        public char Gender
	        {
	            get { return _gender; }
	            set { _gender = value; }
	        }
	        private int _age;
	        public int Age
	        {
	            get { return _age; }
	            set { _age = value; }
	        }
	        public virtual void Show()//虚方法
	        {
	            Console.WriteLine("我是人别害怕");
	        }
	        public void Say()
	        {
	            Console.WriteLine("hello");
	        }
	
	    }
	
	    public class Teacher : Person//继承父类person
	    {
	        public override void Show()  //overrider父类 
	        {
	            Console.WriteLine("我是老师");
	        }
	         
	     
	    }
	    public class Student : Person//继承父类person
	    {
	        public override void Show() overrider父类 
	        {
	            Console.WriteLine("这是我自己方法里的内容");
	        }
	
	    }
	}

二、抽象方法与抽象类

• 抽象类不能实例化（不能使用new操作）
• 抽象类是有构造函数的，虽然不能实例化
• 抽象类不能是密封的或者是静态的（不能在抽象类前面加static和sealed）
• 抽象类是子类的描述，只有被子类继承，才有实际意义
• 抽象方法是隐式的虚方法（没有方法体的虚方法）
• 子类重写父类的方法，参数和返回值必须跟父类是一样的
• 如下例所示

 public abstract class Animal
	    {
	        private string _name;
	        public string Name
	        {
	            get { return _name; }
	            set { _name = value; }
	        }
	        private char _gender;
	        public char Gender
	        {
	            get { return _gender; }
	            set { _gender = value; }
	        }
	        private int _age;
	        public int Age
	        {
	            get { return _age; }
	            set { _age = value; }
	        }
	
	        public abstract void Shout();//抽象方法，没有方法体
	       
	
	        public void SayHello()
	        {
	            Console.WriteLine("哈哈哈");
	        }
	    }
	    public class Pig :Animal
	    {
	        public override void Shout()
	        {
	            Console.WriteLine("哼哼叫");
	        }
	    }

三、接口

• 定义：接口是一组函数成员而不实现成员的引用类型
• 接口可以实现多重继承
• 接口成员不能有new、static、abstract、override、virtual修饰符
• 当一个接口实现另一个接口，这两个接口中有相同的方法是时，可用new关键字隐藏父类接口中的方法
• 接口没有构造函数，所以不能直接使用new对接口进行实例化
• 如下例所示

 public class Person
	    {
	       
	        private string _name;
	        public string Name
	        {
	            get { return _name; }
	            set { _name = value; }
	        }
	        private char _gender;
	        public char Gender
	        {
	            get { return _gender; }
	            set { _gender = value; }
	        }
	        private int _age;
	        public int Age
	        {
	            get { return _age; }
	            set { _age = value; }
	        }
	        public void Show()
	        {
	            Console.WriteLine("{0}岁的{1}是{2}，是最帅的", _age, _name, _gender);
	        }
	
	    }
	
	    public class Teacher : Person,IFly
	    {
	        public void Say()
	        {
	            Console.WriteLine("hellow,我是老师");
	        }
	
	        public void IFly()
	        {
	            Console.WriteLine("我会飞");
	        }
	
	       
	    }
	    public class Student:IFly
	    {
	        public void SayHello()
	        {
	            Console.WriteLine("我是学生");
	        }
	
	        public void IFly()
	        {
	            Console.WriteLine("我会飞");
	        }
	    }
	

区别

一、抽象方法与虚方法的区别

• 虚方法有实现部分，并且为派生类提供了覆盖该方法的选项，抽象方法没有实现部分，强制派生类覆盖方法
• abstract方法只能在抽象类中声明，virtual方法都可以
• abstract方法必须在派生类中重写，virtual方法则不必
• abstract方法不能声明方法体
• 包含abstract方法的类不能被实例化

二、接口和抽象类的区别

相同点
• 都不能直接实例化，都可以通过继承实现其方法
• 包含未实现的方法声明
不同点
• 接口支持多重继承，抽象类不能实现多重继承
• 接口是一组行为规范，抽象类是一个不完全的类