工厂模式的简介
工厂模式简单来说就是定义一个用于创建对象的接口,让子类决定实例化那个类。在生成复杂对象的地方,都可以使用。将大量有共同接口的类进行实例化。工厂模式突出了职责单一原则和开闭原则。一般分为三种:简单工厂,工厂方法和抽象工厂。
简单工厂示例:
/**
* 产品的抽象类
* 由具体的产品类实现
*/
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();
}
}
最后的总结
三种的无论那种都是工厂模式,其最终的目的就是为了解耦而存在。在开发过程中没有必要纠结过深。根据你的业务逻辑产品需求来灵活运用,切勿生搬硬套。最终达到降低耦合度的目的即可。