八大设计模式——工厂模式

八大设计模式——工厂模式

工厂模式

工厂模式就是将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性。

当我们每次添加新产品，我们就需要去修改我们的工厂类，修改已存在的代码，首先不符合设计模式的开闭原则，也就是只能追加不能修改，若修改量比较大，可能会影响系统性能，那怎办呢？这个时候就提出了工厂方法模式。

工厂模式将对象的创建和使用分离，从而提高代码的可维护性，可扩展性和可测试性。

1、简单工厂模式：

首先简单工厂模式并不是工厂模式的一种，也不属于23种模式，它只是工厂模式的一种基础形式。

适用场景：当我们创建的对象较少且过程相对来说比较简单，这个时候就可以考虑使用简答工厂模式。

2、工厂方法模式：

工厂方法模式通过定义一个用于创建对象的接口，但将具体对象的创建交给子类来实现，使得客户端代码可以独立于具体对象的类型，而只与工厂接口进行交互。

使用场景：

1、当你不知道该使用对象的确切类型的时候。
2，当你希望为库或框架提供扩展其内部组件或方法的时候。

//工厂方法模式
//1、将具体产品和创建者解耦
//2、符合单一职责原则
//3、符合开闭原则

public class factoryMethod {
    public static void main(String[] args) {
        ProductFactory p1 = new ConcreateProductA();
        ProductFactory p2 = new ConcreateProductA1();

        Product productA = p1.createProduct();
        productA.method1();
        Product productA1 = p2.createProduct();
        productA1.method1();
    }

}
interface Product{
    void method1();
}
class ProductA implements Product{
    @Override
    public void method1() {
        System.out.println("--ProductAToMethod1--");
    }
}
class ProductA1 implements Product{
    @Override
    public void method1() {
        System.out.println("--ProductA1ToMethod1--");
    }
}
interface ProductFactory{
    Product createProduct();
}
class ConcreateProductA implements  ProductFactory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
class ConcreateProductA1 implements  ProductFactory{
    @Override
    public Product createProduct() {
        return new ProductA1();
    }
}

3、抽象工厂模式：

抽线工厂模式提供了一个创建一些类相关或相互依赖对象的接口，而无需指定具体类。通过使用抽象工厂模式，客户端可以创建并使用多个产品组合，而无需关心具体产品的实现细节。

应用场景：程序需要处理不同系列的相关产品，但是不希望依赖于这些产品的具体类时，可以使用抽象工厂模式。

//抽象工厂模式
//1、可以确信从工厂得到的产品间彼此兼容
//2、可以避免具体产品和客户端代码间的耦合
//3、符合单一职责原则
//4、符合开闭原则

public class abstractFactoryMethod {
    public static void main(String[] args) {
        AbstractFactory apple = new AppleFactory();
        Computer applecomputer = apple.createComputer();
        Phone iPhone = apple.createPhone();
        applecomputer.display();
        iPhone.display();

        AbstractFactory huaweiFactory = new HuaweiFactory();
        Computer huaweiComputer = huaweiFactory.createComputer();
        Phone mate60 = huaweiFactory.createPhone();
        huaweiComputer.display();
        mate60.display();
    }
}
interface Computer{
    void display();
}
interface Phone{
    void display();
}
interface AbstractFactory{
    Computer createComputer();
    Phone createPhone();
}

class AppleComputer implements Computer{
    @Override
    public void display() {
        System.out.println("--苹果电脑--");
    }
}
class HuaweiComputer implements Computer{
    @Override
    public void display() {
        System.out.println("--华为电脑--");
    }
}

class ApplePhone implements Phone{
    @Override
    public void display() {
        System.out.println("--iPhone15--");
    }
}
class HuaweiPhone implements Phone{
    @Override
    public void display() {
        System.out.println("--遥遥领先--");
    }
}
class AppleFactory implements AbstractFactory{

    @Override
    public Computer createComputer() {
        return new AppleComputer();
    }

    @Override
    public Phone createPhone() {
        return new ApplePhone();
    }
}
class HuaweiFactory implements AbstractFactory{

    @Override
    public Computer createComputer() {
        return new HuaweiComputer();
    }

    @Override
    public Phone createPhone() {
        return new HuaweiPhone();
    }
}