Java工厂模式浅谈

工厂模式的简介

工厂模式简单来说就是定义一个用于创建对象的接口，让子类决定实例化那个类。在生成复杂对象的地方，都可以使用。将大量有共同接口的类进行实例化。工厂模式突出了职责单一原则和开闭原则。一般分为三种：简单工厂，工厂方法和抽象工厂。

简单工厂示例：

/**
 * 产品的抽象类
 * 由具体的产品类实现
 */
public abstract class Fruits {
    public abstract  void  method();

}

/**
 * 具体的产品类
 */
public class Banana extends Fruits {
    @Override
    public void method() {
        System.out.println("我是香蕉");
    }
}
/**
 * 具体的产品类
 */
public class Apple extends Fruits {
    @Override
    public void method() {
        System.out.println("我是苹果");
    }
}

/**
 * 工厂类
 */
public class MyFactory {
    public static Fruits createFruit(String type) throws Exception {
        if ("A".equals(type)) {
            return new Banana();
        } else {
            return new Apple();

        }
    }}
/**
 * 测试
 */
public class MyClass {
    public static void main(String arg[]) {
        Fruits fruits = MyFactory.createFruit("B");
        fruits.method();
    }
}

简单工厂的角色：

1.抽象产品角色：对具体的产品类的抽象。是工厂模式创建角色的父类或者它们共同拥有同样的接口。
2.具体产品角色：对抽象产品的实现。
3.工厂角色：工厂模式的核心所在，用于创建产品对象。

总结

把对象的创建放到工厂类中，通过不同的参数选择不同的创建类。非常的方便，也是用到最多的方式。
缺点就是每添一个对象，就需要对工厂类进行修改。违反开闭原则。

工厂方法示例：

/**
 * 工厂的抽象类
 */
public abstract class Factory {
   public abstract  Fruits createFruit();

}
/**
 * 具体的工厂类
 */
public class BaFactory extends  Factory {
    @Override
    public Fruits createFruit() {
        return new Banana();
    }
}
public class ApFactory extends  Factory {
    @Override
    public Fruits createFruit() {
        return new Apple();
    }
}
/**
 * 测试
 */
public class MyClass {
    public static void main(String arg[]) throws Exception {
        Factory factory = new BaFactory();
        factory.createFruit().method();
        Factory afactory = new ApFactory();
        afactory.createFruit().method();


    }
}

工厂方法的角色：

1.抽象产品角色：对具体的产品类的抽象。是工厂模式创建角色的父类或者它们共同拥有同样的接口。
2.具体产品角色：对抽象产品的实现。
3.抽象工厂角色：工厂模式的核心所在，所有工厂的抽象。
4.具体工厂角色：具体工厂的创建对象，必须实现或者继承抽象工厂

总结

每种产品由一种工厂来创建，一个工厂保存一个产品的创建。符合开闭原则。

抽象工厂示例：

//抽象工厂类
public abstract class Factory {
    public abstract Vegetable createVegetable();
    public abstract Fruit createFruit();
    public abstract Noodles createNoodles();
}
//具体工厂类，其中Vegetable, Fruit，Noodles是抽象类，
public class DefaultFactory extends Factory{
    @Override
    public Fruit createFruit {
        return new Apple();
    }
    @Override
    public Vegetable createVegetable {
        return new Cabbage();
    }
    @Override
    public Noodles createNoodles() {
        return new Lamian();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Factory f = new DefaultFactory();
        Vegetable v = f.createVegetable();
        v.run();
        Fruit w = f.createFruit();
        w.shoot();
        Noodles a = f.createNoodles();
        a.printName();
    }
}

总结

其实就是工厂方法的复杂化，在一个工厂中同事创建多个类。
关于工厂方法其实还有更简单的方法，可以利用Java中的反射来完成示例如下：

/**
 * 工厂的抽象类
 */
public abstract class Factory {

   public abstract <T extends Fruits >T createFruit(Class<T> cls) throws ClassNotFoundException;

}

/**
 * 具体的工厂
 */
public class MyFactory extends  Factory{

    @Override
    public <T extends Fruits> T createFruit(Class<T> cls) {
        Fruits fruits = null;
        try {
            fruits = (Fruits) Class.forName(cls.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) fruits;

    }

}
/**
 * 测试
 */
public class MyClass {
    public  static void main(String arg[]) throws ClassNotFoundException {
      Factory factory = new MyFactory();
       Fruits  fruits =  factory.createFruit(Banana.class);
        fruits.method();
    }
}

最后的总结

三种的无论那种都是工厂模式，其最终的目的就是为了解耦而存在。在开发过程中没有必要纠结过深。根据你的业务逻辑产品需求来灵活运用，切勿生搬硬套。最终达到降低耦合度的目的即可。