实现了创建者和调用者的分离。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 实例化对象,用工厂方法代替new操作。
教你区别内聚与耦合
项目 | Value |
---|---|
OCP(开闭原则,Open-Closed Principle) | 一个软件的实体应当对扩展开放,对修改关闭。 |
DIP(依赖倒转原则,Dependence Inversion Principle) | 要针对接口编程, 不要针对实现编程。 |
LoD(迪米特法则,Law of Demeter ) | 只与你直接的朋友通信,而避免和 陌生人通信。 |
用来生产同一等级结构中的任意产品。(对于增加新的产品,需要修改已有代码 )
基础类
package ah.szxy.simplefactory;
public interface car {
void run();
}
package ah.szxy.simplefactory;
public class BenChi implements car{
@Override
public void run() {
System.out.println("奔驰在跑");
}
}
package ah.szxy.simplefactory;
public class BaoMa implements car{
@Override
public void run() {
System.out.println("宝马在跑");
}
}
工厂类以及测试类
package ah.szxy.simplefactory;
/**
* 简单工厂模式一
* @author chy
*
*/
public class CarFactory {
public static car createCar(String type) {
if ("BaoMa".equals(type)) {
return new BaoMa();
}else if ("BenChi".equals(type)) {
return new BenChi();
}else {
return null;
}
}
}
package ah.szxy.simplefactory;
/**
* 简单工厂模式二
* @author chy
*
*/
public class CarFactory2 {
public static car createBenChi() {
return new BenChi();
}
public static car createBaoMa() {
return new BaoMa();
}
}
package ah.szxy.simplefactory;
/**
* 测试简单工厂模式
* @author chy
*
*/
public class Client2 {
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
//car bc = carFactory.createCar("BenChi");
//car bm = carFactory.createCar("BaoMa");
car bm = CarFactory2.createBaoMa();
car bc = CarFactory2.createBenChi();
bc.run();
bm.run();
}
}
uml图
为了避免简单工厂模式的缺点,不完全满足OCP。 工厂方法模式和简单工厂模式最大的不同在于,简单工厂模式只有一个(对于一个项目 或者一个独立模块而言)工厂类,而工厂方法模式有一组实现了相同接口的工厂类。
package ah.szxy.simplefactory;
public interface car {
void run();
}
package ah.szxy.simplefactory;
public class BenChi implements car{
@Override
public void run() {
System.out.println("奔驰在跑");
}
}
package ah.szxy.simplefactory;
public class BaoMa implements car{
@Override
public void run() {
System.out.println("宝马在跑");
}
}
package ah.szxy.factorymethod;
public interface Factory {
public Car createCar();
}
package ah.szxy.factorymethod;
public class BenChiFactory implements Factory{
@Override
public Car createCar() {
return new BenChi();
}
}
package ah.szxy.factorymethod;
public class BaoMaFactory implements Factory{
@Override
public Car createCar() {
return new BaoMa();
}
}
package ah.szxy.factorymethod;
/**
* 测试工厂方法模式
* @author 曹海洋
*
*/
public class Client{
public static void main(String[] args) {
Car bc = new BenChiFactory().createCar();
Car bm = new BaoMaFactory().createCar();
bc.run();
bm.run();
}
}
测试结果
uml图
根据设计理论建议:工厂方法模式。但实际上,我们一般都用简单工厂模式
用来生产不同产品族的全部产品。(对于增加新的产品,无能为力; 支持增加产品族) 抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务 分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
package ah.szxy.abstractfactory;
/**
* 引擎
* @author chy
*
*/
public interface Engine {
void run();
}
class luxuryEngine implements Engine{
@Override
public void run() {
System.out.println("跑的快");
}
}
class lowEngine implements Engine{
@Override
public void run() {
System.out.println("跑的慢");
}
}
package ah.szxy.abstractfactory;
/**
* 座位
* @author chy
*
*/
public interface Seat {
void feel();
}
class luxurySeat implements Seat{
@Override
public void feel() {
System.out.println("坐着爽");
}
}
class lowSeat implements Seat{
@Override
public void feel() {
System.out.println("坐着不爽");
}
}
package ah.szxy.abstractfactory;
/**
* 轮胎
* @author chy
*
*/
public interface Tyre {
void moSun();
}
class luxuryTyre implements Tyre{
@Override
public void moSun() {
System.out.println("耐磨损");
}
}
class lowTyre implements Tyre{
@Override
public void moSun() {
System.out.println("不耐磨损");
}
}
package ah.szxy.abstractfactory;
public interface CarFactory {
Engine engine();
Seat seat();
Tyre tyre();
}
package ah.szxy.abstractfactory;
public class lowCar implements CarFactory{
@Override
public Engine engine() {
return new lowEngine();
}
@Override
public Seat seat() {
return new lowSeat();
}
@Override
public Tyre tyre() {
return new lowTyre();
}
}
package ah.szxy.abstractfactory;
public class LuxuryCar implements CarFactory {
@Override
public Engine engine() {
return new luxuryEngine();
}
@Override
public Seat seat() {
return new luxurySeat();
}
@Override
public Tyre tyre() {
return new luxuryTyre() ;
}
}
package ah.szxy.abstractfactory;
/**
* 测试抽象方法模式
* @author chy
*
*/
public class Client {
public static void main(String[] args) {
CarFactory luxuryCar = new LuxuryCar();
CarFactory lowCar = new lowCar();
luxuryCar.engine().run();
lowCar.engine().run();
}
}
运行结果
uml类图
分类 | 区别 |
---|---|
简单工厂模式(静态工厂模式) | 虽然某种程度不符合设计原则,但实际使用最多。 |
工厂方法模式 | 不修改已有类的前提下,通过增加新的工厂类实现扩展。 |
抽象工厂模式 | 不可以增加产品,可以增加产品族 |