/**
* 所有工厂模式都是为了让对象的调用者和对象创建过程分离,简化调用端代码,便于维护
* 简单地对象创建则不需要使用工厂模式
*/
/**
* 简单工厂(静态工厂)
*
* 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