面向对象三大特性之多态

多态是什么？

　　　　用一句话来概括下，多态就是同一操作（方法）作用于不同的对象时，可以有不同的解释，产生不同的执行结果。这句话看似简

　　　　单，实则颇有深意。下面我们来深入理解一多态的意义及如何使用多态。

使用多态编程的好处

　　　　在使用继承编程的时候，我们一般是把不同子类的方法分别写在不同的子类中，使用的时候用is a关键字来判断对象是哪种类型

　　　　的，然后进行强制转换来使用不同对象的方法。

 　　　  但是，如果有多个子类的话，使用的时候难道要写多个if语句来判断对象是哪种类型的吗？这样会产生很多冗余代码，也会很繁

　　　　琐。

　　　　使用多态编程可以很好的解决这个问题。在父类写一个虚方法或抽象方法，子类去重写父类的方法，在调用的时候系统会根据对

　　　　象运行时的类型决定调用哪个方法。这样子是不是简洁多了？

小例子

　　　　假设我们有一个“书”类，然后有很多子类继承“书”类。例如“计算机组成原理”类继承“书类”，“深入Java面向对象”继承“书”类...

　　　　而这些子类都有类似的方法，即被不同的人使用。

　　　　下面我们来用代码实现它。

/// <summary>
    /// 演示类
    /// </summary>
    class Demo
    {
        List<Book> books = new List<Book>();

        /// <summary>
        /// 测试
        /// </summary>
        public void Test()
        {
            books.Add(new ComputerBook());
            books.Add(new JavaBook());

            foreach (Book item in books)
            {
                if (item is ComputerBook)
                {
                    ((ComputerBook)item).ByReading();
                }
                if (item is JavaBook)
                {
                    ((JavaBook)item).ByReading();
                }
            }
        }
    }

    /// <summary>
    /// 书类
    /// </summary>
    class Book
    {
        
    }

    /// <summary>
    /// 计算机书籍
    /// </summary>
    class ComputerBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public void ByReading()
        {
            Console.WriteLine("我是计算机类书籍，被在校大学生使用。");
        }
    }

    /// <summary>
    /// Java书籍
    /// </summary>
    class JavaBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public void ByReading()
        {
            Console.WriteLine("我是Java书籍，被在业Java程序员使用。");
        }
    }

 　　　　

　　　　 通过这段代码可以发现：在使用子类对象的时候需要先用is a来判断子类对象时哪种类型的。那么也就是说，如果一个父类有10

　　　　 个派生类（子类）的话，就要用10个if判断语句来判断子类对象是哪种类型了，未免太过繁琐。

　　　　 这时，虚方法就该登场了。

虚方法

 　　　　概念：

　　　　　　　　虚方法有方法体，可以被重写，使用virtual来修饰。

　　　　　　　　父类中的虚方法并非必须被子类重写，在父类中可以给出虚方法的默认实现。如果子类不重写父类的虚方法则依然执行

　　　　　　　　父类的默认实现。如果子类重写了父类的虚方法，则执行子类重写后的方法。

　　　　　　　　其实方法重载也是实现多态的一种形式，只是重载的方法都在同一个类中，而用虚方法实现多态的方法散布在有继承关

　　　　　　　　系的多个类中。

　　　　使用：

　　　　　　　　在父类中使用virtual关键字定义虚方法，在子类中使用override关键字来重写父类中的虚方法。

　　　　override关键字：

　　　　　　　　通过override关键字来修饰的方法，称为方法的重写。

　　　　下面我们用虚方法来改造一下上面的例子

    /// <summary>
    /// 演示类
    /// </summary>
    class Demo
    {
        List<Book> books = new List<Book>();

        /// <summary>
        /// 测试
        /// </summary>
        public void Test()
        {
            books.Add(new ComputerBook());
            books.Add(new JavaBook());
            //遍历时不用加判断
            foreach (Book item in books)
            {
                item.ByReading();
            }
        }
    }

    /// <summary>
    /// 书类
    /// </summary>
    class Book
    {
        public virtual void ByReading()
        {

        }
    }

    /// <summary>
    /// 计算机书籍
    /// </summary>
    class ComputerBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public override void ByReading()
        {
            Console.WriteLine("我是计算机类书籍，被在校大学生使用。");
        }
    }

    /// <summary>
    /// Java书籍
    /// </summary>
    class JavaBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public override void ByReading()
        {
            Console.WriteLine("我是Java书籍，被在业Java程序员使用。");
        }
    }

　　　　

　　　　可以看出，使用虚方法来写代码简便了许多。但是问题又来了，一般子类的父类和在父类中的虚方法是“宏观”的，“抽象”的，我

　　　　们不想让这个父类被实例化并且只提供方法的定义，由子类去实现这个方法，该怎么做呢？

　　　　如何解决这个问题呢？我们可以使用抽象类和抽象方法来实现。

抽象类和抽象方法

　　　　abstract关键字：

　　　　　　　　abstract关键字用来修饰抽象类和抽象方法。

　　　　抽象类：

　　　　　　　　使用abstract关键字修饰的抽象类不能被实例化。

　　　　　　　　抽象类中可以有非抽象方法。

　　　　　　　　抽象类不能是密封的或者静态的。

　　　　抽象方法：

　　　　　　　　使用abstract关键字修饰的抽象方法是一个没有实现的方法，由子类重写抽象方法来实现。

　　　　　　　　抽象方法没有大括号，直接在小括号后以分号";"结尾。

　　　　　　　　含有抽象方法的类必须是抽象类。

　　　　　　　　抽象方法必须在其子类中实现，除非它的子类也是抽象类。

　　　　

　　　　下面我们使用抽象类和抽象方法再次改造上面的例子

    /// <summary>
    /// 演示类
    /// </summary>
    class Demo
    {
        List<Book> books = new List<Book>();

        /// <summary>
        /// 测试
        /// </summary>
        public void Test()
        {
            books.Add(new ComputerBook());
            books.Add(new JavaBook());
            //遍历时不用加判断
            foreach (Book item in books)
            {
                item.ByReading();
            }
        }
    }

    /// <summary>
    /// 书类
    /// </summary>
    abstract class Book
    {
        public abstract void ByReading();
    }

    /// <summary>
    /// 计算机书籍
    /// </summary>
    class ComputerBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public override void ByReading()
        {
            Console.WriteLine("我是计算机类书籍，被在校大学生使用。");
        }
    }

    /// <summary>
    /// Java书籍
    /// </summary>
    class JavaBook : Book
    {
        /// <summary>
        /// 被阅读
        /// </summary>
        public override void ByReading()
        {
            Console.WriteLine("我是Java书籍，被在业Java程序员使用。");
        }
    }

　　　　 

　　　　

　　　　到了这里，我们可以发现使用虚方法和抽象方法来编程（也就是多态）更符合面向对象编程的思想，并且可以大幅的提升代码的

　　　　可读性和减少冗余的代码。

　　　　用更少的代码实现相同的实现，这感觉，很爽的。