工厂模式的设计与实现

工厂模式适用于对象的创建过程较为复杂、需要扩展系统功能、需要屏蔽具体类型等情况下，可以提高代码的可维护性和可扩展性。它在很多框架和库中都被广泛应用，例如Java中的JDBC、Spring框架中的Bean工厂等。

主要有以下三类

1.简单工厂模式

定义一个工厂类，通过参数判断执行不同的命令，创建不同的产品

1.1定义一个抽象产品类

public abstract class Car {
    //一个抽象方法
    public abstract void drive();
}

1.2具体的产品实现类

public class JaoCheCar extends Car {
    @Override
    public void drive() {
        System.out.println("JaoCheCar is driving......");
    }
}
public class SUVCar extends Car {
    @Override
    public void drive() {
        System.out.println("SUVCar is driving......");
    }
}

1.3定义一个工厂类用于判断创建什么产品

public class Factory {
    public Car drivecar(String s){
        if (s.equals("SUV")){
            return new SUVCar();
        }else if (s.equals("JiaoChe")){
            return new JaoCheCar();
        }
        return null;
    }
}

1.4最后要开始测试了

public static void main(String[] args) {
        Factory factory = new Factory();
        Car suv = factory.drivecar("SUV");
        suv.drive();
        Car jiaoChe = factory.drivecar("JiaoChe");
        jiaoChe.drive();
    }

优点：将创建对象的权力交给了工厂，降低了耦合性

缺点：工厂类的扩展有问题，违反开闭原则且责任过重不易维护

2.工厂方法模式

2.1定义一个抽象的工厂类和抽象的产品类。

public abstract class CarFactory {
    public abstract Car creatcar();
}

public abstract class Car {
    //一个抽象方法
    public abstract void drive();
}

2.2创建具体的产品实现类和工厂实现类

public class JaoCheCar extends Car {
    @Override
    public void drive() {
        System.out.println("JaoCheCar is driving......");
    }
}
public class SUVCar extends Car {
    @Override
    public void drive() {
        System.out.println("SUVCar is driving......");
    }
}

public class JaoCheCarFactory extends CarFactory{
    @Override
    public Car creatcar() {
        return new JaoCheCar();
    }
}
public class SUVCarFactory extends CarFactory{
    @Override
    public Car creatcar() {
        return new SUVCar();
    }
}

2.3最后要开始测试啦

public static void main(String[] args) {
        SUVCarFactory suvCarFactory = new SUVCarFactory();
        Car suvcar = suvCarFactory.creatcar();
        suvcar.drive();
        JaoCheCarFactory jaoCheCarFactory = new JaoCheCarFactory();
        Car jiaochecar = jaoCheCarFactory.creatcar();
        jiaochecar.drive();
    }

优点：符合开闭原则，具备很好的可扩展性和维护性，有效的降低了耦合度

缺点：每一个产品都要对应一个工厂类，代码量增多，结构复杂。客户端需要知道所有的工厂类才可以根据需要进行创建，增加了客户端的复杂性，降低了代码的灵活性。

3.抽象工厂模式

对不同的产品进行分类，每一个产品大类成为产品族，抽象工厂具备产品族的方法。通过调用不同的抽象方法执行不同的命令。

3.1定义一个产品族，及他的两个实现类

public abstract class Car {
    //一个抽象方法
    public abstract void drive();
}
//实现类一
public class JaoCheCar extends Car {
    @Override
    public void drive() {
        System.out.println("JaoCheCar is driving......");
    }
}
//实现类二
public class SUVCar extends Car {
    @Override
    public void drive() {
        System.out.println("SUVCar is driving......");
    }
}

3.2再定义一个产品族，及他的两个实现类

public abstract class Home {
    public abstract void live();
}
//实现类一
public class BigHome extends Home{
    @Override
    public void live() {
        System.out.println("我住在大房子");
    }
}
//实现类二
public class SmallHome extends Home{
    @Override
    public void live() {
        System.out.println("我住在小房子");
    }
}

3.3定义一个抽象工厂类，及他的两个实现类。

public abstract class Factory {
    public abstract Car creatcar();
    public abstract Home creathome();
}
public class FactoryA extends Factory{
    @Override
    public Car creatcar() {
        return new SUVCar();
    }

    @Override
    public Home creathome() {
        return new BigHome();
    }
}
public class FactoryB extends Factory{
    @Override
    public Car creatcar() {
        return new SUVCar();
    }

    @Override
    public Home creathome() {
        return new SmallHome();
    }
}

3.4最后开始测试

public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        factoryA.creatcar().drive();
        factoryA.creathome().live();
        System.out.println("-------------------");
        Factory factoryB = new FactoryB();
        factoryB.creatcar().drive();
        factoryB.creathome().live();
    }

优点：

（1）符合开闭原则

（2）将同一个产品家族的创建集中在一个工厂类中，使得相关的产品可以一起创建，从而提高了代码的内聚性。

（3）降低客户端与具体类之间的耦合度，提高代码的灵活性和可维护性。

（4）抽象工厂模式将相关的产品集中在一起创建，可以确保这些产品是相互配套和一致的。这样可以在一定程度上提高了系统的稳定性和可靠性。

缺点：需要增加新的产品家族时，需要修改工厂的接口和实现，扩展性不如工厂方法模式。

当产品家族过多的时候，会使得类的层次结构复杂化