[初级]设计模式--工厂模式

/**
 * 所有工厂模式都是为了让对象的调用者和对象创建过程分离，简化调用端代码，便于维护
 * 简单地对象创建则不需要使用工厂模式
 */

/**
 * 简单工厂(静态工厂)
 * 
 * 	1、创建产品接口
 * 	2、创建工厂类
 * 	3、工厂类通过传入参数的不同返回不同的产品
 * 
 * 优点：
 * 	1、代码调用简单，类之间的关系也较简单
 * 缺点：
 * 	1、拓展性稍差，如果需要增加新的产品，则需要修改已有代码(工厂类)，不符合开闭原则(可扩展、禁修改)
 */
public class SimpleFactroy {
	public static void main(String[] args) {
		ArsenalFactory.getArms("AK47").attack();
		ArsenalFactory.getArms("喀秋莎").attack();
		ArsenalFactory.getArms("如意金箍棒").attack();
	}
}

/**
 * 工厂类，通过该类获取产品实例
 */
class ArsenalFactory{
	public static IArm getArms(String name){
		if("AK47".equals(name)){
			return new AK47();
		}else if("喀秋莎".equals(name)){
			return new Katyusha();
		}else if("如意金箍棒".equals(name)){
			return new MonkeyKingBar();
		}else{
			return null;
		}
	}
}
/**
 * 产品接口
 */
interface IArm{
	public void attack();
}
/**
 * 以下为具体产品
 */
class AK47 implements IArm{
	@Override
	public void attack() {
		System.out.println("AK47 突突突");
	}
}
class Katyusha implements IArm{
	@Override
	public void attack() {
		System.out.println("喀秋莎 嗖嗖嗖");
	}
}
class MonkeyKingBar implements IArm{
	@Override
	public void attack() {
		System.out.println("妖怪 看棒");
	}
}

/**
 * 工厂方法
 * 
 * 	1、定义产品接口
 * 	2、定义工厂抽象类
 * 	3、通过工厂创建具体产品
 * 
 * 优点：
 * 	1、方便对产品进行更换
 * 	2、方便增加新的产品
 * 缺点：
 * 	1、产品多了类就会多 [一个产品=一个产品类+一个产品类工厂](类爆炸)
 * 	2、产品接口 修改后其他实现类都要改
 */
public class FactoryMethod {
	public static void main(String[] args) {
//		VehicleFactory v = new PlaneFactory();
		VehicleFactory v = new CarFactory();
		v.create().run();
	}
}
/**
 * 产品接口
 */
interface IMoveable{
	public void run();
}
/**
 * 工厂抽象类
 */
abstract class VehicleFactory{
	abstract IMoveable create();
}

/**
 * 以下为具体产品及相应工厂
 */
class Plane implements IMoveable{
	@Override
	public void run() {
		System.out.println("大飞机 呼呼呼");
	}
}
class PlaneFactory extends VehicleFactory{
	public IMoveable create(){
		return new Plane();
	}
}
class Car implements IMoveable{
	@Override
	public void run() {
		System.out.println("小汽车 嘀嘀嘀");
	}
}
class CarFactory extends VehicleFactory{
	public IMoveable create(){
		return new Car();
	}
}

抽象工厂start

/**
 * 抽象工厂类
 */
public abstract class AbstractFactory {
	public abstract Weapon createWeapon();
	public abstract Vehicle createVehicle();
	public abstract Food createFood();
}
/**
 * 抽象工厂对应的抽象产品类
 */
abstract class Weapon{
	public abstract void fire();
}
abstract class Vehicle{
	public abstract void run();
}
abstract class Food{
	public abstract void eat();
}

/**
 * 产品系列1
 */
public class DefaultFactory extends AbstractFactory{
	@Override
	public Weapon createWeapon() {
		return new AK47();
	}
	@Override
	public Vehicle createVehicle() {
		return new Tank();
	}
	@Override
	public Food createFood() {
		return new Beef();
	}
}

class AK47 extends Weapon{
	@Override
	public void fire() {
		System.out.println("AK47 嗒嗒嗒");
	}
}
class Tank extends Vehicle{
	@Override
	public void run() {
		System.out.println("坦克 咕隆隆");
	}
}
class Beef extends Food{
	@Override
	public void eat() {
		System.out.println("吃牛肉");
	}
}

/**
 * 产品系列2
 */
public class MagicFactory extends AbstractFactory{
	@Override
	public Weapon createWeapon() {
		return new MagicStick();
	}
	@Override
	public Vehicle createVehicle() {
		return new MagicBroom();
	}
	@Override
	public Food createFood() {
		return new MagicBread();
	}
}
class MagicStick extends Weapon{
	@Override
	public void fire() {
		System.out.println("魔法棒 变");
	}
}
class MagicBroom extends Vehicle{
	@Override
	public void run() {
		System.out.println("魔法扫帚 飞");
	}
}
class MagicBread extends Food{
	@Override
	public void eat() {
		System.out.println("魔法面包 呃");
	}
}

/**
 * 抽象工厂
 * 	主要解决 产品系列 的功能
 * 
 * 	1、定义 产品系列工厂 抽象类
 * 	2、定义每个产品的抽象类
 * 	3、定义具体产品、具体产品工厂
 * 
 * 	AbstractFactory --> 定义产品的标准(方法)
 * 	DefaultFactory、MagicFactory.... --> 实现具体的产品(方法)
 * 
 * 优点：
 * 	1、方便对产品系列进行增加、替换
 * 缺点：
 * 	1、新增产品的话，每个工厂实现都要改
 */
public class Client {
	public static void main(String[] args) {
//		AbstractFactory f = new DefaultFactory();
		AbstractFactory f = new MagicFactory();
		f.createWeapon().fire();
		f.createVehicle().run();
		f.createFood().eat();
	}
}

 抽象工厂end