设计模式-------工厂模式

一、简单工厂

它由三种角色组成：
    工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。如例子中的FruitFatory类。
    抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Iproduce接口。
    具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现，如例子中的Apple、Orange类。

下面以生产水果为例讲解

首先定义一个共同的生产接口

public interface Iproduce {
    void produce();
}

然后具体的水果 生产实现共同的生产接口，如苹果的生产，橘子的生产等，如下：

public class Apple implements Iproduce {
     public void produce(){
       System.out.print("生产苹果");
    }
}


public class Orange implements Iproduce {
    public void produce(){
        System.out.print("生产橘子");
    }
}

接着我们定义一个水果工厂，用来生产需要的水果

public class FruitFactroy {
    public Iproduce getProduce(String fruitName){
        if("apple".equals(fruitName)){
            return new Apple();
        }
        if("orange".equals(fruitName)){
            return new Orange();
        }
        return null;
    }
}

下面是客户端的实现

public class Customer {
    public static void main(String[] args){
        FruitFactroy fruitFactroy = new FruitFactroy();
        Iproduce produce = fruitFactroy.getProduce("apple");//传入想要生产的水果
        produce.produce();//生产苹果
    }

}

二、工厂方法

      抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
      具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
      抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
      具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

方法工厂与简单工厂的不同是把水果工厂抽象成接口，并定义了一个生产方法。具体的水果生产工厂类实现水果的工厂接口

定义工厂接口

public interface IFactroy {
    Iproduce create();
}

具体的实现工厂类

public class AppleFactroy implements IFactroy {//苹果实现类
    public Iproduce create(){
        return new Apple();
                
    }
}
public class OrangeFactroy implements IFactroy {//橘子实现类
    public Iproduce create(){
        return new Orange();
    }
}

客户端实现

public class Customer {
    public static void main(String[] args){
        IFactroy fruitFactroy = new AppleFactroy();
        Iproduce produce = fruitFactroy.create();
        produce.produce();
    }
}

      
     有人可能觉得工厂方法的形式还不如简单工厂来的好，工厂方法进行扩展生产水果种类的的时候还要去改客户端。这不是不但没有减少难度，还增加了很多类和方法，为什么要这样呢？
      简单工厂进行产品扩展的时候，比如说工厂又想生产香蕉了（我最喜欢吃香蕉了，哈哈），简单工厂只能在FruitFactroy工厂类中添加香蕉的分支，违背了开放--封闭原则。但是如果使用方法工厂，只需要再建一个香蕉的工厂类实现IFactory接口就好了，并不需要修改内部的代码，遵循了开放---封闭原则。






三、抽象工厂
      提供了一个创建一系列相关或相互依赖对象的接口，而无需指定其具体的类。《大话设计模式》
      它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：
1.系统中有多个产品族，而系统一次只可能消费其中一族产品
2.同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
      抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
     具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
     抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
     具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
     现在好了，由于业务的扩展，引入了新的水果产品，Apple引入了苹果汁和苹果沙拉两个品种，Orange引入了橘子汁和橘子沙拉两个品种

public class AppleJuice extends Apple {
    @Override
    public void produce() {
        System.out.print("生产苹果汁");
    }
}


public class AppleSala extends Apple {
    @Override
    public void produce() {
        System.out.print("生产苹果沙拉");
    }
}






public class OrangeJuice extends Orange {
    @Override
    public void produce() {
        System.out.print("生产橘子汁");
    }
}
public class OrangeSala extends Orange {
    @Override
    public void produce() {
        System.out.print("生产橘子沙拉");
    }
}

抽象工厂

public interface IFactroy {
    Apple createApple();
    Orange createOrange();
}

具体工厂

public class JuiceFactory implements IFactroy{
    @Override
    public Apple createApple() {
        return new AppleJuice();
    }


    @Override
    public Orange createOrange() {
        return new OrangeJuice();
    }
}
public class SalaFactory implements IFactroy{
    @Override
    public Apple createApple() {
        return new AppleSala();
    }


    @Override
    public Orange createOrange() {
        return new OrangeSala();
    }
}

客户端

public class Customer {
    public static void main(String[] args){
        Apple apple = new JuiceFactory().createApple();
        apple.produce();


    }
}