工厂模式三大分类
* 工厂模式：实现创建者和调用者的分离。
* 分类：
* 1.简单工厂模式
* 2.工厂方法模式
* 3.抽象工厂模式简单工厂模式，就以造车为例：
首先有个车接口，有个跑的方法：
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("比亚迪在跑");
}
}写一个车工厂：
/**
* 简单工厂模式车工厂，如果有新车只能在这上面改代码，不利于扩展。
*/
public class CarFactory {
public static Car getCar(String type){
if("奥迪".equals(type)){
return new Audi();
}else if("比亚迪".equals(type)){
return new Byd();
}else{
return null;
}
}
}也可以这么写：
/**
* 简单工厂第二种方式
*/
public class CarFactory3 {
public static Car getAodi(){
return new Audi();
}
public static Car getByd(){
return new Byd();
}
}
调用：
Car c1 = CarFactory.getCar("奥迪");
Car c2 = CarFactory.getCar("比亚迪");
c1.run();
c2.run();
Car c4 = CarFactory3.getAodi();
c4.run();可以发现简单工厂模式代码简单，但不符合OCP。
面向对象设计的基本原则之一：OCP（开闭原则）：一个软件的实体应当对扩展开放，对修改关闭。工厂方法模式：同样是造车，车接口和实现跟上面一样，省略。
写一个车工厂接口：
/**
*工厂方法模式的车工厂，有新车只需新增车和对应的车工厂即可，开放扩展。
*/
public interface CarFactory2 {
Car getCar();
}然后写两个车对应的车工厂实现类：
public class AudiFactory implements CarFactory2{
@Override
public Car getCar() {
return new Audi();
}
}
public class BydFactory implements CarFactory2{
@Override
public Car getCar() {
return new Byd();
}
}
调用：
//工厂方法
Car c3 = new AudiFactory().getCar();
c3.run();可以发现，工厂方法解决了简单工厂的弊端，可扩展，但写的接口和类要多些。这两种模式。从理论上来说工厂方法较好，利于扩展，但实际上简单工厂用的多。
上面两种模式都是生产一种产品，下面这个抽象工厂模式就是生产产品族的。
* 抽象工厂模式：用来生产不同产品族的全部产品。在有多个业务品种、业务分类时，
* 通过抽象工作模式产生需要的对象是一种非常好的解决方式。
* 产品族：比如发动机、轮胎、座椅、玻璃等生产出一辆车，这些一起的就是一个产品族。
* 抽象工厂对于新增产品无能为力，只能新增产品族；新增产品还是交给简单工厂或工厂方法。首先先有产品：
/**
* 生产轮胎
*/
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("磨损快");
}
}
/**
* 生产座椅
*/
public interface Seat {
void massage();
}
//高端
class LuxurySeat implements Seat{
@Override
public void massage() {
System.out.println("座椅可以按摩");
}
}
//低端
class LowSeat implements Seat{
@Override
public void massage() {
System.out.println("座椅不可以按摩");
}
}
/**
* 生产发动机
*/
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("启动慢");
}
}
然后写一个车工厂接口：
public interface CarFactory4 {
Tyre getTyre();
Seat getSeat();
Engine getEngine();
}
两个实现类：
//低端车
public class LowCarFactory implements CarFactory4{
@Override
public Tyre getTyre() {
return new LowTyre();
}
@Override
public Seat getSeat() {
return new LowSeat();
}
@Override
public Engine getEngine() {
return new LowEngine();
}
}
//高端车
public class LuxuryCarFactory implements CarFactory4{
@Override
public Tyre getTyre() {
return new LowTyre();
}
@Override
public Seat getSeat() {
return new LowSeat();
}
@Override
public Engine getEngine() {
return new LowEngine();
}
}
调用：
//抽象工厂
CarFactory4 factory = new LowCarFactory();
Engine engine=factory.getEngine();
engine.start();
engine.run();