23种设计模式详解(三)

1.模板方法模式(Templates Pattern)

模板方法模式就是指:一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用。

车辆模板:

public abstract class CarModel {
    //启动
    protected abstract void start();
    //跑
    //为什么用final,让子类不能修改run()里面的方法调用顺序
    final public  void run(){
        //开始要启动
        this.start();
        //到了目的地就停车
        this.stop();
    };
    //停住
    protected abstract void stop();
}

宝马实现类:

public class BMW extends CarModel {
    @Override
    public void start() {
        System.out.println("宝马启动");
    }
    @Override
    public void stop() {
        System.out.println("宝马停车");
    }
}

悍马实现类:

public class Hummer extends CarModel {
    @Override
    public void start() {
        System.out.println("悍马启动");
    }
    @Override
    public void stop() {
        System.out.println("悍马停车");
    }
}

测试:

public class Test {
    public static void main(String[] args){
        BMW bmw=new BMW();
        bmw.run();
        Hummer hm=new Hummer();
        hm.run();

    }
}

结果:

2.建造者模式(Build Pattern)

工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。

sender:

public interface Sender {
    public void send();
}

smsSender:

public class smsSender implements Sender {
    @Override
    public void send() {
        System.out.println("发短信");
    }
}

mailSender:

public class mailSender implements Sender {
    @Override
    public void send() {
        System.out.println("发邮件");
    }
}

build:

public class build {
    private List<Sender> phoneList=new ArrayList<>();
    public void mailSend(int count){
        for(int i=0;i<count;i++){
            phoneList.add(new mailSender());

        }
    }
    public void smsSend(int count){
        for(int i=0;i<count;i++){
            phoneList.add(new smsSender());

        }
    }
}

测试:

public class Test {
    public static void main(String[] args){
        build b=new build();
        b.mailSend(10);
    }
}

3.桥梁模式(Bridge Pattern)

举例,我有一家公司,现在我要成立两家子公司,一个是房地产公司,一个是服装公司,但是我总公司要监督这两家子公司。

产品:

public abstract class Product {
    //生产
    protected abstract void produce();
    //销售
    protected abstract void sell();

}

服装:

public class Clothes extends Product {
    @Override
    public void sell() {
        System.out.println("夏天到了,生产了一批高端T恤");
    }

    @Override
    public void produce() {
        System.out.println("T恤全部买完");
    }
}

房地产:

public class House extends Product {
    @Override
    public void produce() {
        System.out.println("投资盖了一座大楼");
    }

    @Override
    public void sell() {
        System.out.println("房子全部高价售罄");
    }
}

总公司:

public abstract class Company {
    private Product product;

    public Company(Product product) {
        this.product = product;
    }

    //赚钱
    public void makeMoney(){
        this.product.produce();
        this.product.sell();
    }

}

房地产公司:

public class houseCorp extends Company {
    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("赚钱了");
    }

    public houseCorp(House house) {
        super(house);
    }
}

服装公司:

public class clothesCorp extends Company {
    public clothesCorp(Clothes clothes) {
        super(clothes);

    }
    @Override
    public void makeMoney() {
        super.makeMoney();
        System.out.println("赚钱了");
    }
}

测试:

public class Test {
    public  static void main(String[] args){
        House h=new House();
        houseCorp hc=new houseCorp(h);
        hc.makeMoney();
    }
}

结果:

以后我的房地产公司或者服装公司要不要转型做其他产品?我要不要在成立一家子公司?如果这样我要去修改代码?不用,成立子公司就去继承Company,转型发展其他产品线就去继承Product,不用修改源代码,这就是桥梁模式的好处。

4.命令模式(Command Pattern)

命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。

命令接口:

public interface Command {
    public void exe();
}

命令接口的实现:

public class myCommand implements Command{
    private Soldier soldier;

    public myCommand(Soldier soldier) {
        this.soldier = soldier;
    }

    @Override
    public void exe() {
        soldier.action();
    }
}

司令:

public class Commander {
    private Command command;
    public Commander(Command command) {
        this.command = command;
    }
   public void action(){
        command.exe();
   }
}

士兵:

public class Soldier {
    public void action() {
        System.out.println("收到命令");
    }
}

测试:

public class Test {
    public static void main(String[] args){
        Soldier sd=new Soldier();
        Command cm=new myCommand(sd);
        Commander cmd=new Commander(cm);
        cmd.action();
    }
}

结果:

命令模式的目的就是达到命令的发出者和执行者之间解耦,实现请求和执行分开,熟悉Struts的同学应该知道,Struts其实就是一种将请求和呈现分离的技术,其中必然涉及命令模式的思想!

源码:

链接:https://pan.baidu.com/s/1p8YU_3A1HQ4v8QiPrtINsA

密码:w5q5

原文发布于微信公众号 - Java大联盟(javaunion)

原文发表时间:2018-05-08

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏阿凯的Excel

动态显示下拉框内容

过了冬至,你在北方瑟瑟发抖,我在广东秋风瑟瑟~ 最近小编经常梦回母校~放一张母校的美图! 年底了,又到了预订报刊的时候! 肯定有人会问,这年头还有谁看报刊...

2773
来自专栏Linyb极客之路

工作流引擎之activiti会签功能实现

在流程业务管理中,任务是通常都是由一个人去处理的,而多个人同时处理一个任务,这种任务我们称之为会签任务。这种业务需求很常见,如一个请款单,领导审批环节中,就需要...

4832
来自专栏影子

PostgreSQL>窗口函数的用法

转载请注明出处:https://www.cnblogs.com/funnyzpc/p/9311281.html

851
来自专栏圣杰的专栏

DDD理论学习系列(7)-- 值对象

? 1.引言 提到值对象,我们可能立马就想到值类型和引用类型。而在C#中,值类型的代表是strut和enum,引用类型的代表是class、interface、...

2287
来自专栏后端技术探索

php进阶

基本数据类型和数组都为真复制,即为真副本,当属性为对象时,为假复制,改变副本仍会影响原对象.解决方案:

671
来自专栏gaoqin31

设计模式之 六大原则

定义: 一个类承担的职责不宜过多,或者说就一个类而言,应该仅有一个引起它变化的原因

793
来自专栏Android 技术栈

java 常用十种设计模式示例归纳 | 已打包请带走

一个Demo,集合常用的十种设计模式,每个模式使用易被人们接受的案例讲述,按模式分包,使用设计模式前后对比,界面显示定义讲解,让你更深刻的了解每种设计模式。 ...

1592
来自专栏恰同学骚年

设计模式的征途—4.抽象工厂(Abstract Factory)模式

上一篇的工厂方法模式引入了工厂等级结构,解决了在原来简单工厂模式中工厂类职责太重的原则,但是由于工厂方法模式的每个工厂只生产一类产品,可能会导致系统中存在大量的...

671
来自专栏Java呓语

权限之数据权限概念原型实现抽象

随着业务的演进,逐渐衍生出精细化管理数据的诉求。我遇到的业务场景是在企业级数据管理中,对不同职级的员工展示不同的数据。我的业务上的诉求是对SELECT进行权限控...

772
来自专栏Jimoer

Java设计模式学习记录-简单工厂模式、工厂方法模式

之前介绍了设计模式的原则和分类等概述。今天开启设计模式的学习,首先要介绍的就是工厂模式,在介绍工厂模式前会先介绍一下简单工厂模式,这样由浅入深来介绍。

683

扫码关注云+社区