设计模式创建型——工厂模式

简单工厂模式（Simple Factory Pattern）是属于创建型模式，又叫做静态工厂方法（Static Factory Method Pattern）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

简单工厂模式角色

Factory（工厂角色）工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有实例的内部逻辑；工厂类可以直接被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它返回一个抽象产品类Product，所有的具体产品都是抽象产品的子类。
Product（抽象产品角色）抽象产品角色是简单工厂模式所创建的所有对象的父类,负责描述所有实例所共有的公共接口，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个工厂方法，因为所有创建的具体产品对象都是其子类对象。
ConcreteProduct（具体产品类）具体产品角色是简单工厂模式的创建目标，所有创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现定义在抽象产品中的抽象方法。

简单工厂模式类图

PS：图中fruit 为抽象产品角色，apple，pear，orange是具体产品类，factory是工厂角色。

简单工厂模式代码实现

抽象产品角色：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 13:41:41
 */
public interface Fruit {
    String getColor();
}

实际产品角色：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 13:41:41
 */
public class Apple implements Fruit{
    @Override
    public String getColor() {
        return "红色";
    }
}
public class Orange implements Fruit{
    @Override
    public String getColor() {
        return "橙色";
    }
}
public class Pear implements Fruit{
    @Override
    public String getColor() {
        return "黄色";
    }
}

工厂角色：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 13:44:44
 */
public class FruitFactory {
    public Fruit createFruit(String fruitType) {
        if(fruitType.equalsIgnoreCase("Apple")){
            return new Apple();
        } else if(fruitType.equalsIgnoreCase("Orange")) {
            return new Orange();
        }else if(fruitType.equalsIgnoreCase("Pear")){
            return new Pear();
        }
        return null;
    }
}

测试：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc
 * @date 2023/04/04 14:02:43
 */
public class Test {

    public static void main(String[] args) {
        FruitFactory fruitFactory = new FruitFactory();
        Fruit fruit = fruitFactory.createFruit("Orange");
        System.out.println(fruit.getColor());
        fruit = fruitFactory.createFruit("Apple");
        System.out.println(fruit.getColor());
        fruit = fruitFactory.createFruit("Pear");
        System.out.println(fruit.getColor());
    }
}

工厂方法模式

工厂方法模式，又称工厂模式（Factory Pattern）、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。
将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。

工厂方法模式角色

抽象工厂角色（Abstract Factory）：描述具体工厂的公共接口，是具体工厂的父类。
具体工厂角色（Concrete Factory）：描述具体工厂，创建产品的实例，供外界调用，主要实现了抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品角色（Product）：抽象产品角色是简单工厂模式所创建的所有对象的父类,负责描述所有实例所共有的公共接口，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个工厂方法，因为所有创建的具体产品对象都是其子类对象。
具体产品角色（Concrete Product）：具体产品角色是简单工厂模式的创建目标，所有创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现定义在抽象产品中的抽象方法，由具体工厂来创建，它同具体工厂之间一一对应。

工厂方法模式类图

工厂方法模式代码实现

抽象产品角色：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 14:31:33
 */
public interface Fruit {
    String getColor();
    String getTaste();
}

具体产品角色

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 14:45:27
 */
public class Apple implements Fruit {
    @Override
    public String getColor() {
        return "红色";
    }

    @Override
    public String getTaste() {
        return "好吃";
    }
}
public class Pear implements Fruit {
    @Override
    public String getColor() {
        return "黄色";
    }

    @Override
    public String getTaste() {
        return "吃了还想吃";
    }
}
public class Orange implements Fruit {
    @Override
    public String getColor() {
        return "橙色";
    }

    @Override
    public String getTaste() {
        return "美味";
    }
}

抽象工厂角色

import java.util.Objects;

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 14:47:44
 */
public abstract class FruitAbstractFactory {

    public Fruit createFruit(String fruitType) {
        if(Objects.isNull(fruitType)){
            return null;
        }
        if(fruitType.equalsIgnoreCase("Apple")){
            return new Apple();
        } else if(fruitType.equalsIgnoreCase("Orange")) {
            return new Orange();
        }else if(fruitType.equalsIgnoreCase("Pear")){
            return new Pear();
        }
        return null;
    }

    public abstract String getFruitColor(Fruit fruit);

    public abstract String getFruitTaste(Fruit fruit);

}

具体工厂角色

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 昂焱数据: https://www.ayshuju.com
 * @date 2023/04/04 14:49:48
 */
public class FruitColorFactory extends FruitAbstractFactory{

    @Override
    public String getFruitColor(Fruit fruit) {
        return fruit.getColor();
    }

    @Override
    public String getFruitTaste(Fruit fruit) {
        return null;
    }
}

public class FruitTasteFactory extends FruitAbstractFactory{

    @Override
    public String getFruitColor(Fruit fruit) {
        return null;
    }

    @Override
    public String getFruitTaste(Fruit fruit) {
        return fruit.getTaste();
    }
}

测试：

/**
 * @author Evan Walker
 * @version 1.0
 * @desc
 * @date 2023/04/04 14:02:43
 */
public class Test {

    public static void main(String[] args) {

        FruitColorFactory colorFactory = new FruitColorFactory();
        FruitTasteFactory tasteFactory = new FruitTasteFactory();
        Fruit fruitColor = colorFactory.createFruit("Orange");
        Fruit fruitTaste = tasteFactory.createFruit("Orange");

        System.out.print(fruitColor.getColor());
        System.out.println(fruitTaste.getTaste());

        fruitColor = colorFactory.createFruit("Apple");
        fruitTaste = tasteFactory.createFruit("Apple");

        System.out.print(fruitColor.getColor());
        System.out.println(fruitTaste.getTaste());

        fruitColor = colorFactory.createFruit("Pear");
        fruitTaste = tasteFactory.createFruit("Pear");

        System.out.print(fruitColor.getColor());
        System.out.println(fruitTaste.getTaste());

    }
}

工厂模式的特点

优点

一个调用者想创建一个对象，只需知道其名称。
扩展性高，如果想增加一个产品，只需扩展一个工厂类。
屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

使用场景

日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

注意事项

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m