Java设计模式——工厂模式
简单工厂模式(Simple Factory Pattern):
它是为了让程序有一个更好地封装,降低程序模块之间的耦合程度。对于简单的工厂模式,其实也可以将其理解成为一个创建对象的工具类:
java code:
public class SimpleFactory {
public Object create(Class<?> clazz) {
if (clazz.getName().equals(Plane.class.getName())) {
return createPlane();
} else if (clazz.getName().equals(Broom.class.getName())) {
return createBroom();
}
return null;
}
private Broom createBroom() {
return new Broom();
}
private Plane createPlane() {
return new Plane();
}
}
test code:
public class FactoryTest {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Broom broom = (Broom) simpleFactory.create(Broom.class);
broom.run();
}
}
工厂方法模式(Factory Method Pattern):
工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化哪一个
java code:
/*抽象工厂:*/
public abstract class VehicleFactory {
public abstract Moveable create();
}
/*具体工厂:*/
public class BroomFactory extends VehicleFactory {
@Override
public Moveable create() {
return new Broom();
}
}
/*抽象产品接口:*/
public interface Moveable {
public void run();
}
/*具体产品:*/
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("Broom function");
}
}
test code:
VehicleFactory factory = new BroomFactory();
Moveable moveable = factory.create();
moveable.run();
抽象工厂模式(Abstract Factory Pattern):
java code:
/*抽象工厂:*/
public abstract class AbstractFactory {
public abstract Flyable createFlyable();
public abstract Moveable createMoveable();
public abstract Writeable createWriteable();
}
/*具体工厂:*/
public class Factory1 extends AbstractFactory {
@Override
public Flyable createFlyable() {
return new Aircraft();
}
@Override
public Moveable createMoveable() {
return new Car();
}
@Override
public Writeable createWriteable() {
return new Pen();
}
}
/*抽象产品接口:*/
public interface Flyable {
public void fly(int i);
}
public interface Moveable {
public void move(int i);
}
public interface Writeable {
public void write(String i);
}
public class Aircraft implements Flyable {
@Override
public void fly(int i) {
System.out.println("fly"+i);
}
}
public class Car implements Moveable {
@Override
public void move(int i) {
System.out.println("move"+i);
}
}
public class Pen implements Writeable {
@Override
public void write(String i) {
System.out.println("write"+i);
}
}
test code:
public class FactoryTest {
public static void main(String[] args) {
AbstractFactory factory = new Factory1();
Flyable flyable = factory.createFlyable();
flyable.fly(150);
Moveable moveable = factory.createMoveable();
moveable.move(10);
Writeable writeable = factory.createWriteable();
writeable.write("Hello");
}
}