09.多态

Posted 2020-08-17

多态的概率:

多态是面向对象当中最重要的概念.

多态的概念:

让一个对象能够表现出多种状态(类型)

实现多态:

通常实现多态有三种手段:

(1).虚方法

(2).抽象类

(3).接口

多态就是对象可以表现多个类型的能力

虚方法:

将父类的方法标记为虚方法使用关键字 virtual 来修饰

在父类中使用virtual修饰的方法,在子类中重写时,要加override来修饰.

override与重载（overload）的区别

重载是方法的名称相同。参数或参数类型不同，进行多次重载以适应不同的需要。重载（overload）是面向过程的概念。

Override 是进行基类中函数的重写。Override是面向对象的概念

重写 和重载 不一样 要区分开

使用虚函数的多态实例1:

namespace _23.虚方法的练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            //用虚方法来实现  真的鸭子嘎嘎叫  木头鸭子吱吱叫   橡皮鸭子唧唧叫
            RealDuck rd1 = new RealDuck();
            MuDuck md1 = new MuDuck();
            XPDuck xd1 = new XPDuck();
            RealDuck[] rd = new RealDuck[3] { rd1,md1,xd1} ;
            for (int i = 0; i < rd.Length; i++)
            {
                rd[i].Bark();
            }
            Console.ReadKey();
        }
    }
    public class RealDuck
    {
        public virtual void Bark()
        {
            Console.WriteLine("真的鸭子嘎嘎叫");
        }
    }
    public class MuDuck:RealDuck
    {
        public override void Bark()
        {
            Console.WriteLine("木头鸭子吱吱叫");
        }
    }
    public class XPDuck:RealDuck
    {
        public override void Bark()
        {
            Console.WriteLine("橡皮鸭子唧唧叫");
        }
    }
}

使用虚函数的多态实例2:

namespace _24.虚方法的练习02
{
    class Program
    {
        static void Main(string[] args)
        {
            //经理十一点打卡   员工九点打卡   程序员不打卡
            Employee emp = new Employee();
            Manager mg = new Manager();
            Programmer pm = new Programmer();
            Employee[] emps = {emp,mg,pm};
            for (int i = 0; i < emps.Length; i++)
            {
                emps[i].DaKa();
            }
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 员工类
    /// </summary>
    public class Employee
    {
        public virtual void DaKa()
        {
            Console.WriteLine("员工,九点打卡");
        }
    }
    public class Manager : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("经理十一点打卡");
        }
    }
    public class Programmer : Employee
    {
        public override void DaKa()
        {
            Console.WriteLine("程序员不打卡");
        }
    }
}

 

抽象类:

?抽象类与抽象方法由abstract修饰

?abstract的使用注意

–抽象方法没有方法体

–抽象成员只能存在于抽象类中

–抽象类可以有非抽象成员

–抽象类的派生类必须实现抽象方法体

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

–抽象类的子类必须实现抽象类中所有抽象方法

使用抽象类来实现多态的示例代码1:

namespace _25.抽象类的练习01
{
    class Program
    {
        static void Main(string[] args)
        {
            //狗狗会叫   猫咪也会叫
            Dog dg = new Dog();
            Cat ct = new Cat();
            Animal[] am = { dg,ct};
            for (int i = 0; i < am.Length; i++)
            {
                am[i].Shout();
            }
            Console.ReadKey();
        }
    }
    public abstract class Animal
    {
        public abstract void Shout();
    }
    public class Dog : Animal
    {
        public override void Shout()
        {
            Console.WriteLine("小狗汪汪叫");
        }
    }
    public class Cat : Animal
    {
        public override void Shout()
        {
            Console.WriteLine("小猫喵喵叫");
        }
    }
}

使用抽象类来实现多态的示例代码:

namespace _26.使用多态来解决实际问题01
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用多态求矩形的面积和周长以及圆形的面积和周长
            //思考过程:
            //矩形不能作为圆形的父类   因为计算方法不一样 
            //圆形也不能作为矩形的父类   因为计算方法不一样
            //所以 虚方法不能解决问题
            //我们 采用抽象类来实现
            Shape s1 = new Rectangle(5, 3);
            Console.WriteLine("矩形的面积为:{0},矩形的周长为:{1}.",s1.area(),s1.Perimeter());
            Shape s2 = new Circle(3);
            Console.WriteLine("圆的面积为:{0:#.##},圆形的周长为:{1:#.##}.", s2.Perimeter(), s2.Perimeter());
            Console.ReadKey();
            
        }
    }
    public abstract class Shape
    {
        public abstract double area();   //没有实现的求面积的方法
        public abstract double Perimeter();  //没有实现的求周长的方法
    }
    public class Rectangle : Shape
    {
        private double _chang;
        private double _kuan;
        public double Chang
        {
            get
            {
                return _chang;
            }
            set
            {
                _chang = value;
            }
        }
        public double Kuan
        {
            get
            {
                return _kuan;
            }
            set
            {
                _kuan = value;
            }
        }
        public Rectangle(double chang, double kuan)
        {
            this.Chang = chang;
            this.Kuan=kuan;
        }
        public override double area()
        {
            return Chang * Kuan;
        }
        public override double Perimeter()
        {
            return (Chang + Kuan) * 2;
        }
    }
    public class Circle : Shape
    {
        private double r;
        public double R
        {
            get
            {
                return r;
            }
            set
            {
                r = value;
            }
        }
        public Circle(double r)
        {
            this.R = r;
        }
        public override double area()
        {
            return Math.PI * Math.Pow(R, 2);
        }
        public override double Perimeter()
        {
            return 2*Math.PI*R;
        }
    }
}

 

 

虚方法和抽象类的比较:

 

虚函数,抽象类,以及接口都可以用来实现多态,那么他们之间有什么区别,或者用途上的

不同呢?

(1).虚方法,就是在已知条件中,可以找到一个父类的时候,我们可以使用虚方法,来完成多态.   比如 例题:经理,员工,程序员,三个类,他们都需要打卡上班,这个时候,我们可以以员工

类为父类,因为本质上,经理,员工,程序员 他们都是属于员工的,故可以使用员工类,作为所有类型的父类. 

 

来自为知笔记(Wiz)