java设计模式之工厂模式(二)

在这人世间，有些路是非要单独一个人去面对，单独一个人去跋涉的，路再长再远，夜再黑再暗，也得独自默默地走下去。

设计模式学习,近期我会把23中设计模式都写成博客,敬请期待~

什么是工厂模式?

工厂模式属于设计模式中的创建型,我们不暴露创建对象的具体逻辑，而是将逻辑封装在一个方法中，那么这个方法就可以被视为一个工厂.

工厂模式优缺点

优点

• 不暴露具体代码逻辑实现,吧代码逻辑封装到一个方法中,无需关心代码细节(细节指代码实现逻辑)直接调用即可实现效果,使用简单
• 实现方和调用方完全解耦,遵守了依赖倒置原则(面向接口编程)
• 实现了对扩展开发,对修改关闭,遵守了开闭原则

缺点:

• 如果增加一个模块代码改动比较大
• 需要创建很多的工厂(Foatory)类,增加了代码抽象和难度理解

工厂模式分类

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

为什么要学习工厂模式?使用场景是什么??

学任何东西首先都应该考虑到为什么要学他,学他会给我们带来什么好处.对于简答工厂模式而言,给大家举一个例子,

假设:我要买一辆车,我应该怎么做?

• 去卖车的地方,先挑一款比较喜欢的车;
  (卖车的地方就相当于一个工厂)
• 然后把车加工出来;
  加工车,就相当于写车的细节
• 交钱提车;
  交钱提车相当于工厂类吧车的对象返回给我

可以看出,这就是一个简单的工厂模式,我出钱,你把车给我,而不是我直接来造车,

不写成工厂模式会有什么缺点:

  假设我很有钱,一天买一辆车,不同品牌不同型号,那就买一次车得创建一次车的细节,从刚
开始画车的轮廓,到最后给车上色,都由我一个人单独完成,

工厂模式的优点:

我出钱,你给我车,细节我不用管.就是这么简单

(当然这只是举例,车的代码肯定由咋们写,只是说会少很多相同的代码)

这就是简单工厂模式~

普通工厂模式

public abstract class OrdinaryCar {
    //汽车名字
    public abstract void CarName();
}

//五菱汽车
public class OrdinaryWuLin extends OrdinaryCar {
    @Override
    public void CarName() {
        Log.i("Factory:简单工厂之:","五菱宏光");
    }
}

//大众汽车
public class OrdinaryDaZhong extends OrdinaryCar {
    @Override
    public void CarName() {
        Log.i("Factory:简单工厂之:","大众汽车");
    }
}

//简单工厂实现
public class OrdinaryFactory {
    public static OrdinaryCar OrdinaryCar(String carName){
        if ( carName.equals("WuLing")) {
            //返回五菱
            return  new OrdinaryWuLin();
        }else if(carName.equals("DaZhong")){
            //返回大众
            return new OrdinaryDaZhong();
        }else {
            return null;
        }
    }
}

代码使用:

OrdinaryCar ordinaryWuLin1 = OrdinaryFactory.OrdinaryCar("WuLing");
OrdinaryCar ordinaryDaZhong1 = OrdinaryFactory.OrdinaryCar("DaZhong");
ordinaryWuLin1.CarName();//五菱汽车
ordinaryDaZhong1.CarName();//大众汽车

优点:

• 使用简单,没有很难的逻辑

缺点:

• 违背了OCP(开闭)原则(扩展开发,修改关闭)
• 代码容易写错,过多的if else 判断

UML类图(2.1):

UML类图代码:

UML类图参考文档,如果实在不想学这个UML类图,直接跳过这一段即可.

@startuml
abstract OrdinaryCar{
    abstract CarName();
}
OrdinaryDaZhong ..|> OrdinaryCar

OrdinaryWuLing ..|> OrdinaryCar

OrdinaryFactory ->OrdinaryDaZhong

OrdinaryFactory ->OrdinaryWuLing

消费者 -> OrdinaryFactory

class 消费者
note bottom :只与OrdinaryFactory交互,不管如何创建车\n我只给你车的类型,你给我返回车

@enduml

简单工厂Log结果图(3.1):

工厂方法模式

工厂方法思想:

• 一个车工厂(Factory)满足一个车的创建,然后由总工厂来管理车工厂

简单的理解就是,总工厂管理每一个车工厂,车工厂管理每一台汽车的创建,现在我要买型号为,五菱宏光A3的汽车,我给总工厂钱,总工厂去找五菱宏光工厂,五菱宏光在找A系列的车最后在给我对应的汽车

//购买车的名字
public abstract class FaCar {
    public abstract void CarName();
}
//汽车总工厂
public interface FaFactory {
    FaCar createCar();
}

//大众汽车
public class FaDaZhong extends FaCar {
    @Override
    public void CarName() {
        Log.i("Factory:工厂方法之:","大众汽车");
    }
}

//大众汽车工厂类
public class FaDaZhongFactory implements FaFactory{
    @Override
    public FaCar createCar() {
        return new FaDaZhong();
    }
}

优点:

• 满足开闭原则(对扩展开放,对修改关闭)
• 使用也比较简单,只是代码会变多很多

缺点:

• 因为一个类创建一个工厂,会使代码变多,不利于管理

如果我现在要增加五菱和特斯拉,怎么增加:

//五菱汽车
public class FaWuLing extends FaCar{
    @Override
    public void CarName() {
        Log.i("Factory:工厂方法之:","五菱汽车");
    }
}

//五菱工厂
public class FaWuLingFactory implements FaFactory{
    @Override
    public FaCar createCar() {
        return new FaWuLing();
    }
}

//特斯拉汽车
public class FaTeSiLa extends FaCar {
    @Override
    public void CarName() {
        Log.i("Factory:工厂方法之:","特斯拉汽车");
    }
}

//特斯拉工厂
public class FaTeSiLaFactory implements FaFactory{
    @Override
    public FaCar createCar() {
        return new FaTeSiLa();
    }
}

代码使用:

FaCar faDaZhong = new FaDaZhongFactory().createCar();
FaCar faWuLing = new FaWuLingFactory().createCar();
FaCar faTeSiLa = new FaTeSiLaFactory().createCar();
faDaZhong.CarName();//大众汽车
faWuLing.CarName();//五菱汽车
faTeSiLa.CarName();//特斯拉汽车 

工厂方法模式Log图(3.2):

UML类图(2.2):

UML类图代码:

UML类图参考文档,如果实在不想学这个UML类图,直接跳过这一段即可.

@startuml
interface FaFactory{
   Car createCar();
}
note right:用来创建车类型

abstract class FaCar {
         abstract void CarName();
}
note left:用来创建车名字

FaDaZhong ..|> FaCar
FaWuLing ..|> FaCar
FaTeSiLa ..|> FaCar

FaCarDaZhongFactory --|> FaFactory
FaWuLingFactory --|> FaFactory
FaTeSiLaFactory --|> FaFactory


class FaCarDaZhongFactory{
     returtn FaDaZhong()
}
class FaWuLingFactory{
     returtn FaWuLing()
}
class FaTeSiLaFactory{
     returtn FaTeSiLa()
}
@enduml

抽象工厂模式

什么是抽象工厂模式:

比如说华为和小米;

相对于手机来说,小米手机和华为手机属于是手机系列(参考图1.1)

(参考图1.1):

相对于华为来说,华为手机和华为电脑,都是属于华为系列参考图(1.2)

参考图(1.2):

如果说我现在苏宁实体店,我想先买小米手机,我是不是先去小米店,然后找到小米手机系列,如果想买小米电脑,找到小米电脑系列,再次购买小米电脑

在这里苏宁实体店就充当着总工厂(Factory)类
去苏宁实体店里面找到小米店,小米店充当着小米工厂(Factory)
然后小米店给你小米手机/小米电脑, 充当着小米小米手机具体的实现
华为也是一样的,先去总工厂(苏宁实体店),然后去华为店(华为Factory)
在找到你想买的东西

我不知道我这么解释大家能不能听懂,接下来请跟随我的脚步一点一点实现~

感觉抽象工厂类有点 ‘套娃’ 的意思<(￣▽￣)/

代码实现:

定义2个接口 :用来实现手机和电脑具体细节,比如手机可以打开,电脑可以学习等.

//手机细节实现
public interface IPhone {
    // 打开手机
    void open();
    //连接Wifi
    void wifi();
     // 发送短信
    void sendSMS();
}

//电脑细节实现
public interface IComputer {
    //学习
    void study();
	 //玩耍
    void play();
     //看电视
    void WatchTv();
}

创建华为手机,小米手机,华为电脑,小米电脑:

//华为手机
public class HuaWeiPhone implements IPhone{
    @Override
    public void open() {
        Log.i("Factory抽象工厂方法:","华为手机打开");
    }
    @Override
    public void wifi() {
        Log.i("Factory抽象工厂方法:","华为手机WIFI打开");
    }
    @Override
    public void sendSMS() {
        Log.i("Factory抽象工厂方法:","华为手机发送消息");
    }
}

//华为电脑
public class HuaWeiComputer implements IComputer{
    @Override
    public void study() {
        Log.i("Factory抽象工厂方法:","华为电脑学习");
    }
    @Override
    public void play() {
        Log.i("Factory抽象工厂方法:","华为电脑玩耍");
    }
    @Override
    public void WatchTv() {
        Log.i("Factory抽象工厂方法:","华为电脑看电视");
    }
}

//小米手机
public class XiaoMiPhone implements IPhone{
    @Override
    public void open() {
        Log.i("Factory抽象工厂方法:","小米手机打开");
    }
    @Override
    public void wifi() {
        Log.i("Factory抽象工厂方法:","小米手机WIFI打开");
    }
    @Override
    public void sendSMS() {
        Log.i("Factory抽象工厂方法:","小米手机发送消息");
    }
}

//小米电脑:
public class XiaoMiComputer implements IComputer{
    @Override
    public void study() {
        Log.i("Factory抽象工厂方法:","小米电脑学习");
    }
    @Override
    public void play() {
        Log.i("Factory抽象工厂方法:","小米电脑玩耍");
    }
    @Override
    public void WatchTv() {
        Log.i("Factory抽象工厂方法:","小米电脑看电视");
    }
}

创建总工厂,用来返回时小米工厂,还是华为工厂

public interface TotalFactory {
    /**
     * 创建手机系列
     */
    IPhone createPhone();

    /**
     * 创建电脑系列
     */
    IComputer createComputer();
}

创建华为工厂,创建小米工厂;用来加工对应的产品

//华为工厂
public  class HuaWeiFactory implements TotalFactory {
    @Override
    public IPhone createPhone() {
        return new HuaWeiPhone();
    }
    @Override
    public IComputer createComputer() {
        return new HuaWeiComputer();
    }
}

//小米工厂
public  class XiaoMiFactory implements TotalFactory {
    @Override
    public IPhone createPhone() {
        return new XiaoMiPhone();
    }
    @Override
    public IComputer createComputer() {
        return new XiaoMiComputer();
    }
}

使用代码:

XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
IComputer computer = xiaoMiFactory.createComputer();
IPhone phone = xiaoMiFactory.createPhone();
computer.play();//小米电脑
computer.study();//小米电脑
computer.WatchTv();//小米电脑

phone.open();//小米手机
phone.sendSMS();//小米手机
phone.wifi();//小米手机

抽象工厂模式Log图(3.3):

UML类图(2.3):

只以华为系列举例(太多太乱看的更迷糊)

优点:

• 咋们只与总工厂(TotalFactory)交互,需要小米手机就new小米工厂,然后创建对应的方法小米手机即可.
• 遵守了开闭原则(对扩展开放,对修改关闭)
• 遵守了依赖倒置原则(面向接口编程)

注:
我是用的Android项目,有没学过的Android的同学直接下载代码即可,下载项目你是跑步起来的哦~

完整代码

最近文章:

java 设计模式之单例模式(一)

原创不易,记得点赞哦~我近期会把23篇都尽量更新出来,有想学设计模式的朋友记得关注哦(#^.^#)