大话设计模式之简单工厂模式笔记-CSDN博客

代码规范：

代码命名需要有具体的含义，切不可以用A，B，C等字符代替面试题里面的数字，可用strNumberA，strNumberB等。

面向对象的分析设计编程思想，可以通过面向对象三大特性封装、继承、多态把程序的耦合度降低，使程序更加灵活。

业务封装（封装）

让业务逻辑和界面逻辑分开，让它们之间的耦合度下降。简单来说就是将业务写到单独的一个类里。

简单工厂模式（继承和多态）

主要是根据获取的参数来判断到底要实例化谁，用一个单独的类来做这个创造实例的过程，这就是工厂。

在使用继承编程的时候，我们一般是把不同子类的方法分别写在不同的子类中，使用的时候用is a关键字来判断对象是哪种类的，然后进行强制转换来使用不同对象的方法。但是，如果有多个子类的话，使用的时候难道要写多个if语句来判断对象是哪种类型的吗？这样会产生很多冗余代码，也会很繁琐。使用多态编程可以很好的解决这个问题。在父类写一个虚方法或抽象方法，子类去重写父类的方法，在调用的时候系统会根据对象运行时的类型决定调用哪个方法。这样子是不是简洁多了？

下面这段代码应用了继承，但是子类方法的判断是用的if语句is a关键字来判断的。

通过这段代码可以发现：在使用子类对象的时候需要先用is a来判断子类对象时哪种类型的。那么也就是说，如果一个父类有10个派生类（子类）的话，就要用10个if判断语句来判断子类对象是哪种类型了，未免太过繁琐。这时，虚方法就该登场了。

/// <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程序员使用。");
        }
    }

虚方法

概念：虚方法有方法体，可以被重写，使用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程序员使用。");
        }
    }

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

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