1，简单工厂模式
1.1，简介
简单工厂：封装创建产品的过程。提供一个返回产品实例的方法，此方法封装了产品实例的逻辑，根据参数返回不同的实例。所有产品一个工厂实例生成。
缺点：每多一个产品，就要修改 instance() 方法，修改的多，方法就变长。
优点：我就是这么用的，简单实用。。。
简单工厂模式不属于 23 种设计模式之一。
1.2，demo
- 产品接口
package com.demo.base.design_partten.factory.simple_factory;
/**
* 产品接口
* */
public interface Car {
void run();
void stop();
}
- 产品类
package com.demo.base.design_partten.factory.simple_factory;
/**
* 产品类
* */
public class BCCar implements Car {
@Override
public void run() {
System.out.println("bc car is running");
}
@Override
public void stop() {
System.out.println("bc car is stop");
}
}
package com.demo.base.design_partten.factory.simple_factory;
/**
* 产品类
* */
public class BMCar implements Car {
@Override
public void run() {
System.out.println("bm car is running");
}
@Override
public void stop() {
System.out.println("bm car is stop");
}
}
- 工厂类
封装创建产品对象的方法。
package com.demo.base.design_partten.factory.simple_factory;
/**
* @author gx
* 简单工厂：
* 封装创建产品的过程。提供一个返回产品实例的方法，此方法封装了产品实例的逻辑，根据参数返回不同的实例。所有产品一个工厂实例生成。
* 缺点：
* 每多一个产品，就要修改 instance() 方法，修改的多，方法就变长。
* 优点：
* 我就是这么用的，简单实用。。。
*/
public class Factory {
public static Car instance(Integer carType) throws Exception {
if(carType.equals(1)){
return new BCCar();
}else if(carType.equals(2)){
return new BMCar();
}else{
throw new Exception();
}
}
}
- 测试类
调用工厂类提供的方法来创建产品对象。
package com.demo.base.design_partten.factory.simple_factory;
/**
* 简单工厂模式不算 GOF 23 种设计模式之一。
* GOF：一本书四个人写的关于设计模式的书（Gang of Four）
* 调用工厂类的方法，传入参数获取不同的实例。
* */
public class Test {
public static void main(String[] args) throws Exception {
Car instance = Factory.instance(1);
instance.run();
instance.stop();
Car instance1 = Factory.instance(2);
instance1.run();
instance1.stop();
}
}
2，抽象工厂模式
2.1，简介
抽象工厂模式
GOF 之一。符合开闭原则。
同一个工厂创建一系列的产品（车，座椅）。不违反开闭原则情况下，智能扩展一个新的系列（大众）。
抽象工厂模式和工厂方法模式：抽象工厂每个工厂可以创建一个系列的多个不同实例，工厂方法只能创建一个实例。
2.2，demo
- 产品接口
package com.demo.base.design_partten.factory.abstract_factory;
public interface Seat {
void sit();
}
package com.demo.base.design_partten.factory.abstract_factory;
/**
* 产品接口
* */
public interface Car {
void run();
void stop();
}
- 产品实现类
package com.demo.base.design_partten.factory.abstract_factory;
/**
* 产品类
* */
public class BCCar implements Car {
@Override
public void run() {
System.out.println("bc car is running");
}
@Override
public void stop() {
System.out.println("bc car is stop");
}
}
package com.demo.base.design_partten.factory.abstract_factory;
/**
* 产品类
* */
public class BMCar implements Car {
@Override
public void run() {
System.out.println("bm car is running");
}
@Override
public void stop() {
System.out.println("bm car is stop");
}
}
package com.demo.base.design_partten.factory.abstract_factory;
public class BCSeat implements Seat {
@Override
public void sit() {
System.out.println("bc sit！");
}
}
package com.demo.base.design_partten.factory.abstract_factory;
public class BMSeat implements Seat {
@Override
public void sit() {
System.out.println("BM sit！");
}
}
- 抽象工厂
package com.demo.base.design_partten.factory.abstract_factory;
public interface AbstractFactory {
Car createCar();
Seat createSeat();
}
- 工厂类
package com.demo.base.design_partten.factory.abstract_factory;
public class BCFactory implements AbstractFactory {
@Override
public Car createCar() {
return new BCCar();
}
@Override
public Seat createSeat() {
return new BCSeat();
}
}
package com.demo.base.design_partten.factory.abstract_factory;
public class BMFactory implements AbstractFactory{
@Override
public Car createCar() {
return new BMCar();
}
@Override
public Seat createSeat() {
return new BMSeat();
}
}
- 测试类
package com.demo.base.design_partten.factory.abstract_factory;
public class Test {
public static void main(String[] args) {
BMFactory bmFactory = new BMFactory();
Car bmCar = bmFactory.createCar();
bmCar.run();
bmCar.stop();
Seat bmSeat = bmFactory.createSeat();
bmSeat.sit();
BCFactory bcFactory = new BCFactory();
Car bcCar = bcFactory.createCar();
bcCar.run();
bcCar.stop();
Seat bcSeat = bcFactory.createSeat();
bcSeat.sit();
}
}
3. 工厂方法模式
3.1，简介
工厂方法模式：属于 GOF 23种设计模式之一。符合开放封闭原则。
开放封闭原则：
对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。
每个产品一个对应的工厂，新增一种产品，需要新增一个工厂，不需要修改之前的产品和工厂类。
3.2，demo
- 产品接口
package com.demo.base.design_partten.factory.method_factory;
/**
* 产品接口
* */
public interface Car {
void run();
void stop();
}
- 产品实现类
package com.demo.base.design_partten.factory.method_factory;
/**
* 产品类
* */
public class BCCar implements Car {
@Override
public void run() {
System.out.println("bc car is running");
}
@Override
public void stop() {
System.out.println("bc car is stop");
}
}
package com.demo.base.design_partten.factory.method_factory;
/**
* 产品类
* */
public class BMCar implements Car {
@Override
public void run() {
System.out.println("bm car is running");
}
@Override
public void stop() {
System.out.println("bm car is stop");
}
}
package com.demo.base.design_partten.factory.method_factory;
public class DzCar implements Car {
@Override
public void run() {
System.out.println("dz car is running");
}
@Override
public void stop() {
System.out.println("dz car is stop");
}
}
- 抽象工厂
package com.demo.base.design_partten.factory.method_factory;
/**
* 抽象工厂
* */
public interface AbstractFactory {
Car createCar();
}
- 工厂实现类
package com.demo.base.design_partten.factory.method_factory;
public class BCFactory implements AbstractFactory {
@Override
public Car createCar() {
return new BCCar();
}
}
package com.demo.base.design_partten.factory.method_factory;
/**
* @author gx
*/
public class BMFactory implements AbstractFactory {
@Override
public Car createCar() {
return new BMCar();
}
}
package com.demo.base.design_partten.factory.method_factory;
public class DzFactory implements AbstractFactory{
@Override
public Car createCar() {
return new DzCar();
}
}
- 测试类
package com.demo.base.design_partten.factory.method_factory;
/**
* 工厂方法模式：
* 属于 GOF 23种设计模式之一。符合开放封闭原则。
* 开放封闭原则：
* 对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
* 对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。
* 每个产品一个对应的工厂，新增一种产品，需要新增一个工厂，不需要修改之前的产品和工厂类。
* */
public class Test {
public static void main(String[] args) {
Car car = new BMFactory().createCar();
car.run();
car.stop();
Car car1 = new BCFactory().createCar();
car1.run();
car1.stop();
Car car2 = new DzFactory().createCar();
car2.run();
car2.stop();
}
}
4. 工厂方法模式和抽象工厂模式的区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。