设计模式_工厂模式学习笔记

简单工厂模式

public class Test {
    public static void main(String[] args) {
        Factory factory = new Factory();
        MyProduct product = factory.create("ProductA");
        System.out.println(product);
    }
}
interface MyProduct{
    void doSomething();
}
class ProductA implements  MyProduct{

    @Override
    public void doSomething() {
        System.out.println("product A");
    }
}
class ProductB implements  MyProduct{

    @Override
    public void doSomething() {
        System.out.println("product B");
    }
}

class Factory{
    public Factory(){}
    public MyProduct create(String name){
        if(name.equals("ProductA")){
            return new ProductA();
        }else{
            return new ProductB();
        }
    }
}

上面的代码就是简单工厂模式，但是如果我们想要增加一个ProductC的话，需要改动Factory类的create方法，这样不符合设计模式的开闭原则，我们可以使用java的反射来解决这个问题

public class Test {
    public static void main(String[] args) {
        Factory factory = new Factory();
        MyProduct product = factory.create(ProductA.class);
        System.out.println(product);
    }
}
interface MyProduct{
    void doSomething();
}
class ProductA implements  MyProduct{

    @Override
    public void doSomething() {
        System.out.println("product A");
    }
}
class ProductB implements  MyProduct{

    @Override
    public void doSomething() {
        System.out.println("product B");
    }
}

class Factory {
    public Factory() {}

    public MyProduct create(Class<? extends MyProduct> clazz) {
        if (clazz != null) {
            try {
                return clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

工厂方法模式

工厂方法模式（Factory Method Pattern）又叫作多态性工厂模式，指定义一个创建对象的接口，但由实现这个接口的类来决定实例化哪个类，工厂方法把类的实例化推迟到子类中进行。
也就是说，工厂方法模式中，不在由工厂类生产对应的产品，而是由工厂类的子类实现具体产品的生产逻辑，解决简单工厂中switch case的臃肿，也符合开闭原则。

public class Test {
    public static void main(String[] args) {
        IFactory factory = new FactoryA();
        IProduct product = factory.create();
        System.out.println(product);
    }
}
interface IProduct{
    public void doSomething();
}
interface IFactory{
    public IProduct create();
}
//A工厂
class FactoryA implements IFactory{

    @Override
    public IProduct create() {
        return new ProductA();
    }
}
//B工厂
class FactoryB implements IFactory{

    @Override
    public IProduct create() {
        return new ProductB();
    }
}
//A产品
class ProductA implements IProduct{

    @Override
    public void doSomething() {
        System.out.println("product A");
    }
}
//B产品
class ProductB implements IProduct{

    @Override
    public void doSomething() {
        System.out.println("product B");
    }
}

抽象工厂模式

一个具体的工厂里可以生产专属于这个工厂的东西，例如华为工厂可以生产华为手机和华为电脑；工厂方法模式中一个工厂只能生产一个产品，而抽象工厂模式中一个工厂可以生产一组产品

public class Test {
    public static void main(String[] args) {
        //创建华为工厂
        IFactory factory = new Factory1();
        //在华为工厂里创建华为手机
        IProductA productA = factory.createProductA();
        productA.doA();
    }
}
//手机产品
interface IProductA{
    public void doA();
}
//电脑产品
interface IProductB{
    public void doB();
}
interface IFactory{
    public IProductA createProductA();
    public IProductB createProductB();
}
//华为工厂
class Factory1 implements IFactory{
    //华为手机
    @Override
    public IProductA createProductA() {
        return new ProductA1();
    }
    //华为电脑
    @Override
    public IProductB createProductB() {
        return new ProductB1();
    }
}
//苹果工厂
class Factory2 implements IFactory{
    //苹果手机
    @Override
    public IProductA createProductA() {
        return new ProductA2();
    }
    //苹果电脑
    @Override
    public IProductB createProductB() {
        return new ProductB2();
    }

}

class ProductA1 implements IProductA{

    @Override
    public void doA() {
        System.out.println("我是华为手机");
    }
}
class ProductA2 implements IProductA{

    @Override
    public void doA() {
        System.out.println("我是苹果手机");
    }
}
class ProductB1 implements IProductB{

    @Override
    public void doB() {
        System.out.println("我是华为电脑");
    }
}
class ProductB2 implements IProductB{

    @Override
    public void doB() {
        System.out.println("我是苹果电脑");
    }
}