java设计模式之-工厂模式

java设计模式之-工厂模式

工厂模式分为：简单工厂、工厂方法模式、抽象工厂。实际上简单工厂并不属于设计模式。但是简单工厂提出来了工厂的概念。

一、简单工厂

//咖啡的父类，所有的咖啡都要继承该类。我把他定义成抽象方法。
public abstract class Coffee {
    public abstract void creatCoffee();
}

//以下是咖啡的几个子类
public class Coffee01 extends Coffee{
    public void creatCoffee() {
        System.out.println("创建Coffee01");
    }
}


public class Coffee02 extends Coffee{
    public void creatCoffee() {
        System.out.println("创建Coffee02");
    }
}


public class Coffee03 extends Coffee{
    public void creatCoffee() {
        System.out.println("创建Coffee03");
    }
}

既然是工厂模式，那么我们还需要定义一个工厂他的作用就是实例化我们需要的类。

public class CoffeeFactory {
    
    public Coffee createCoffee(String coffee) {
        if(coffee.equals("coffee01")) {
            return new Coffee01();
        }else if(coffee.equals("coffee02")) {
            return new Coffee02();
        }else {
            return new Coffee03();
        }
    }
    
    public static void main(String[] args) {
        new CoffeeFactory().createCoffee("coffee01").creatCoffee();
    }
    
}

他是通过简单的入参判断需要实例化哪个类，写法也是比较简单，实用性也不强。

二、工厂方法模式

工厂方法模式主要是在工厂上做文章，每一个产品可以对应一个工厂，至于消费者要什么工厂由子类来确定。但是也有缺点，如果产品太多的话，那就要对应很多工厂，那么类将会异常的庞大

//工厂父类，所有工厂都需要继承该类
public abstract class CoffeeFactory {
    public abstract Coffee createFactory();
}


public class CoffeeFactory01 extends CoffeeFactory{
    @Override
    public Coffee createFactory() {
        // TODO Auto-generated method stub
        return new Coffee01();
    }
}


public class CoffeeFactory02 extends CoffeeFactory{
    @Override
    public Coffee createFactory() {
        // TODO Auto-generated method stub
        return new Coffee02();
    }
}

public class CoffeeFactory03 extends CoffeeFactory{
    @Override
    public Coffee createFactory() {
        // TODO Auto-generated method stub
        return new Coffee03();
    }
}


public class CoffeeFactory04 extends CoffeeFactory{
    @Override
    public Coffee createFactory() {
        // TODO Auto-generated method stub
        return new Coffee04();
    }
}

三、抽象工厂模式

抽象工厂是工厂方法的模式的升级版。现在是这么个情况，上边的例子不是都是生产咖啡的吗？现在呢，我想在引进茶，那你该怎么办？是修改上诉代码，还是再添加一个和上边工厂方法模式结构一样的一些类呢？不管是用哪种方法都是不利于维护以及后续拓展，于是就有了抽象工厂模式诞生，他用一个超级工厂做所有工厂的父类，那么我们后期如果有新的需求，我们可以直接添加就可以，而不用去修改以前的代码了。

public abstract class CFactory {
    public abstract Coffee createCoffee();
    public abstract Tea createTea();
}


public abstract class CoffeeFactory extends CFactory {
    public abstract Coffee createCoffee();
}
public class Coffee01Factory extends CoffeeFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee01();
    }
    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return null;
    }
}
public class Coffee02Factory extends CoffeeFactory {
    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee02();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return null;
    }
}



public abstract class TeaFactory extends CFactory {
    public abstract Tea createTea();
}
public class RedTeaFactory extends TeaFactory {
    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return new GreenTea();
    }
    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return null;
    }
}
public class GreenTeaFactory extends TeaFactory {
    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return new RedTea();
    }
    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return null;
    }
}

结构还是比较简单的，容易上手。说实在的23中设计模式我熟练的也就3种。还有20种不会的，以后有时间一定要学习一下