Java中常见的设计模式之工厂设计模式

工厂设计模式

     工厂模式：工厂模式就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类（动态实例化）。
     工厂模式可以简单分为：简单工厂模式，工厂方法模式，抽象工厂模式。
1、简单工厂模式
      简单工厂模式又叫静态工厂，是三个里面最简单的。主要有一个静态方法，用来接收参数，并且根据参数来决定返回实现同一接口不同类的实例。
     java例子：
     interface Fruit{
          public void eat();
     }
     class Apple implements Fruit{
          public void eat(){
               System.out.println("Apple");
          }
     }
     class Orange implements Fruit{
          public void eat(){
               System.out.println("Orange");
          }
     }
     class Banana implements Fruit{
          public void eat(){
               System.out.println("Banana");
          }
     }
     class Factory{
          public static Fruit getInstance(String str){
               Fruit f = null;
               if("Apple".equals(str)){
                    f = new Apple();
               }else if("Orange".equals(str)){
                    f = new Orange();
               }else{
                    f = new Banana();
               }
               return f;
          }
     }
     public class FactoryDemo{
          public static void main(String[]args){
               Fruit f = null;
               f = Factory.getInstance("Apple");
               f.eat();
          }
     }
     简单工厂模式的核心就是Factory类，该类拥有必要的逻辑判断和所有产品的创建权利。只需要把需要的信息给Factory类的方法，就可以获得对应的实例。
     简单工厂模式的不足：每当需要增加新的产品时，都需要修改Factory的源码，当个各类之间有很强的逻辑关系式时，Factory必须有很强的判断能力，代码量将不断激增。另外整个系统严重依赖Factory，一旦Factory出现问题，整个系统将无法正常使用。
2、工厂方法模式
工厂方法模式为工厂类定义了接口，用多态来削弱工厂的职能。 
    interface Fruit{
          public void eat();
     }
     interface Factory{
          public Fruit createFruit();
     }
     class Apple implements Fruit{
          public void eat(){
               System.out.println("Apple");
          }
     }
     class Orange implements Fruit{
          public void eat(){
               System.out.println("Orange");
          }
     }
     class Banana implements Fruit{
          public void eat(){
               System.out.println("Banana");
          }
     }
     class AppleFactory implements Factory{
          public Apple createFruit(){
               return new Apple();
          }
     }
     class OrangeFactory implements Factory{
          public Orange createFruit(){
               return new Orange();
          }
     }
     class BananaFactory implements Factory{
          public Banana createFruit(){
               return new Banana();
          }
     }
     public class FactoryDemo{
          public static void main(String[]args){
               AppleFactory af = new AppleFactory();
               Apple ap = af.createFruit();
               ap.eat();
          }
     }
     工厂方法和简单工厂的主要区别是：简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品实现放在实现了工厂接口的不同工厂类里面。但是工厂方法也会面临多个对象的问题，成千上百的产品，就要有成千上百的工厂类。


3、抽象工厂模式
抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。
    interface Fruit{
        public void eat();
    }
    interface Vegetables{
        public void eatV();
    }
    interface Factory{
        public Fruit createFruit();
        public Vegetables createVegetable();
    }
    class Apple implements Fruit{
        public void eat(){
            System.out.println("Apple");
        }
    }
    class Orange implements Fruit{
        public void eat(){
            System.out.println("Orange");
        }
    }
    class Banana implements Fruit{
        public void eat(){
            System.out.println("Banana");
        }
    }
    class Cucumber implements Vegetables{
        public void eatV(){
            System.out.println("Cucumber");
        }
    }
    class Tomato implements Vegetables{
        public void eatV(){
            System.out.println("Tomato");
        }
    }
    class AppleFactory implements Factory{
        public Apple createFruit(){
            return new Apple();
        }
        public Tomato createVegetable(){
            return new Tomato();
        }
    }
    class OrangeFactory implements Factory{
        public Orange createFruit(){
            return new Orange();
        }
        public Cucumber createVegetable(){
            return new Cucumber();
        }
    }
    
    public class FactoryDemo{
        public static void main(String[]args){
            AppleFactory af = new AppleFactory();
            Apple ap = af.createFruit();
            Tomato to = af.createVegetable();
            ap.eat();
            to.eatV();
        }
    }
     工厂方法和抽象工厂，都有自己的应用场景，并没有什么优劣之分，但在应用抽象工厂之前，要先对创建的对象进行系统的分类，这点很重要，好的产品分类规则能为具体工厂类的选择调用和以后的扩展提供清晰的思路。