工厂模式：实现了创建者与调用者的分离

工厂模式实现了创建者和调用者的分离；
工厂模式分为三种模式：简单工厂模式、工厂方法模式、抽象工厂模式；
工厂模式中的核心角色：

简单工厂模式

简单工厂模式，将创建对象的逻辑封装到工厂类的方法中，根据参数返回对应类型的对象。
缺点：新增产品时需要修改原有代码，在工厂类方法中添加判断逻辑，违背了开闭法则

产品

public abstract class Phone {
    public abstract void photo();
}

public class APhone extends Phone {
    @Override
    public void photo() {
        System.out.println("a家的手机拍照照~");
    }
}

public class BPhone extends Phone{
    @Override
    public void photo() {
        System.out.println("b家的手机拍照照~");
    }
}

public class CPhone extends Phone{
    @Override
    public void photo() {
        System.out.println("c家的手机拍照照~");
    }
}

工厂

public class PhoneFactory {
    public Phone createPhone(String phoneType){
        if ("a".equals(phoneType)) {
            return new APhone();
        } else if ("b".equals(phoneType)){
            return new BPhone();
        } else if ("c".equals(phoneType)) {
            return new CPhone();
        }
        return null;
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        System.out.println("简单工厂模式：");
        usePhoto("a");
    }
    static void usePhoto(String photoType){
        PhoneFactory factory = new PhoneFactory();
        Phone phone = factory.createPhone(photoType);
        phone.photo();
    }
 }

控制台

工厂方法模式

工厂方法模式，抽象出工厂类提供创建对象的接口，由子工厂类去实现。即将具体产品对象的创建交由子工厂类来创建。
缺点：新增产品时需要新增一个生产该产品的子工厂类，导致系统中类的个数增加
优点：新增产品时不需要修改工厂类，只需要新增生产该产品的子工厂类，使得工厂类符合开闭原则

产品同上
工厂

public abstract class Factory {
    public abstract Phone createPhone();
}

public class AFactory extends Factory {
    @Override
    public Phone createPhone() {
        return new APhone();
    }
}

public class BFactory extends Factory{
    @Override
    public Phone createPhone() {
        return new BPhone();
    }
}

public class CFactory extends Factory{
    @Override
    public Phone createPhone() {
        return new CPhone();
    }
}

客户端

public class Client {
    public static void main(String[] args) {
        System.out.println("工厂方法模式：");
        usePhoto2(new AFactory());
    }
    static void usePhoto2(Factory factory){
        Phone phone = factory.createPhone();
        phone.photo();
    }
}

控制台

抽象工厂模式

抽象方法模式，生产一组有关联的产品，在工厂方法模式的基础上新增多个创建产品的方法。
缺点：同工厂方法模式一样，新增产品时增加一个创建该产品的子工厂类

产品1如上
新增产品2

public abstract class Computer {
    public abstract void game();
}

public class AComputer extends Computer {
    @Override
    public void game() {
        System.out.println("a家的电脑打游戏~");
    }
}

public class BComputer extends Computer {
    @Override
    public void game() {
        System.out.println("b家的电脑打游戏~");
    }
}

public class CComputer extends Computer {
    @Override
    public void game() {
        System.out.println("c家的电脑打游戏~");
    }
}

工厂
在工厂方法的基础上新加一个创建新产品的方法

public abstract class Factory {
    public abstract Phone createPhone();

    public abstract Computer createComputer();
}

public class AFactory extends Factory {
    @Override
    public Phone createPhone() {
        return new APhone();
    }

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

public class BFactory extends Factory {
    @Override
    public Phone createPhone() {
        return new BPhone();
    }

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

public class CFactory extends Factory {
    @Override
    public Phone createPhone() {
        return new CPhone();
    }

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

客户端

public class Client {
    public static void main(String[] args) {
        System.out.println("抽象工厂模式：");
        usePhotoAndComputer(new factory.abstractFactory.AFactory());
    }
    static void usePhotoAndComputer(factory.abstractFactory.Factory factory){
        Phone phone = factory.createPhone();
        phone.photo();
        Computer computer = factory.createComputer();
        computer.game();
    }
}

控制台