2.工厂模式

一.简单工厂

意图：定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

三个角色：1.抽象产品 2.具体产品（实现抽象产品） 3.工厂类（创建产品实例的具体逻辑）

情景：其实不止英雄联盟，其他很多游戏都是，在你名字建好之后，系统会默认弹出一个选项框 0.第一次玩 1.我是大神 ，选择0会自动进入新手教学模式，1直接转到游戏大厅（这类玩家最烦的就是你多BB）

用户级别的抽象类：定义级别的规范（大部分情况下接口和抽象类可以根据自己的情况选择）

/**
* Created by shixin-pc on 2018/5/7.
* 抽象产品,玩家选择的级别
*/
public interface Level {
void userLevel();
}

用户级别：实现用户级别接口

/**
* Created by shixin-pc on 2018/5/7.
* 第一次玩
*/
public class FirstPlay implements Level{
@Override
public void userLevel() {
Log.e("tag","去新手教学");
}
}

/**
* Created by shixin-pc on 2018/5/7.
* 我是大神
*/

public class SuperiorPlayer implements Level{
@Override
public void userLevel() {
Log.e("tag","直接去大厅");
}
}

工厂：实现创建所有级别实例的内部逻辑

/**
* Created by shixin-pc on 2018/4/10.
* 工厂
*/
public class Me {
private static FirstPlay mFirstPlay = new FirstPlay();
private static SuperiorPlayer mSuperiorPlayer = new SuperiorPlayer();

/**
* @param option 0=第一次玩 1=大神
*/
public static Level makeSocks(int option) {
switch (option) {
case 0:
mFirstPlay.userLevel();
return mFirstPlay;
case 1:
mSuperiorPlayer.userLevel();
return mSuperiorPlayer;
}
return null;
}
}

调用

/**
* 简单工厂
*/
private void simpleFactory(int option) {
Level boatSocks = Me.makeSocks(option);
}

简单工厂又叫静态工厂

优点：优点在于调用者只需要关心传入的参数而无需关系逻辑和对象是如何产生
缺点：比如我新增一个级别，就需要修改Me这个类的逻辑，违反了开闭原则，也正是这个原因，简单工厂其实不算是设计模式中的一种

二.方法工厂

意图：定义一个用于创建对象的接口，让子类决定实例化那一个类
方法工厂其实就是为了弥补简单工厂的缺陷（违反开闭原则）

如果说算法是程序的灵魂，那么数据就是程序的核心了，毕竟算法和程序都需要有数据
情景：操作数据库

最基本的数据访问程序

用户表User

public class User {
private int id;
private String name;

public User(int id, String name) {
this.id = id;
this.name = name;
}

public void setId(int id) {
this.id = id;
}

public void setName(String name) {
this.name = name;
}

public int getId() {
return id;
}

public String getName() {
return name;
}

@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}

数据库操作类

public class SqlserverUser {
public void insert(User user){
Log.e("tag","增加一条用户数据");
}

public void getUser(){
Log.e("tag","获取一条用户数据");
}
}

调用:这里的问题在于如果我要更换一个DB类，并且在insert时不用去考虑当前用的是哪一个DB很麻烦，下面看我们用工厂方法来实现

User user=new User(1,"盖伦");
SqlserverUser su=new SqlserverUser();
su.insert(user);
su.getUser();

工厂的方式实现

用书数据表类

public class User {
private int id;
private String name;

public User(int id, String name) {
this.id = id;
this.name = name;
}

public void setId(int id) {
this.id = id;
}

public void setName(String name) {
this.name = name;
}

public int getId() {
return id;
}

public String getName() {
return name;
}

@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}

DB接口：操作数据库的接口

public interface IUser {
void insert(User user);

void getUser();
}

DB实现类：具体的操作数据库的类

//第一个db

public class AccessUser implements IUser{
public void insert(User user){
Log.e("tag","AccessUser增加一条用户数据");
}

public void getUser(){
Log.e("tag","AccessUser获取一条用户数据");
}
}

//第二个db

public class SqlserverUser implements IUser{
public void insert(User user){
Log.e("tag","SqlserverUser增加一条用户数据");
}

public void getUser(){
Log.e("tag","SqlserverUser获取一条用户数据");
}
}

工厂规范类

public interface IFactory {
IUser createUser();
}

具体的工厂

public class AccessFactory implements IFactory {
@Override
public IUser createUser() {
return new AccessUser();
}
}


public class SqlServerFactory implements IFactory {
@Override
public IUser createUser() {
return new SqlserverUser();
}
}

调用:利用工厂方法和多态的特性达到了上面的需求

IFactory ifactory= new SqlServerFactory();
IUser iuser = ifactory.createUser();
iuser.insert(user);
iuser.getUser();