工厂模式实现了创建者和调用者分离。
工厂模式详细分类可以有一下三种:
简单工厂模式
工厂方法模式
抽象工厂模式
- 简单工厂模式创建对象可以直接通过“工厂类”创建说需要的对象。
一个Car接口和两个实现类
/**
* Car接口,带有一个run方法
* @author 90948
*/
public interface Car {
void run();
}
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪车");
}
}
public class BYD implements Car {
@Override
public void run() {
System.out.println("比亚迪车");
}
}
创建工厂类
/**
* Car工厂,创建Audi对象和BYD对象
* @author 90948
*/
public class CarFactory {
public static Car createCar(String name){
if("奥迪".equals(name)){
return new Audi();
}else if("比亚迪".equals(name)){
return new BYD();
}else{
return null;
}
}
}
测试类
public class Test {
public static void main(String[] args) {
Car c1 = CarFactory.createCar("奥迪");
Car c2 = CarFactory.createCar("比亚迪");
c1.run();
c2.run();
}
}
//结果:
//奥迪车
//比亚迪车
简单工厂模式的缺点:不满足面向对象的基本原则中的“开闭原则”,即开闭原则规定“软件中的对象(类,模块,函数等等)应该对于扩展是开放的,但是对于修改是封闭的。
- 工厂方法模式:
同样用Car接口和两个实现类
不同的是,创建一个CarFactory接口,并且有AudiFactory和BYDFactory实现类。
CarFactory接口
public interface CarFactory {
Car createCar();
}
实现类:
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
public class BYDFactory implements CarFactory {
@Override
public Car createCar() {
return new BYD();
}
}
测试类:
public class Test {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BYDFactory().createCar();
c1.run();
c2.run();
}
}
//结果:
//奥迪车
//比亚迪车
优点:符合“开闭原则”。但是使项目的复杂度增加,即扩展是以增加新的类来实现的。
- 抽象工厂模式
用来生产不同产品族的全部产品,比如说:生产高端汽车需要高端的发动机,高端的座椅和高端的轮胎,生产低端的汽车需要低端的发动机,低端的座椅和低端的轮胎。代码实现:
发动机接口以及其高低端发动机实现类:
/**
* 发动机接口
* @author 90948
*
*/
public interface Engine {
void run();//转速
void strat();//启动效率
}
/**
* 高端发动机
* @author 90948
*
*/
public class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("转速快!");
}
@Override
public void strat() {
System.out.println("启动快!");
}
}
/**
* 低端发动机
* @author 90948
*/
public class LowerEngine implements Engine {
@Override
public void run() {
System.out.println("转速慢!");
}
@Override
public void strat() {
System.out.println("启动慢!");
}
}
座椅接口以及高低端座椅实现类
/**
* 座椅接口
* @author 90948
*/
public interface Seat {
void massage();//是否可以按摩
}
/**
* 高端座椅
* @author 90948
*/
public class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("高端座椅,可以按摩!");
}
}
/**
* 低端座椅
* @author 90948
*/
public class LowerSeat implements Seat {
@Override
public void massage() {
System.out.println("低端座椅,不可以按摩!");
}
}
轮胎接口以及高低端轮胎实现类
/**
* 轮胎接口
* @author 90948
*/
public interface Tyre {
void revolve();//是否磨损
}
/**
* 高端轮胎
* @author 90948
*
*/
public class LuxuryTyre implements Tyre {
@Override
public void revolve() {
System.out.println("高端轮胎,不磨损!");
}
}
/**
* 低端轮胎
* @author 90948
*
*/
public class LowerTyre implements Tyre {
@Override
public void revolve() {
System.out.println("低端轮胎,质量差!");
}
}
制造汽车的工厂接口以及高低端汽车生产的实现类
/**
* 创建汽车的接口
* @author 90948
*
*/
public interface CarFactory {
Engine createEngine();//创建发动机
Seat createSeat();//创建座椅
Tyre createTyre();//创建轮胎
}
/**
* 制作高端汽车
* @author 90948
*
*/
public class LuxuryCar implements CarFactory{
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
/**
* 制作低端汽车
* @author 90948
*
*/
public class LowerCar implements CarFactory{
@Override
public Engine createEngine() {
return new LowerEngine();
}
@Override
public Seat createSeat() {
return new LowerSeat();
}
@Override
public Tyre createTyre() {
return new LowerTyre();
}
}
测试类,生产一辆高端汽车:
/**
* 测试类,制作一辆高端汽车
* @author 90948
*/
public class Test {
public static void main(String[] args) {
CarFactory factory = new LuxuryCar();
Engine engine = factory.createEngine();
Seat seat = factory.createSeat();
Tyre tyre = factory.createTyre();
engine.run();
engine.strat();
seat.massage();
tyre.revolve();
}
}
//结果:
//转速快!
//启动快!
//高端座椅,可以按摩!
//高端轮胎,不磨损!
应用的场景主要有:
1. JDBC中Connection对象的获取。
2. Hibernate中通过SessionFactory创建Session
3. Spring中IoC容器创建管理Bean。
等等……