工厂模式
实现了创建者和调用者的分离
详细分类
简单工厂模式
工厂方法模式
抽象工厂模式
面向对象设计的基本原则
OCP：开闭原则（一个软件应当对于扩展开放，修改关闭）
DIP：依赖倒转原则（要针对接口编程，不要针对实现编程）
LoD：迪米特原则（只与你直接的朋友通信，而避免和陌生人通信）
核心本质
实例化对象，用工厂方法代替new操作
将选择实体类、创建对象统一管理和控制。从而将调用者和我们的实现类解耦
工厂模式
简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有代码）
工厂方法模式：用来生产同一等级固定产品（支持增加任意产品）
抽象工厂模式：用来生产不同产品族的全部产品（对于增加新的产品，无能为力，只能增加产品族）
简单工厂模式：
package com.note.pattern.factory.simplefactory;
public interface Car {
public void run();
}
package com.note.pattern.factory.simplefactory;
public class AodiCar implements Car {
@Override
public void run() {
System.out.println("奥迪在跑---------------------");
}
}
package com.note.pattern.factory.simplefactory;
public class BydCar implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑---------------");
}
}
如果没有工厂模式：
package com.note.pattern.factory.simplefactory;
public class ClientNoFactory {
public static void main(String[] args) {
Car aodi = new AodiCar();
aodi.run();
Car byd = new BydCar();
byd.run();
}
}
没有用工厂模式调用者牵扯的关系太多了~既要知道Car 还要知道怎么去创造car 。全能型人才
有工厂模式：
package com.note.pattern.factory.simplefactory;
public class SimpleFactory {
public static Car createCar(String type) {
if ("奥迪".equals(type)) {
return new AodiCar();
} else if ("比亚迪".equals(type)) {
return new BydCar();
}
return null;
}
}
package com.note.pattern.factory.simplefactory;
public class ClientSimpleFactory {
public static void main(String[] args) {
Car aodi = SimpleFactory.createCar("奥迪");
aodi.run();
Car byd = SimpleFactory.createCar("比亚迪");
byd.run();
}
}
要点：
简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同实例对象
对于新增加的产品无能无力~不修改代码是无法扩展的
工厂方法模式：
为了避免简单工厂模式的缺点，不能满足OCP
工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类
package com.note.pattern.factory.simplefactory;
public interface Car {
public void run();
}
package com.note.pattern.factory.simplefactory;
public class AodiCar implements Car {
@Override
public void run() {
System.out.println("奥迪在跑---------------------");
}
}
package com.note.pattern.factory.simplefactory;
public class BydCar implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑---------------");
}
}
package com.note.pattern.factory.methodfactory;
public interface CarFactory {
public Car createCar();
}
package com.note.pattern.factory.methodfactory;
public class AodiCarFactory implements CarFactory {
@Override
public Car createCar() {
return new AodiCar();
}
}
package com.note.pattern.factory.methodfactory;
public class BydCarFactory implements CarFactory {
@Override
public Car createCar() {
return new BydCar();
}
}
package com.note.pattern.factory.methodfactory;
public class Client {
public static void main(String[] args) {
Car aodi = new AodiCarFactory().createCar();
aodi.run();
Car byd = new BydCarFactory().createCar();
byd.run();
}
}
如果我们增加一个奔驰车，不需要修改已有的类。
根据设计理论建议：工厂方法模式 。但实际上我们都用简单工厂模式
抽象工厂模式：
用来生产不同产品族的全部产品。（对于增加新的产品无能为力，支持增加产品族）
package com.note.pattern.factory.abstractfactory;
public interface Engine {
void run();
void start();
}
class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("转的快");
}
@Override
public void start() {
System.out.println("可以自动起停");
}
}
class LowEngine implements Engine{
@Override
public void run() {
System.out.println("转的慢");
}
@Override
public void start() {
System.out.println("不可以自动起停");
}
}
package com.note.pattern.factory.abstractfactory;
public interface Seat {
void message();
}
class LuxurySeat implements Seat{
@Override
public void message() {
System.out.println("可以按摩");
}
}
class LowSeat implements Seat{
@Override
public void message() {
System.out.println("不可以按摩");
}
}
package com.note.pattern.factory.abstractfactory;
public interface Tyre {
void revolve();
}
class LuxuryTyre implements Tyre{
@Override
public void revolve() {
System.out.println("磨损慢");
}
}
class LowTyre implements Tyre{
@Override
public void revolve() {
System.out.println("磨损快");
}
}
package com.note.pattern.factory.abstractfactory;
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
package com.note.pattern.factory.abstractfactory;
public class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}
package com.note.pattern.factory.abstractfactory;
public class Client {
public static void main(String[] args) {
CarFactory car = new LuxuryCarFactory();
Engine engine = car.createEngine();
engine.run();
engine.start();
}
}
总结：
简单工厂模式（静态工厂模式）
虽然某种程度不符合设计规则，单实际使用最多
工厂方法模式
不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式
不可以增加产品，可以增加产品族
