Java 设计模式（2）工厂模式

上一篇
1. Java 设计模式（1）单例模式
特点
springboot中哪些是工厂模式
1. BeanFactory与ApplicationContext容器‌
  Spring容器的核心接口，负责Bean的创建、管理和依赖注入，通过getBean()方法获取对象实例，隐藏具体实现逻辑‌
2. @Bean注解的工厂方法‌
  在配置类中声明@Bean方法动态创建对象，支持参数注入和条件控制（如@Conditional）‌
  1. 　　
    @Configuration public class DataSourceConfig { @Bean public DataSource dataSource() { return new HikariDataSource(); // 工厂方法创建连接池 } }

分类

无工厂模式

缺点：客户端需要知道创建细节‌

public class BYD {
    public void run() {
        System.out.println("比亚迪再跑");
    }
}

public class BMW {
    public void run(){
        System.out.println("宝马在跑");
    }
}






/**
 * 传统创建对象  没有通过工厂模式
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        BYD benz=new BYD();
        BMW bmw=new BMW();
        benz.run();
        bmw.run();
    }
}

简单工厂

优点：通过集中化的静态方法创建对象，客户端调用简单高效‌。客户端只需传入参数，无需关注对象创建细节‌
缺点：新增产品类型需修改工厂类逻辑（如增加switch-case分支）‌。工厂类与具体产品类强绑定，扩展性差‌

/**
 * 抽象产品角色
 * @author Administrator
 *
 */
public interface Car {
    public void run();
}



/**
 * 具体产品类
 * @author Administrator
 *
 */
public class BYD implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }

}

/**
 * 具体产品类
 * @author Administrator
 *
 */
public class BMW implements Car {

    @Override
    public void run() {
        System.out.println("宝马在跑");
    }
}


/**
 * 工厂类角色
 * @author Administrator
 *
 */
public class runrFactory {
    //返回类型必须为抽象产品角色
    public static Car run(String params) throws          Exception{
        //判断逻辑，返回具体的产品角色给Client
        if(params.equals("byd")){
            return new BYD();
        }else if(params.equals("bmw")){
            return new BMW();
        }else{
            throw new Exception();
        }
    }
}
//客户
public class Client {
    public static void main(String[] args) throws Exception {
        //告诉司机(工厂) 
        Car car=runrFactory.run("byd");
        //下命令开车
        car.run();
    }
}

工厂方法模式

优点：新增产品只需添加对应工厂类，无需修改已有代码‌。客户端依赖抽象工厂接口，与具体产品解耦‌。支持不同工厂创建不同产品变体‌
缺点：每新增一个产品需新增一个工厂类，增加系统复杂度‌。需显式选择使用哪个工厂类‌

/**
 * 抽象产品角色
 * @author Administrator
 *
 */
abstract class Car {
    abstract void run();
}


/**
 * 具体产品类
 * @author Administrator
 *
 */
public class BMW extends Car {

    @Override
    public void run() {
        System.out.println("宝马在跑");
    }
}
/**
 * 具体产品类
 * @author Administrator
 *
 */
public class BYD extends Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}


/**
 * 抽象工厂角色 用來生产车
 * @author Administrator
 *
 */
public interface abstractFactory {
    Car runFactory();

}


/**
 * 具体工厂角色
 * 创建奔驰车对象
 */
public class BYDFactory implements abstractFactory {
    @Override
    public  Car runFactory() {
        return new BYD();
    }
}


/**
 * 具体工厂角色
 * 创建宝马车对象
 */
public class BMWFactory implements abstractFactory {
    @Override
    public Car runFactory() {
        return new BMW();
    }
}


//客户
public class Client {
    private static Car BYD,BMW;
    private static abstractFactory BYDfactory,BMWfactory;
    public static void main(String[] args) throws Exception {
        //告诉(工厂) 要车
        BYDfactory=new BYDFactory();
        BYD=BYDfactory.runFactory();
        //可以开车了
        BYD.run();
        System.out.println("-------------------");
        BMWfactory=new BMWFactory();
        BMW=BMWfactory.runFactory();
        BMW.run();
    }
}

抽象工厂

// 抽象工厂类  定义不同的产品之间的标准，商务车
public interface ICarA {
    public void drive();
}


// 抽象工厂类  定义不同的产品之间的标准 跑车族
public interface ICarB {
    public void drive();
}

//具体产品类
public class productAHongqi implements ICarA {
    @Override
    public void drive() {
        System.out.println("开商务族--红旗车");
    }
}

//具体工厂类
public class productABmw implements ICarA {
    @Override
    public void drive() {
        System.out.println("开商务族--宝马车 ...");
    }
}

//具体产品类
public class producSporttBAudi implements ICarB {
    @Override
    public void drive() {
        System.out.println("开跑车族--奥迪车...");
    }
}


//具体工厂类
public class productSportBBenz implements ICarB {
    @Override
    public void drive() {
        System.out.println("开跑车族--奔驰车 ...");
    }
}


/**
 * 抽象工厂类 创建跑车族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory1 {
    abstract ICarB getProductBBenz();
    abstract ICarB getProductBAudi();
}


/**
 * 抽象工厂类  创建商务族跑车
 * @author Administrator
 *
 */
public abstract class abstractoryFactory2 {
    abstract ICarA getProductABmw();
    abstract ICarA getProductBHongqi();
}


/**
 * 具体工厂类 跑车族
 * @author Administrator
 *
 */
public class Factory1 extends abstractoryFactory1 {

    @Override
    ICarB getProductBBenz() {
        return new productSportBBenz();
    }

    @Override
    ICarB getProductBAudi() {
        return new producSporttBAudi();
    }
}


/**
 * 具体工厂类
 * 商务族
 * @author Administrator
 *
 */
public class Factory2 extends abstractoryFactory2 {
    @Override
    ICarA getProductABmw() {
        return new productABmw();
    }

    @Override
    ICarA getProductBHongqi() {
        return new productAHongqi();
    }
}


public class Client {
    public static void main(String[] args) {
        //工厂一制造的产品族车
        abstractoryFactory1 factory1 = new Factory1();
        ICarB productsportAbenz = factory1.getProductBBenz();
        ICarB productsportBaudi = factory1.getProductBAudi();

        productsportAbenz.drive();
        productsportBaudi.drive();
        //工厂二制造的产品族车
        abstractoryFactory2 factory2 = new Factory2();
        ICarA productAbmw = factory2.getProductABmw();
        ICarA productBhongqi = factory2.getProductBHongqi();
        productAbmw.drive();
        productBhongqi.drive();
    }
}

区别
1. 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个(产品族)。
2. 工厂方法模式的具体工厂类只能创建一个具体产品类的实例(一对一),而抽象工厂模式可以创建多个具体产品类的实例(一对多)。
下一篇
1. Java 设计模式（3）策略模式

posted @ 2025-07-24 15:20 zwjvzwj 阅读(6) 评论(0) 收藏举报

刷新页面返回顶部

zwjvzwj

Java 设计模式（2）工厂模式

公告