【SSM】Spring6（三.工厂模式）
文章目录
- 1.简单工厂模式（静态工厂方法模式）
-
- 1.1 案例
- 1.2 优缺点
- 2. 工厂方法模式
-
- 2.1 案例
- 2.2 优缺点
- 3.抽象工厂模式
1.简单工厂模式（静态工厂方法模式）
1.1 案例
属于工厂方法模式一种特殊的。
包括
- 抽象产品
- 具体产品
- 工厂类
package com.sdnu.simple.factory;
/**
* 抽象产品角色
*/
public abstract class Weapon {
/**
* 所以武器都可以攻击
*/
public abstract void attack();
}
坦克
package com.sdnu.simple.factory;
/**
* 具体产品角色
*/
public class Tank extends Weapon{
@Override
public void attack() {
System.out.println("坦克开炮");
}
}
战斗机
package com.sdnu.simple.factory;
/**
* 具体产品角色
*/
public class Fighter extends Weapon{
@Override
public void attack() {
System.out.println("战斗机扔下炸弹");
}
}
匕首
package com.sdnu.simple.factory;
public class Dagger extends Weapon{
@Override
public void attack() {
System.out.println("匕首sa");
}
}
工厂类
package com.sdnu.simple.factory;
/**
* 工厂类
*/
public class WeaponFactory {
/**
* 静态方法
* @param weaponType
* @return
*/
public static Weapon get(String weaponType){
if ("TANK".equals(weaponType)) {
return new Tank();
} else if ("Dagger".equals(weaponType)){
return new Dagger();
} else if ("Fighter".equals(weaponType)) {
return new Fighter();
} else {
throw new RuntimeException("不支持该武器类生产");
}
}
}
测试
package com.sdnu.simple.factory;
/**
* 测试，消费端
*/
public class Test {
public static void main(String[] args) {
//需要坦克
Weapon tank = WeaponFactory.get("TANK");
tank.attack();
//需要战斗机
Weapon fighter = WeaponFactory.get("Fighter");
fighter.attack();
//需要匕首
Weapon dagger = WeaponFactory.get("Dagger");
dagger.attack();
}
}
1.2 优缺点
优点：
- 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。
缺点：
- 工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
- 不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。
2. 工厂方法模式
2.1 案例
包括
- 抽象产品
- 具体产品
- 抽象工厂
- 具体工厂
抽象产品
package com.sdnu.factory.method;
/**
* 抽象产品角色
*/
public abstract class Weapon {
/**
* 所以武器都可以攻击
*/
public abstract void attack();
}
具体产品
package com.sdnu.factory.method;
public class Dagger extends Weapon{
@Override
public void attack() {
System.out.println("匕首sa");
}
}
package com.sdnu.factory.method;
/**
* 具体产品角色
*/
public class Fighter extends Weapon{
@Override
public void attack() {
System.out.println("战斗机扔下炸弹");
}
}
package com.sdnu.factory.method;
/**
* 具体产品角色
*/
public class Tank extends Weapon{
@Override
public void attack() {
System.out.println("坦克开炮");
}
}
抽象工厂
package com.sdnu.factory.method;
/**
* 抽象工厂
*/
public abstract class WeaponFactory {
//实例方法
public abstract Weapon get();
}
具体工厂
package com.sdnu.factory.method;
/**
* 具体工厂
*/
public class DaggerFactory extends WeaponFactory{
@Override
public Weapon get() {
return new Dagger();
}
}
package com.sdnu.factory.method;
/**
* 具体工厂
*/
public class FighterFactory extends WeaponFactory{
@Override
public Weapon get() {
return new Fighter();
}
}
package com.sdnu.factory.method;
/**
* 具体工厂
*/
public class TankFactory extends WeaponFactory{
@Override
public Weapon get() {
return new Tank();
}
}
测试
package com.sdnu.factory.method;
public class Test {
public static void main(String[] args) {
DaggerFactory daggerFactory = new DaggerFactory();
Weapon dagger = daggerFactory.get();
dagger.attack();
TankFactory tankFactory = new TankFactory();
Weapon tank = tankFactory.get();
tank.attack();
}
}
2.2 优缺点
-
优点
● 一个调用者想创建一个对象，只要知道其名称就可以了。
● 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
● 屏蔽产品的具体实现，调用者只关心产品的接口。 -
缺点
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。