监考老师很好，下半年继续-阿里云开发者社区

监考老师很好，下半年继续

2023-08-08 31

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 监考老师很好，下半年继续

hello，大家好，我是了不起。

六月底，了不起为了软考，一天来回5个小时的地铁差点让我破大防了兄弟们

而且软考那天下午题迟到了，原因居然是太过匆忙，地铁走错了线，而且是连续走错了两次，两次都走到了回家的地铁线上了。

赶到考场的时候，门都关了。

那一瞬间真的感觉自己要祭了，还好命大。老师说还没迟到太多，所以放我进去了。

但是心态是真的崩了，估计下半年继续了。希望不要还是那个考场，在山庄深处。去学校的路就是爬山，那天真的是又热又慌啊。

唠叨时间结束了，该进入我们的真实学习分享吧。

今天从头学习设计模式，为了学他呢，说真的，很多人工作后认为寻常的crud根本就和设计模式没有关系。其实不尽然，只是我们没有发散思维的去怎么运用罢了，而且能否使用的前提还得是设计模式基础是否扎实。

设计模式

设计模式要素

设计模式代表的是我们周围不断重复发生的问题，以及如何解决该问题的核心方案，我们只有使用同一套方案，才可不必做一次又一次的重复工作。所以设计模式的核心不在如何抽象，而在于提供核心的解决方案。

用代码的话来说，如何在不同的场景可以复用同一套代码设计和体系结构是设计模式需要考虑的。

用原话来说，就是设计模式使得人们更加方便地复用成功的设计和体系结构。

基本要素

设计模式有四项基本要素。

模式名称（Pattern Name）
问题（Problem）
解决方案（Solution）
效果（Consequences）

分类

根据设计模式的目的，可以分为三大类：创建型模式，结构型模式，行为型模式。

创建型模式是与对象的创建有关的。
结构型模式处理的是类或对象的组合。
行为型模式是对类或对象怎么交互和怎么分配职责进行描述的。

这三类也可以分成两种，一种对于类来说，一种对于对象来说。

	创建型	结构型	行为型
类	工厂方法模式（Factory Method）	适配器模式（类）(Adapter)	解释器模式（Interpreter）模板方法模式（Template Method）
对象	抽象工厂模式（Abstract Factory）生成器模式（Builder）原型模式（Prototype）单例模式（Singleton）	适配器模式（对象）（Adapter）桥接模式（Bridge）组合模式（Composite）装饰模式（Decorator）外观模式（Facade）享元模式（Flyweight）代理模式（Proxy）	责任链模式（China of Responsibility）命令模式（Command）迭代器模式（Iterator）终极者模式（Mediator）备忘录模式（Memento）观察者模式（Observer）状态模式（State）策略模式（Strategy）访问者模式（Visitor）

PS：如果你要备考软考中级，这23种设计模式是要背的。

看完文章，那就来道软考题检查一下学习成果

在面向对象软件开发过程中，采用设计模式 ____，

A：以复用成功的设计

B：以保证程序的运行速度达到最优值

C：以减少设计过程中创建的类的个数

D：允许在非面向对象程序设计语言中使用面向对象的概念

答案：选 A，不懂的重新看一遍上面要素吧

什么是创建型设计模式？

创建型模式是对实例化过程进行的抽象，它能帮助一个系统独立于如何创建、组合和表示系统中的对象。注意力，这个一般要考的！

类创建型模式：使用继承改变被实例化的类
对象创建型模式：将实例化委托给另外一个对象

简单工厂模式

简单工厂模式属于创建型模式，但是它不属于23中的一种。

这里有三类角色：

工厂（Factory）：它是负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象。
抽象产品（abstract）：它是工厂类所创建的所有类的父类。里面封装了这个产品的所有公共方法，细节由子类对象去实现。
产品（Product）：它是简单工厂模式的创建目标，它会实现抽象产品定义的所有方法。

直接上代码

从Product开始，定义一个抽象的产品

abstract class Product{
        public abstract void method();
}

再定义两个抽象实现类ProductA、ProductB

class ProductA extends Product{
    @Override
    public void method()
    {
        System.out.println("产品A");
    }
}
class ProductB extends Product{
    @Override
    public void method()
    {
        System.out.println("产品B");
    }
}

最后在定义一个创建对象的简单工厂类

class Factory {
    public static Product createProduct(String type){
        Product product = null;
        switch (type){
            case "A":
                product = new ProductA();
                break;
            case "B":
                product = new ProductB();
            default:
                System.out.println("未匹配type");
                break;
        }
        return product;
    }
}

之后只需要在main函数中对Factory进行调用就行了，由于createProduct方法是static静态的，我们也不需要new一个对象出来，直接通过Factory.createProduct()调用即可。

public static void main(String[] args)
{
    Product productA = Factory.createProduct("A");
    productA.method();
    Product productB = Factory.createProduct("B");
    productB.method();
}

一个简单的工厂模式就这么实现了。但是这种会存在问题。比如，我多一个实现类ProductC,那么收到影响的就还有Factory的createProduct方法，需要再加一个case。

class ProductC extends Product{
    @Override
    public void method()
    {
        System.out.println("产品C");
    }
}
class Factory {
    public static Product createProduct(String type){
        Product product = null;
        switch (type){
            case "A":
                product = new ProductA();
                break;
            case "B":
                product = new ProductB();
            case "C":
                product = new ProductC();
            default:
                System.out.println("未匹配type");
                break;
        }
        return product;
    }
}

但是这种设计违反了开启-关闭原则，对扩展开启，对修改关闭。在实际项目上容易导致，修改后，旧代码发生异常。

不过这也是工厂方法模式的诞生缘由。

工厂方法模式意图：定义一个用于创建对象的接口，让子类决定实例化哪个类。让Factory的实例化延续到子类身上。

其中：

Product：定义工厂方法所创建的对象接口
ConcreteProduct：实现Product定义的接口
Creator：声明工厂方法，它会return一个Product类型的对象。
ConcreleCreator：重写工厂方法，返回一个ConcreteProduct对象实例。

一般适用于

当一个类不知道它所创建的对象类的时候
当一个类希望由它的子类来指定它需要创建的对象的时候
当类将创建对象的职责委托给子类中的某个子类，且你希望它是子类代理者这一信息局部化的时候

工厂方法模式

讲讲怎么从简单工厂转成工厂方法模式。

通过上图，我们来对应修改代码s

由抽象类abstract改成接口类interface，再对Factory抽象出一层接口类

interface Product{
   void method();
}
interface Factory {
   Product createProduct();
}

由继承类extends改成实现实现类implements

class ProductA implements Product{
    @Override
    public void method()
    {
        System.out.println("产品A");
    }
}
class ProductB implements Product{
    @Override
    public void method()
    {
        System.out.println("产品B");
    }
}
class FactoryA implements Factory{
    @Override
    public Product createProduct(){
        return new ProductA();
    }
}
class FactoryB implements Factory{
    @Override
    public Product createProduct(){
        return new ProductB();
    }
}

Main主函数由类+方法命调用改成 new一个对象

public static void main(String[] args)
{
    FactoryA factoryA = new FactoryA();
    Product productA = factoryA.createProduct();
    productA.method();
    FactoryA factoryB = new FactoryA();
    Product productB = factoryB.createProduct();
    productB.method();
}