大话设计模式之简单工厂模式笔记

╰+哭是因爲堅強的太久メ 2022-04-08 14:28 184阅读 0赞

# 代码规范： #

代码命名需要有具体的含义，切不可以用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程序员使用。");
            }
        }

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

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