创建型-工厂模式（factory）

1，简单工厂模式

1.1，简介

简单工厂：封装创建产品的过程。提供一个返回产品实例的方法，此方法封装了产品实例的逻辑，根据参数返回不同的实例。所有产品一个工厂实例生成。

缺点：每多一个产品，就要修改 instance() 方法，修改的多，方法就变长。

优点：我就是这么用的，简单实用。。。

简单工厂模式不属于 23 种设计模式之一。

1.2，demo

  1. 产品接口
package com.demo.base.design_partten.factory.simple_factory;
 
/**
 * 产品接口
 * */
public interface Car {
 
    void run();
 
    void stop();
}
  1. 产品类
package com.demo.base.design_partten.factory.simple_factory;
 
/**
 * 产品类
 * */
public class BCCar implements Car {
    @Override
    public void run() {
        System.out.println("bc car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bc car is stop");
    }
}
 
package com.demo.base.design_partten.factory.simple_factory;
 
/**
 * 产品类
 * */
public class BMCar implements Car {
    @Override
    public void run() {
        System.out.println("bm car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bm car is stop");
    }
}
  1. 工厂类

封装创建产品对象的方法。

package com.demo.base.design_partten.factory.simple_factory;
 
/**
 * @author gx
 * 简单工厂：
 *  封装创建产品的过程。提供一个返回产品实例的方法，此方法封装了产品实例的逻辑，根据参数返回不同的实例。所有产品一个工厂实例生成。
 * 缺点：
 *  每多一个产品，就要修改 instance() 方法，修改的多，方法就变长。
 * 优点：
 *  我就是这么用的，简单实用。。。
 */
public class Factory {
    public static Car instance(Integer carType) throws Exception {
        if(carType.equals(1)){
            return new BCCar();
        }else if(carType.equals(2)){
            return new BMCar();
        }else{
            throw new Exception();
        }
    }
}
  1. 测试类

调用工厂类提供的方法来创建产品对象。

package com.demo.base.design_partten.factory.simple_factory;
 
/**
 * 简单工厂模式不算 GOF 23 种设计模式之一。
 * GOF：一本书四个人写的关于设计模式的书（Gang of Four）
 * 调用工厂类的方法，传入参数获取不同的实例。
 * */
public class Test {
    public static void main(String[] args) throws Exception {
        Car instance = Factory.instance(1);
        instance.run();
        instance.stop();
 
        Car instance1 = Factory.instance(2);
        instance1.run();
        instance1.stop();
    }
}

2，抽象工厂模式

2.1，简介

抽象工厂模式

GOF 之一。符合开闭原则。

同一个工厂创建一系列的产品（车，座椅）。不违反开闭原则情况下，智能扩展一个新的系列（大众）。

抽象工厂模式和工厂方法模式：抽象工厂每个工厂可以创建一个系列的多个不同实例，工厂方法只能创建一个实例。

2.2，demo

  1. 产品接口
package com.demo.base.design_partten.factory.abstract_factory;
 
public interface Seat {
    void sit();
}
 
package com.demo.base.design_partten.factory.abstract_factory;
 
/**
 * 产品接口
 * */
public interface Car {
 
    void run();
 
    void stop();
}
  1. 产品实现类
package com.demo.base.design_partten.factory.abstract_factory;
 
/**
 * 产品类
 * */
public class BCCar implements Car {
    @Override
    public void run() {
        System.out.println("bc car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bc car is stop");
    }
}
 
package com.demo.base.design_partten.factory.abstract_factory;
 
/**
 * 产品类
 * */
public class BMCar implements Car {
    @Override
    public void run() {
        System.out.println("bm car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bm car is stop");
    }
}
 
package com.demo.base.design_partten.factory.abstract_factory;
 
public class BCSeat implements Seat {
    @Override
    public void sit() {
        System.out.println("bc sit！");
    }
}
 
package com.demo.base.design_partten.factory.abstract_factory;
 
public class BMSeat implements Seat {
    @Override
    public void sit() {
        System.out.println("BM sit！");
    }
}
  1. 抽象工厂
package com.demo.base.design_partten.factory.abstract_factory;
 
public interface AbstractFactory {
    Car createCar();
 
    Seat createSeat();
}
  1. 工厂类
package com.demo.base.design_partten.factory.abstract_factory;
 
public class BCFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BCCar();
    }
 
    @Override
    public Seat createSeat() {
        return new BCSeat();
    }
}
 
package com.demo.base.design_partten.factory.abstract_factory;
 
public class BMFactory implements AbstractFactory{
    @Override
    public Car createCar() {
        return new BMCar();
    }
 
    @Override
    public Seat createSeat() {
        return new BMSeat();
    }
}
  1. 测试类
package com.demo.base.design_partten.factory.abstract_factory;
public class Test {
    public static void main(String[] args) {
        BMFactory bmFactory = new BMFactory();
        Car bmCar = bmFactory.createCar();
        bmCar.run();
        bmCar.stop();
        Seat bmSeat = bmFactory.createSeat();
        bmSeat.sit();
        BCFactory bcFactory = new BCFactory();
        Car bcCar = bcFactory.createCar();
        bcCar.run();
        bcCar.stop();
        Seat bcSeat = bcFactory.createSeat();
        bcSeat.sit();
    }
}

3. 工厂方法模式

3.1，简介

工厂方法模式：属于 GOF 23种设计模式之一。符合开放封闭原则。

开放封闭原则：
 对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
 对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

每个产品一个对应的工厂，新增一种产品，需要新增一个工厂，不需要修改之前的产品和工厂类。

3.2，demo

  1. 产品接口
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * 产品接口
 * */
public interface Car {
 
    void run();
 
    void stop();
}
  1. 产品实现类
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * 产品类
 * */
public class BCCar implements Car {
    @Override
    public void run() {
        System.out.println("bc car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bc car is stop");
    }
}
 
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * 产品类
 * */
public class BMCar implements Car {
    @Override
    public void run() {
        System.out.println("bm car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("bm car is stop");
    }
}
 
package com.demo.base.design_partten.factory.method_factory;
 
public class DzCar implements Car {
    @Override
    public void run() {
        System.out.println("dz car is running");
    }
 
    @Override
    public void stop() {
        System.out.println("dz car is stop");
    }
}
  1. 抽象工厂
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * 抽象工厂
 * */
public interface AbstractFactory {
    Car createCar();
}
  1. 工厂实现类
package com.demo.base.design_partten.factory.method_factory;
 
public class BCFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BCCar();
    }
}
 
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * @author gx
 */
public class BMFactory implements AbstractFactory {
    @Override
    public Car createCar() {
        return new BMCar();
    }
}
 
package com.demo.base.design_partten.factory.method_factory;
 
public class DzFactory implements AbstractFactory{
    @Override
    public Car createCar() {
        return new DzCar();
    }
}
  1. 测试类
package com.demo.base.design_partten.factory.method_factory;
 
/**
 * 工厂方法模式：
 *  属于 GOF 23种设计模式之一。符合开放封闭原则。
 *  开放封闭原则：
 *      对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
 *      对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。
 * 每个产品一个对应的工厂，新增一种产品，需要新增一个工厂，不需要修改之前的产品和工厂类。
 * */
public class Test {
    public static void main(String[] args) {
 
        Car car = new BMFactory().createCar();
        car.run();
        car.stop();
 
        Car car1 = new BCFactory().createCar();
        car1.run();
        car1.stop();
 
        Car car2 = new DzFactory().createCar();
        car2.run();
        car2.stop();
 
    }
}

4. 工厂方法模式和抽象工厂模式的区别

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

5. 使用场景

这个使用就多了，

  1. Mybatis 的 SqlSessionFactory 和 SqlSession
  2. jdk 的 ObjectFactory，下面各种各样的工厂类。

本文作者：Hi.PrimaryC

本文链接：https://www.cnblogs.com/cnff/p/17080950.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   primaryC  阅读(56)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
AI IDE Trae
  1. 1 404 not found REOL
404 not found - REOL
00:00 / 00:00
An audio error has occurred.