工厂设计模式

工厂模式

没有工厂模式

设计流程

在没有使用工厂模式来进行对象的创建和使用。

对应的uml图的设计行为。根据这个uml图将代码进行实现。

代码

抽象类(Fruit)

package com.yt.designPattern23.factoryPattern.simpleFactory.noUse;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public abstract class Fruit {
    private String name;

    public void cut(){
        System.out.println(name + "这个水果被切了");
    }
    public void eat(){
        System.out.println(name + "这个水果被吃了");
    }
    public void hold(){
        System.out.println(name + "这个水果被拿了");
    }
    public void setterName(String name){
        this.name = name;
    }
    //抽象业务方法设计，让子类来具体进行实现操作，不同的子类含有着不同的实现功能。
    public abstract void prepare();
}

具体水果类(Apple)

package com.yt.designPattern23.factoryPattern.simpleFactory.noUse;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public class Apple extends Fruit{
    @Override
    public void prepare() {
        System.out.println("这个苹果正在被准备着");
    }
}

具体水果类(Banana)

package com.yt.designPattern23.factoryPattern.simpleFactory.noUse;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:19
 **/
public class Banana  extends Fruit{
    @Override
    public void prepare() {
        System.out.println("这个香蕉正在被准备着");
    }
}

具体水果类(Orange)

package com.yt.designPattern23.factoryPattern.simpleFactory.noUse;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public class Orange extends Fruit{
    @Override
    public void prepare() {
        System.out.println("这个橘子正在被准备着");
    }
}

使用类(People)

package com.yt.designPattern23.factoryPattern.simpleFactory.noUse;
​
/**
 * @program: designPattern
 * @description     这种是没有使用工厂模式来进行对象的创建操作和使用操作的。
 * @author: YangTao
 * @create: 2024-03-02 22:19
 **/
public class People {
    public static void main(String[] args) {
        Orange orange = new Orange();
        orange.setterName("苹果");
        orange.prepare();
        orange.cut();
        orange.eat();
        orange.hold();
    }
}

在没有使用的情况下： 都是要直接使用者自己去创建这个具体的对象，这就是相当于是一种行为——我使用者想要吃苹果的时候，我是要我自己去先做出一个苹果，只有自己做出来了这个苹果之后，我才能对这个苹果来进行使用，处理操作。这并不符合人的设计理念和想法。

简单工厂模式

流程设计

工厂是根据具体产品的名称对应操作来进行具体对象创建操作的。当传入的名称和设计的不符合的情况之下会直接生成一个错误的提示的。不会生成对象的。

所有的产品都是在一个工厂当中来进行创建的

代码

抽象产品类(Fruit)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public abstract class Fruit {
    private String name;
​
    public void cut(){
        System.out.println(name + "这个水果被切了");
    }
    public void eat(){
        System.out.println(name + "这个水果被吃了");
    }
    public void hold(){
        System.out.println(name + "这个水果被拿了");
    }
    public void setterName(String name){
        this.name = name;
    }
    public static void printFault(){
        System.out.println("创建对象出现了错误，工厂当中没有这一种产品");
    }
    //抽象业务方法设计，让子类来具体进行实现操作，不同的子类含有着不同的实现功能。
    public abstract void prepare();
}

具体产品类(Apple)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public class Apple extends Fruit {
    @Override
    public void prepare() {
        System.out.println("这个苹果正在被准备着");
    }
}

具体产品类(Banana)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:19
 **/
public class Banana extends Fruit {
    @Override
    public void prepare() {
        System.out.println("这个香蕉正在被准备着");
    }
}

具体产品类(Orange)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-02 22:18
 **/
public class Orange extends Fruit {
    @Override
    public void prepare() {
        System.out.println("这个橘子正在被准备着");
    }
}

具体工厂类(FruitFactory)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-04 09:18
 **/
public class FruitFactory {
    //通过名称来对水果进行创建在对工厂当中
    public static Fruit getFruit(String name){
        Fruit fruit = null;
        if(name.equals("apple")){
            fruit = new Apple();
            fruit.setterName("apple");
​
        }
        else if(name.equals("banana")){
            fruit = new Banana();
            fruit.setterName("banana");
        }
        else if(name.equals("orange")){
            fruit = new Orange();
            fruit.setterName("orange");
        }
        else{
            //生成错误的提示
            Fruit.printFault();
        }
        return fruit;
    }
}

产品的使用端(People)

package com.yt.designPattern23.factoryPattern.simpleFactory.use;
​
​
/**
 * @program: designPattern
 * @description     这种是没有使用工厂模式来进行对象的创建操作和使用操作的。
 * @author: YangTao
 * @create: 2024-03-02 22:19
 **/
public class People {
    public static void main(String[] args) {
        Fruit fruit;
        fruit= FruitFactory.getFruit("apple");
        fruit.cut();
        fruit.eat();
        fruit.hold();
        fruit.prepare();
​
        //生成错误的对象，工厂当中是没有这个产品的创建的。
        fruit= FruitFactory.getFruit("aaa");
        fruit.cut();
        fruit.eat();
        fruit.hold();
        fruit.prepare();
    }
}

生成的结果：

简单的工厂设计模式是根据产品的名称来进行创建操作的，但是还有一些局限是只能是含有一个工厂来进行对象的创建操作的。对具体的产品进行创建，当名称不对应的时候就会出现错误。不能对一个产品含有不同的品牌来进行产品的创建。想要对不同的产品含有着不同的品牌来进行设计的情况，是要设定多个不同的工厂的，这个工厂是只针对于这个厂家的藏产品来进行设计和创建的。

这就会引出接下来的工厂设计模式来对其进行创建操作。

工厂方法模式

由简单工厂模式进行改进操作，并不是将所有的对象都是由一个工厂来进行创建的，而是分成不同的工厂来对具体的产品进行创建的。类似于工厂生产水果，就这个工厂只是生产西瓜的，那个工厂只是生产苹果。只是生产自己的产品，不额外的生产其他的产品。

以生产电器为例子来进行工厂方法的学习！

电器一共是含有着电视，冰箱，空调这基本的三种。简单工厂是将其三种电器都是让一个大工厂来进行生产的，这样也是可以的。但是还有着一种设计的方法是每一种产品都是让一个工厂来进行生产操作，专注自己的那一份工作，做好就得了。

流程设计

每一个工厂是只创建一个具体的对象实例的。

代码

抽象工厂(Factory)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:30
 **/
public interface Factory {
​
    public Logger createLogger();
}

具体工厂(DatabaseFactory)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:30
 **/
public class DatabaseFactory implements Factory{
    @Override
    public Logger createLogger() {
        DatabaseLogger logger = new DatabaseLogger();
        return logger;
    }
}

具体工厂(FileFactory)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:30
 **/
public class FileFactory implements Factory{
    @Override
    public Logger createLogger() {
        FileLogger logger = new FileLogger();
        return logger;
    }
}

抽象产品(Logger)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:29
 **/
public interface Logger {
    public void writeLogger();
}

具体产品(DatabaseLogger)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:29
 **/
public class DatabaseLogger implements Logger{
    @Override
    public void writeLogger() {
        System.out.println("数据库输日志");
    }
}

具体产品(FileLogger)

package com.yt.designPattern23.factoryPattern.factoryMethod;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 20:29
 **/
public class FileLogger implements Logger{
    @Override
    public void writeLogger() {
        System.out.println("文件输日志");
    }
}

这种每一个工厂是只生产一个产品的，这种效率的话是不高的。

当来了一种需求是含有着多种产品，每一种产品又含有很多个品牌。

抽象工厂

抽象工厂就是可以对这种需求来进行处理操作的。

流程设计

代码

抽象工厂

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
​
public interface Factory {
    //工厂设定抽象方法，让其子类进行实现
        public Fruit productApple();
​
        public Fruit productOrange();
​
        public Fruit productBanana();
}

具体工厂(ChinaFactory)

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:01
 **/
public class ChinaFactory implements Factory{
​
    @Override
    public Fruit productApple() {
        ChinaApple chinaApple = new ChinaApple();
        chinaApple.setterName("中国苹果");
        return chinaApple;
    }
​
    @Override
    public Fruit productOrange() {
        ChinaOrange chinaOrange = new ChinaOrange();
        chinaOrange.setterName("中国橘子");
        return chinaOrange;
    }
​
    @Override
    public Fruit productBanana() {
        ChinaBanana chinaBanana = new ChinaBanana();
        chinaBanana.setterName("中国香蕉");
        return chinaBanana;
    }
}

具体工厂(USAFactory)

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:02
 **/
public class USAFactory implements Factory{
    @Override
    public Fruit productApple() {
        USAApple usaApple = new USAApple();
        usaApple.setterName("美国苹果");
        return usaApple;
    }
​
    @Override
    public Fruit productOrange() {
        USAOrange usaOrange = new USAOrange();
        usaOrange.setterName("美国橘子");
        return usaOrange;
    }
​
    @Override
    public Fruit productBanana() {
        USABanana usaBanana = new USABanana();
        usaBanana.setterName("美国香蕉");
        return usaBanana;
    }
}

抽象产品(Fruit)

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:02
 **/
public abstract class Fruit {
    private String name;
​
    public void cut(){
        System.out.println(name + "这个水果被切了");
    }
    public void eat(){
        System.out.println(name + "这个水果被吃了");
    }
    public void hold(){
        System.out.println(name + "这个水果被拿了");
    }
    public void setterName(String name){
        this.name = name;
    }
    //抽象业务方法设计，让子类来具体进行实现操作，不同的子类含有着不同的实现功能。
    public abstract void prepare();
}

ChinaApple

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:03
 **/
public class ChinaApple extends Fruit{
    @Override
    public void prepare() {
            System.out.println("中国苹果正在被准备着");
    }
}

ChinaBanana

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:04
 **/
public class ChinaBanana extends Fruit{
        @Override
        public void prepare() {
            System.out.println("中国香蕉正在被准备着");
        }
}

ChinaOrange

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:04
 **/
public class ChinaOrange extends Fruit{
        @Override
        public void prepare() {
            System.out.println("中国橘子正在被准备着");
        }
}

USAApple

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:04
 **/
public class USAApple extends Fruit{
        @Override
        public void prepare() {
            System.out.println("美国苹果正在被准备着");
        }
}

USABanana

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:04
 **/
public class USABanana extends Fruit{
        @Override
        public void prepare() {
            System.out.println("美国香蕉正在被准备着");
        }
}

USAOrange

package com.yt.designPattern23.factoryPattern.abstractFactory;
​
/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:04
 **/
public class USAOrange extends Fruit{
        @Override
        public void prepare() {
            System.out.println("美国橘子正在被准备着");
        }
}

客户端(People)

package com.yt.designPattern23.factoryPattern.abstractFactory;

/**
 * @program: designPattern
 * @description
 * @author: YangTao
 * @create: 2024-03-05 21:00
 **/
public class People {
    public static void main(String[] args) {
        Factory factory = null;
        Fruit fruit = null;
        factory = new ChinaFactory();
        //让中国工厂生产中国橘子
        fruit = factory.productOrange();
        fruit.prepare();
        fruit.cut();
        fruit.eat();
        fruit.hold();


        factory = new USAFactory();
        //让中国工厂生产中国橘子
        fruit = factory.productApple();
        fruit.prepare();
        fruit.cut();
        fruit.eat();
        fruit.hold();
    }
}