工厂模式

工厂模式

核心本质：

• 实例化对象不需要使用new，直接用工程方法代替；
• 将选择实现类，创建对象统一管理和控制。使调用者跟我们实现解耦；

一般有这三种模式：简单工厂模式、工厂方法模式、抽象工厂模式

1、简单工厂模式

简介：最简单的对象创建管理方式，对不同的对象进行了一次封装，根据传递类型来执行需要创建的对象；

问题：对于新增加新的产品，需要去覆盖已有的代码；

具体实现：

• 接口：

public interface Fruit {
    void getFruitName();
}

• 产品类：

public class Apple implements Fruit {
    @Override
    public void getFruitName() {
        System.out.println("苹果");
    }
}

public class Orange implements Fruit {
    @Override
    public void getFruitName() {
        System.out.println("橘子");
    }
}

• 创建工厂：

//创建一个工厂，把需要用到的类放进去：
public class SimpleFactory {
    public static Fruit getFruit(String fruit){
        if (fruit.equals("apple")){
           return new Apple();
        }else if (fruit.equals("orange")){
            return new Orange();
        }else {
            return null;
        }
    }
}

• 测试：

public class Client {
    public static void main(String[] args) {
        //使用工厂创建对象，而不需通过new实例对象：
        Fruit fruit1 = SimpleFactory.getFruit("apple");
        Fruit fruit2 = SimpleFactory.getFruit("orange");
        fruit1.getFruitName();
        fruit2.getFruitName();
    }
}

2、工厂方法模式

简介：工厂方法模式会将每个产品都创建一个自己的工厂，然后在根据抽象工厂去实现每个派生类的工厂；

特点：支持新添加任意产品，无需改动已有代码；

具体实现：

• 产品接口：

public interface Fruit {
    void getFruitName();
}

• 产品抽象工厂：

public interface FruitFactory {
    Fruit getFruit();
}

• 产品实现：

public class Apple implements Fruit {
    @Override
    public void getFruitName() {
        System.out.println("苹果");
    }
}

public class Orange implements Fruit {
    @Override
    public void getFruitName() {
        System.out.println("橘子");
    }
}

• 单独产品工厂：

public class AppleFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

public class OrangeFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Orange();
    }
}

• 测试

public class Client {
    public static void main(String[] args) {
        //使用工厂创建对象，而不需通过new实例对象：
        Fruit fruit1 = new AppleFactory().getFruit();
        Fruit fruit2 = new OrangeFactory().getFruit();
        fruit1.getFruitName();
        fruit2.getFruitName();
    }
}

3、抽象工厂模式

简介：抽象工厂主要实现的是一类产品，一种同类型的产品；通过在抽象工厂中增加创建产品的接口，并在具体子工厂中实现新加产品的创建；

抽象工厂主要是根据产品体系来创建的：

实现图示：

具体实现：

• 创建生产体系接口：

public interface CarP {
    void buyCarName();
}

• 创建销毁体系接口：

public interface CarD {
    void destoryName();
}

• 创建抽象接口：

public interface AbstractF {
    CarD card();

    CarP carp();
}

• 实现生产体系：

public class LamborghiniP implements CarP{
    @Override
    public void buyCarName() {
        System.out.println("生产兰博基尼");
    }
}

public class PorscheP implements CarP {
    @Override
    public void buyCarName() {
        System.out.println("生产保时捷");
    }
}

• 实现销毁体系：

public class LamborghiniD implements CarD{
    @Override
    public void destoryName() {
        System.out.println("销毁兰博基尼");
    }
}

public class PorscheD implements CarD {
    @Override
    public void destoryName() {
        System.out.println("销毁保时捷");
    }
}

• 创建产品体系工厂：

public class LamborghiniF implements AbstractF {
    @Override
    public CarD card() {
        return new LamborghiniD();
    }
    @Override
    public CarP carp() {
        return new LamborghiniP();
    }
}

public class PorscheF implements AbstractF {
    @Override
    public CarD card() {
        return new PorscheD();
    }
    @Override
    public CarP carp() {
        return new PorscheP();
    }
}

• 测试

 public static void main(String[] args) {
        LamborghiniF f = new LamborghiniF();
        f.card().destoryName();
        f.carp().buyCarName();
    }