设计模式之工厂模式详解（Java）

引言

设计模式是软件工程中的一种经验总结，它提供了一套可复用的解决方案，以解决在软件设计中反复出现的问题。工厂模式是设计模式中的一种，它主要用于创建对象，并隐藏对象创建的具体实现细节。在Java中，工厂模式有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。本文将详细讲解这三种模式的概念、实现和应用。

一、简单工厂模式

1.1 概念

简单工厂模式又称静态工厂模式，它由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。

1.2 实现

1.2.1 定义产品接口

public interface Car {
    void drive();
}

1.2.2 实现产品类

public class DZCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving DZCar");
    }
}

public class CACar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving CACar");
    }
}

1.2.3 创建工厂类

public class CarFactory {
    public static Car createCar(String type) {
        if ("DZ".equals(type)) {
            return new DZCar();
        } else if ("CA".equals(type)) {
            return new CACar();
        }
        return null;
    }
}

1.3 应用

public class Consumer {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("DZ");
        car.drive();
    }
}

二、工厂方法模式

2.1 概念

工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式让一个类的实例化延迟到其子类。

2.2 实现

2.2.1 定义产品接口

public interface Car {
    void drive();
}

2.2.2 实现产品类

public class DZCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving DZCar");
    }
}

public class CACar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving CACar");
    }
}

2.2.3 创建工厂接口和实现类

public interface CarFactory {
    Car createCar();
}

public class DZCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new DZCar();
    }
}

public class CACarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new CACar();
    }
}

2.3 应用

public class Consumer {
    public static void main(String[] args) {
        CarFactory factory = new DZCarFactory();
        Car car = factory.createCar();
        car.drive();
    }
}

三、抽象工厂模式

3.1 概念

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

3.2 实现

3.2.1 定义产品接口

public interface Car {
    void drive();
}

public interface Wheel {
    void rotate();
}

3.2.2 实现产品类

public class DZCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving DZCar");
    }
}

public class CACar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving CACar");
    }
}

public class DZWheel implements Wheel {
    @Override
    public void rotate() {
        System.out.println("Rotating DZWheel");
    }
}

public class CAWheel implements Wheel {
    @Override
    public void rotate() {
        System.out.println("Rotating CAWheel");
    }
}

3.2.3 创建工厂接口和实现类

public interface CarFactory {
    Car createCar();
    Wheel createWheel();
}

public class DZFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new DZCar();
    }

    @Override
    public Wheel createWheel() {
        return new DZWheel();
    }
}

public class CAFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new CACar();
    }

    @Override
    public Wheel createWheel() {
        return new CAWheel();
    }
}

3.3 应用

public class Consumer {
    public static void main(String[] args) {
        CarFactory factory = new DZFactory();
        Car car = factory.createCar();
        car.drive();
        Wheel wheel = factory.createWheel();
        wheel.rotate();
    }
}

四、总结

工厂模式是一种常用的设计模式，它通过封装对象的创建过程，将对象的创建和使用分离，提高了代码的可维护性和可扩展性。在实际开发中，根据不同的需求选择合适的工厂模式，可以更好地应对软件设计中的问题。