设计模式学习---工厂模式

一：简单工厂模式

1：使用简单工厂模式的优势

让对象的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性，可扩展性。工厂模式也有一点缺陷：当产品修改时，工厂类也要做相应的修改。

2：下面实例

小张开车去东北

这里涉及到小张是乘坐什么交通工具去东北？汽车，飞机，火车.....都可以

Car类

public class Car implements Moveable{

public void run() {
System.out.println("冒着烟奔跑中car.......");
}
}

Plane类

public class Plane implements Moveable {

@Override
public void run() {
System.out.println("扇着翅膀前进中plane....");
}

}

接口类Moveable

public interface Moveable {
void run();
}

抽象类VehicleFactory

public abstract class VehicleFactory {
abstract Moveable create();
}

CarFactory类

public class CarFactory extends VehicleFactory{
public Moveable create() {
return new Car();
}
}

PlaneFactory类

public class PlaneFactory extends VehicleFactory{
public Moveable create() {
return new Plane();
}
}

测试类

public class Test {
public static void main(String[] args) {

VehicleFactory factory = new CarFactory();
Moveable m = factory.create();

m.run();
}
}

3：下图是类图之间的关系



此时如要换一种方式去东北，只需要按照上图给2个接口都添加实现即可。

由此我们可以想象，如果工厂中要产生大量的产品系列，那样的话，就需要各种添加大量的实现，容易造成工厂泛滥。

二：抽象工厂模式

1：定义及原因：

因为使用简单工厂模式，使得客户端代码成功地与被调用对象的实现类分离，但却带来了另外一种耦合：客户端代码与不同的工厂类耦合，这依然是一个问题。

我们考虑在增加一个工厂类，该类不生产具体的Vehicle类，而是生产VehicleFactory实例------简而言之，该类不制造具体的被调用对象，而是制造不同的工厂对象。这就是抽象工厂模式。

2：如下实例：

抽象工厂类：制造不同的工厂对象

public abstract class AbstractFactory {
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();

}

MagicFactory类：创建系列与魔法有关的食物，交通工具，武器对象

public class MagicFactory extends AbstractFactory {

@Override
public Food createFood() {
return new MushRoom();
}

@Override
public Vehicle createVehicle() {
return new Broom();
}

@Override
public Weapon createWeapon() {
return new MagicStick();
}

}

DefaultFactory类：创建默认类型的食物，交通工具，武器对象

public class DefaultFactory extends AbstractFactory{

@Override
public Food createFood() {
return new Apple();
}

@Override
public Vehicle createVehicle() {
return new Car();
}

@Override
public Weapon createWeapon() {
return new AK47();
}

}

Food类：生产Food

public abstract class Food {
public abstract void printName();
}

继承Food的两个类

Apple类

public class Apple extends Food {
public void printName() {
System.out.println("apple");
}
}

MushRoom类

public class MushRoom extends Food {

@Override
public void printName() {
System.out.println("mushroom");
}

}

Vehicle类

public abstract class Vehicle {
public abstract void run();
}

继承Vehicle类的两个类

Car类

public class Car extends Vehicle {

public void run() {
System.out.println("冒着烟奔跑中car.......");
}
}

Broom类

public class Broom  extends Vehicle{

public void run() {
System.out.println("一路沙尘暴飞奔而来broom.....");
}

}

Weapon类

public abstract class Weapon {
public abstract void shoot();
}

继承Weapon类的两个类

AK47类

public class AK47 extends Weapon{
public void shoot() {
System.out.println("哒哒哒...");
}
}

MagicStick类

public class MagicStick extends Weapon {

@Override
public void shoot() {
System.out.println("fire hu hu hu ...");
}

}

3：下面是类图关系



可以用配置文件配置，具体用法原来已经讲过；

冒着烟奔跑中car.......
哒哒哒...
apple

在抽象工厂模式中，如要产生大量产品品种对象，容易泛滥。