Java设计模式 《工厂模式》

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");
}
}