设计模式学习

最新推荐文章于 2024-09-03 22:52:48 发布
最新推荐文章于 2024-09-03 22:52:48 发布
阅读量893 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 设计模式 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuaicihai/article/details/69063996
版权

设计模式定义

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。由GOF在二十年前提出来的。
目的:为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

面向对象设计的六大基本原则（高内聚、低耦合）

面向对象设计的目标

1、可扩展性 容易添加新的功能
2、灵活性 容易添加新的功能代码修改平稳地发生（修改一处地方带来的影响尽量少）
3、可插入性 容易将一个类抽出去，同时将另一个有同样接口的类加入进来
4、可复用性强。

高内聚、低耦合

耦合性：也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息
内聚性：又称块内联系。指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。
高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，不可分割。
对于低耦合，一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接口，尽量的少而简单。如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。这样有利于修改和组合。

六大基本原则

单一职责原则 SOP：一个类只负责一个功能领域中的相应职责。

开放封闭原则 OCP：对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

接口隔离原则 ISP：使用多个专一功能的接口比使用一个的总接口要好。

里氏替换原则 LSP：子类型必须能够替换它们的基类型。一个软件实体如果使用的是一个基类，那么当把这个基类替换成继承该基类的子类，程序的行为不会发生任何变化。软件实体察觉不出基类对象和子类对象的区别。

依赖倒置原则 DIP:要依赖于抽象，不要依赖于具体。客户端依赖于抽象耦合。

迪米特法则 LOD:对象与对象之间应该使用尽可能少的方法来关联，避免千丝万缕的关系。

单例设计模式

  • 提出者是：GOF（gang of four）
    应用场景

保证一个类在系统中只存在一个实例。如：客户端商城等项目中（涉及注册登录）的用户类，Windows的任务管理器，工厂模式中的工厂等等。

优点

由于单例模式只生成一个实例，减少了系统弄性能开销，当一个对象的产生需要较多的资源时，可通过在应用启动时直接产生单例对象，然后永久驻留内存的方式来解决。

常见的物种单例模式实现方式

  1. 饿汉式（线程安全，调用效率高（因为不用加锁），但是不能延时加载（需要的时候你再去创建对象））
/**
 * 饿汉式
 * 缺点:不能延时加载
 */
public class SingletonDemo1 {

//1.私有化构造
private SingletonDemo1(){

}

//2.生成一个实例对象，类加载的时候生成
private static SingletonDemo1 instance = new SingletonDemo1();

//3.向外提供一个公有、静态的方法提供该单例对象
public static SingletonDemo1 getInstance(){
return instance;
}
}


2. 懒汉式（资源利用效率高，实现了懒加载，但是并发调用效率低，由于每次都要加锁所以浪费系统资源）




/**
 * 懒汉式
 * 优点:延迟加载
 * 缺点:加锁,调用效率低
 */
public class SingletonDemo2 {

//1.私有化构造
private SingletonDemo2(){

}

//2.声明一个私有的,静态的成员变量
private static SingletonDemo2 instance ;

//3.向外提供一个公有、静态的方法提供该单例对象
public static synchronized SingletonDemo2 getInstance(){
if (instance == null) {
instance = new SingletonDemo2();
}
return instance;
}
}


3. 双重检测锁（由于编译器优化原因，和JVM底层模型问题，偶尔会出问题，不建议使用）




/**
 * 双重检测锁机制
 */
public class SingletonDemo3 {

//1.私有化构造
private SingletonDemo3(){

}

//2.声明一个私有的,静态的成员变量
private static SingletonDemo3 instance ;

//3.向外提供一个公有、静态的方法提供该单例对象
public static synchronized SingletonDemo3 getInstance(){
if (instance == null) {
//instance为空时加锁
synchronized (SingletonDemo3.class) {
if (instance == null) {
instance = new SingletonDemo3();
}
}
}
return instance;
}
}
  1. 静态内部类
    • 外部类没有static，所以静态内部类不会在外部类加载的时候初始化，所以就实现了懒加载。
    • 线程安全，因为实例对象是在静态内部类加载的时候创建，所以天然是单例的。
/**
 * 静态内部类
 * 1.延时加载
 * 2.线程安全
 * 外部类加载时内部类不会加载
 */
public class SingletonDemo4 {

//1.私有化构造
private SingletonDemo4(){

}

//2.声明一个静态内部类
private static class SingletonDemo4Instance{
//在静态内部类里面声明一个公有的、静态的成员变量，并赋值为外部类的单例对象
public static SingletonDemo4 instance = new SingletonDemo4();
}

//3.向外提供一个公有、静态的方法提供该单例对象
public static synchronized SingletonDemo4 getInstance(){
//内部类加载
return SingletonDemo4Instance.instance;
}
}


5. 枚举实现单例（线程安全，天然就是单例的，能避免反射和反序列化带来的问题，但是不能懒加载）。

/**
 * 枚举
 * 防止反射破坏单例，防止反序列化破坏单例
 */
public enum SingletonDemo5 {
INSTANCE;

}


**单例中的问题**

        //反射
        //第一步获取字节码文件
        Class<SingleTon01> claz = SingleTon01.class;
        //claz获得无参构造器
        Constructor<SingleTon01> constructor = claz.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        SingleTon01 instance2 = constructor.newInstance();
反射和反序列化会导致单例失效。

        /**
         * 在单例中如何防止反射和反序列化
         */
        public class SingletonDemo6 implements Serializable{

            /**
             * 序列号
             */
            private static final long serialVersionUID = -3652977293498762554L;

            //1.私有化构造
            private SingletonDemo6(){
                if (instance != null) {
                    //已经生成对象，不能再调用该方法
                    throw new RuntimeException();
                }
            }

            //2.声明一个私有的,静态的成员变量
            private static SingletonDemo6 instance = new SingletonDemo6() ;

            //3.向外提供一个公有、静态的方法提供该单例对象
            public static synchronized SingletonDemo6 getInstance(){
                return instance;
            }

            /**
             * 反序列化通过该方法来获取反序列化后的对象
             * @return
             * @throws ObjectStreamException
             */
            private Object readResolve() throws ObjectStreamException{
                return instance;
            }
        }

## 简单工厂模式 又称为静态工厂模式##

**应用场景**

用来生产同一结构中的任意产品。

**缺点**

不符合“开放封闭原则”，要新创建产品的话就要去修改工厂类。

        /**
         * 动物工厂
         */
        public class AnimalFactory {

            public static Animal createAnimal(String animal){
                if ("dog".equals(animal)) {
                    return new Dog();
                } else if ("cat".equals(animal)) {
                    return new Cat();
                }else {
                    return null;
                }
            }
        }

## 工厂方法模式 ##

**应用场景**

用来生产同一等级结构中的固定产品。（支持增加任意产品）

**缺点**

虽然符合“开放封闭原则”，但是会增加很多个类。

        /**
         * 工厂基类
         */
        public abstract class BaseFactory {

            /**
             * 生产动物
             * @return
             */
            public abstract Animal createAnimal();
        }

        /**
         * 猫工厂
         */
        public class CatFactory extends BaseFactory{

            /**
             * 生产猫
             * @return
             */
            public Animal createAnimal(){
                return new Cat();
            }
        }

        /**
         * 狗工厂
         */
        public class DogFactory extends BaseFactory{

            /**
             * 生产狗
             * @return
             */
            public Animal createAnimal(){
                return new Dog();
            }
        }

## 抽象工厂模式 ##

**抽象工厂模式**

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过你改过抽象工厂模式产生需要的对象是一种非常好的解决方式。

例子：高端汽车工厂创建高端发动机、高端座椅、高端轮胎，低端汽车工厂创建低端的。

        /**
         * 发动机
         */
        public abstract class Engine {
            public abstract void start();
        }

        /**
         * 高端发动机
         */
        class HighEngine extends Engine{
            @Override
            public void start() {
                System.out.println("高端发动机提速特别快！");
            }
        }

        /**
         * 低端发动机
         */
        class LowEngine extends Engine{
            @Override
            public void start() {
                System.out.println("低端发动机启动非常慢！");
            }
        }

        /**
         * 座椅
         */
        public abstract class Seat {
            public abstract void Seat();
        }

        /**
         * 高级座椅
         */
        class HighSeat extends Seat{

            @Override
            public void Seat() {
                System.out.println("真皮座椅！");
            }

        }

        /**
         * 低级座椅
         */
        class LowSeat extends Seat{

            @Override
            public void Seat() {
                System.out.println("仿皮座椅！");
            }

        }

        /**
         * 轮胎
         */
        public abstract class Tyre {
            public abstract void run();
        }

        /**
         * 高级轮胎
         */
        class HighTyre extends Tyre{

            @Override
            public void run() {
                System.out.println("磨损很小！");
            }

        }

        /**
         * 低级轮胎
         */
        class LowTyre extends Tyre{

            @Override
            public void run() {
                System.out.println("磨损很大！");
            }

        }

        /**
         * 工厂基类
         */
        public abstract class BaseFactory {

            /**
             * 生产发动机
             * @return
             */
            public abstract Engine createEngine();
            /**
             * 生产轮胎
             * @return
             */
            public abstract Tyre createTyre();
            /**
             * 生产座椅
             * @return
             */
            public abstract Seat createSeat();
        }

        /**
         * 低端工厂
         */
        public class LowFactory extends BaseFactory {

            @Override
            public Engine createEngine() {
                return new LowEngine();
            }

            @Override
            public Tyre createTyre() {
                return new LowTyre();
            }

            @Override
            public Seat createSeat() {
                return new LowSeat();
            }

        }

        /**
         * 高端工厂
         */
        public class HighFactory extends BaseFactory {

            @Override
            public Engine createEngine() {
                return new HighEngine();
            }

            @Override
            public Tyre createTyre() {
                return new HighTyre();
            }

            @Override
            public Seat createSeat() {
                return new HighSeat();
            }

        }


## 建造者模式 ##
**场景**

创建一个对象时需要构建很多个小部分，然后按照一定的步骤装配起来。在使用的时候常常配合工厂模式来使用。实现了构建和装配的解耦。

* StringBuilder的append方法。
* DomBuilder。

组成部分

* CadillacCar:tyre,engine,seat
* CarBuilder:buildTyre，buildEngine，buildSeat构建者
* Director:directCar装配者，里面要传入builder对象

客户端只需要找装配者要产品，装配者找构建者要元件去装配

        /**
         *Cadillac汽车
         */
        public class CadillacCar extends Car {
            private Engine engine;
            private Seat seat;
            private Tyre tyre;
            @Override
            public void run() {
                engine.start();
                tyre.run();
                seat.Seat();
            }
            public Engine getEngine() {
                return engine;
            }
            public void setEngine(Engine engine) {
                this.engine = engine;
            }
            public Seat getSeat() {
                return seat;
            }
            public void setSeat(Seat seat) {
                this.seat = seat;
            }
            public Tyre getTyre() {
                return tyre;
            }
            public void setTyre(Tyre tyre) {
                this.tyre = tyre;
            }
        }

        /**
         * 构建者，构建元件
         */
        public class CadillacBuilder implements IBuilder {

            @Override
            public Engine buildEngine() {
                //如果配合抽象工厂使用，效果是不是更佳？
                return new HighEngine();
            }

            @Override
            public Tyre buildTyre() {
                return new HighTyre();
            }

            @Override
            public Seat buildSeat() {
                return new HighSeat();
            }

        }

        /**
         * 装配者，组装构建者构建的元件
         */
        public class CadillacDerictor implements IDerictor {

            @Override
            public Car derictCar(IBuilder builder) {
                CadillacCar car = new CadillacCar();
                Engine engine = builder.buildEngine();
                Tyre tyre = builder.buildTyre();
                Seat seat = builder.buildSeat();
                car.setEngine(engine);
                car.setTyre(tyre);
                car.setSeat(new LowSeat());
                return car;
            }

        }


## 适配器模式 ##
**生活中的场景**
![](http://i.imgur.com/NbjEWkB.jpg)
**定义**

将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能在一起工作的那些类能够一起工作。

**模式中的角色**
* Client ：客户，相当于我们的笔记本电脑。(只认USB接口)（接手代码之后，新写的功能类）
* 目标结构（Target）：客户所期待的接口。目标接口可以是具体的或者抽象的类，也可以是接口。相当于USB接口
* 需要适配的类（Adaptee）：可以理解成PS2接口。（相当于，以前的程序员遗留下来的类）
* 适配器（Adapter）：通过包装一个需要适配的对象，把原有的接口转换成目标接口。

**客户Client想直接使用Adaptee,但是使用不了，那么我们就定义一个适配器Adapter，客户只需要跟Adapter打交道就行**

**类适配器**

Adapter 继承Adaptee、实现Target接口

**对象适配器**

使用组合的方式，实现Target接口，将Adaptee对象通过构造函数传入Adapter类中。

**接口适配器**

**工作中应用场景**
* 经常用来做旧系统改造和升级
* 学习中见过的场景InputStreamReader(InputStream)

        /**
         * 需要被适配的对象
         */
        public class Adaptee {

            public void handleRequest(){
                System.out.println("原来的老代码");
            }
        }

        /**
         * 新增加的功能类
         */
        public class Client {

            public void test(Target target){
                target.request();
            }
        }

        /**
         * 客户所期待的接口
         */
        public interface Target {
            void request();
        }

        /**
         * 类适配器
         */
        public class ClassAdapter extends Adaptee implements Target {

            @Override
            public void request() {
                this.handleRequest();
            }

        }

        /**
         * 对象适配器
         */
        public class ObjectAdapter implements Target{

            private Adaptee adaptee;

            public ObjectAdapter(Adaptee adaptee) {
                this.adaptee = adaptee;
            }

            @Override
            public void request() {
                adaptee.handleRequest();
            }

        }

## 观察者模式 ##
**实际生活中的一些场景**

* 广播机制。
* 订阅邮件。
* 消息推送

**模式中的角色**

* 目标对象，Subject，被观察的对象，当它的状态变化时，它需要及时通知一系列的对象。
* Observer，观察者。

**通知观察者的方式**
* 推，每次都会通知以广播方式发给所有观察者，所有观察者只能被动接受。
* 拉，观察者只要知道有情况变化即可。至于什么时候获取内容，要不要获取内容，都可以由观察者自己决定。

**自定义观察者模式**

* Subject中有addObserver(Oberver o)和removeObserver(Observer o)方法添加或移除观察者，有notifyAllObservers()方法来通知所有观察者对象发生改变了。
* Observer，里面有updata方法，用于接收到改变通知后作出相应的更新。

        /**
         *观察者的接口
         */
        public interface IObserver {
            /**
             * 接收到消息之后的反应
             * @param object
             */
            void updata(Object object);
        }

        /**
         *被观察者的接口
         */
        public interface ISubject {
            /**
             * 添加观察者
             * @param observer
             */
            void addObserver(IObserver observer);
            /**
             * 移除观察者
             * @param observer
             */
            void removeObserver(IObserver observer);
            /**
             * 通知所有观察者
             */
            void notifyAllObservers();
        }


        /**
         * 学生实现观察者
         */
        public class Student implements IObserver{

            @Override
            public void updata(Object object) {

            }

        }

        class ZhangSan implements IObserver{
            @Override
            public void updata(Object object) {
                System.out.println("张三收到！" + object);
            }
        }
        class Lisi implements IObserver{
            @Override
            public void updata(Object object) {
                System.out.println("李四收到！" + object);
            }
        }
        class WangWu implements IObserver{
            @Override
            public void updata(Object object) {
                System.out.println("王五收到！" + object);
            }
        }
        class ZhaoLiu implements IObserver{
            @Override
            public void updata(Object object) {
                System.out.println("赵六收到！" + object);
            }
        }
        class Lvdan implements IObserver{
            @Override
            public void updata(Object object) {
                System.out.println("驴蛋收到！" + object);
            }
        }


        /**
         * 教师实现被观察者
         */
        public class Teacher implements ISubject {
            List<IObserver> observers = new ArrayList<>();
            @Override
            public void addObserver(IObserver observer) {
                observers.add(observer);
            }

            @Override
            public void removeObserver(IObserver observer) {
                observers.remove(observer);
            }

            @Override
            public void notifyAllObservers() {
                for (int i = 0; i < observers.size(); i++) {
                    IObserver observer = observers.get(i);
                    observer.updata("老师这里有好资源！");
                }
            }

        }

        public static void main(String[] args) {
            ZhangSan zhangSan = new ZhangSan();
            Lisi lisi = new Lisi();
            WangWu wangWu = new WangWu();
            ZhaoLiu zhaoLiu = new ZhaoLiu();
            Teacher teacher = new Teacher();
            teacher.addObserver(zhangSan);
            teacher.addObserver(lisi);
            teacher.addObserver(wangWu);
            teacher.removeObserver(wangWu);
            teacher.addObserver(zhaoLiu);
            //我这里有新资源了
            teacher.notifyAllObservers();
        }
**Java中内置的观察者**

* Observable 是一个类，目标对象/被观察者继承它 当数据发生改变时，调用setChanged()表示目标状态发生改变，调用notifyObservers(Object o)来通知所有的观察者
* Observer 是一个接口，观察者实现它，能接收到目标改变的值或对象

        /**
         * 雇主继承被观察者
         */
        public class Employer extends Observable {

            /**
             * 数据更新
             */
            public void update(Object object){
                setChanged();
                notifyObservers(object);
            }
        }

        /**
         * 雇员实现观察者
         */
        public class Employee implements Observer {

            /**
             * 接收更新数据
             */
            @Override
            public void update(Observable o, Object arg) {
                System.out.println("收到,"+arg);
            }

        }

        @Test
        public void test(){
            Employee employee = new Employee(); 
            Employer employer = new Employer();
            employer.addObserver(employee);
            employer.update("加班！");
        }
## 代理模式 ##

**Proxy**

***核心作用***：

* 通过代理可以控制对对象的访问，以周杰伦为例：合作商找周杰伦演出包含流程：面谈、起草合同、收预付款、订机票、唱歌、收尾款。可以找一个经纪人（代理）来处理与核心业务无关的事情、周杰伦只负责唱歌即可。而且一个经纪人可以代理很多明星。
* 微商，代理一款产品，实际发货的是——大老板，发朋友圈、和人聊天、拉下线、确定购买意向、收款、求好评等等。
* 代理可以详细控制访问某个对象的方法，在调用该方法钱做前置处理，调用这个方法后做后置处理。

***核心角色***：

* 抽象角色：定义代理角色和真实角色的公共对外方法，代理角色与真是角色都得去实现抽象角色。
* 真实角色：实现抽象角色，定义真实角所要实现的业务逻辑，供代理角色调用。
* 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。（将统一的流程控制代码放到代理类中处理）

***应用场景***

* 安全代理：屏蔽客户对真实角色的直接访问
* 远程代理：通过代理类处理远程方法的调用。
* 延迟加载： 先加载轻量级的代理对象，真正需要再加载真实对象。（如大图片问题）。

***分类***

* 静态代理（静态定义代理类）
* 动态代理（动态生成代理类）

    * JDK中自带的动态代理

***静态代理案例***

* MaskFactory接口：包含发货方法
* MaskFactory类：真实角色，真正负责发货。
* ProxyMaskFactory：代理类，里面传入真实对象实现发货。

***缺点***
* 1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。 

* 2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。 相较静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样我们可以更加灵活和统一的处理众多的方法。

        /**
         * 公司
         * 抽象角色，里面定义的是代理角色与真实角色的共同方法
         */
        public interface Company {

            /**
             * 商演活动
             */
            public abstract void performance();
        }

        /**
         * 明星
         */
        public class Star implements Company{

            @Override
            public void performance() {
                System.out.println("在深圳表演");
            }

        }

        /**
         * 经纪人
         */
        public class Agent implements Company {

            private Company company;

            public Agent(Company company){
                this.company = company;
            }

            @Override
            public void performance() {
                System.out.println("买机票");
                //调用明星的表演方法
                company.performance();
                System.out.println("收尾款");
            }

        }

***动态代理***
* 动态代理里面抽象角色只能是接口
* java.lang.reflect.Proxy
    * 作用：动态生成代理类和对象，Proxy.newProxyInstance
* java.lang.reflect.InvocationHandler(处理器接口)
    * 可以通过invoke方法实现对真实角色的访问。method.invoke
    * 每次通过Proxy生成代理类对象时都要指定对应的处理器对象。

        /**
         * 公司
         * 抽象角色，里面定义的是代理角色与真实角色的共同方法
         */
        public interface Company {

            /**
             * 商演活动
             */
            void performance();

            /**
             * 与粉丝互动
             */
            void interaction();
        }

        /**
         * 明星
         */
        public class Star implements Company{

            @Override
            public void performance() {
                System.out.println("在深圳表演");
            }

            @Override
            public void interaction() {
                System.out.println("与粉丝互动");
            }

        }

        /**
         * 票
         */
        public interface Ticket {

            /**
             * 买票
             */
            void buyTicket();
        }

        /**
         * 机票
         */
        public class AirTicket implements Ticket {

            /**
             * 买机票
             */
            @Override
            public void buyTicket() {
                System.out.println("代理买机票");
            }

        }

        /**
         * 经纪人
         */
        public class Agent implements InvocationHandler {

            private Object obj;

            /**
             * 代理明星谈一场商演
             * @param obj
             * @return
             */
            public Object deal(Object obj){
                this.obj = obj;
                return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
            }

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("谈价格");
                //调用明星的表演方法
                method.invoke(obj, args);
                System.out.println("收尾款");
                return null;
            }

        }

        @Test
        public void test(){
            Agent agent = new Agent();
            Company company = (Company) agent.deal(new Star());
            company.performance();
            company.interaction();
            //换活动，代理商演改代理买机票
    //      Ticket ticket = (Ticket) agent.deal(new AirTicket());
    //      ticket.buyTicket();
        }

## 装饰者模式 ##

***职责***

* 动态的为一个对象增加新的功能。
* 装饰模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代理继承关系，更加灵活，同时避免类型体系的快速膨胀。
* 例子：各种各样的车（飞行、潜水、人工智能）


        public String download(String urlStr){
                StringBuffer sb = new StringBuffer();
                String line = null;
                BufferedReader buffer = null;

                try {
                    url = new URL(urlStr);
                    HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
                   //装饰者模式
                    buffer = new BufferedReader(new InputStreamReader(urlConn.getInputStream()));
                    while ((line = buffer.readLine()) != null){
                        sb.append(line);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                finally{
                    try {
                        buffer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            return sb.toString();  
        }
***实现细节（装饰者和被装饰者实现共同的父类，将被装饰者对象传入装饰者中）***

* Component：抽象构件角色
    * 被装饰对象和装饰对象有相同的父类。这样，客户端对象就能够以与被装饰对象相同的方式与装饰对象交互。
* ConcreteComponent:具体构件角色（被装饰对象）

* Decorator：装饰角色
    * 持有一个抽象构件的引用。装饰对象接收所有客户端的请求，并把这些请求转发给真实的对象（被装饰对象）。这样，就能在真实对象（被装饰对象）调用前后增加新的功能。
* ConcreteDecorator：具体装饰角色
    * 负责给真实对象（被装饰对象）增加新的功能。

***常见的应用场景***

* IO流中的Reader r = new BufferedReader(new InputStream(new File("xxxx.txt")));

        /**
         *抽象构件角色
         */
        public abstract class Vehicle {
            public abstract void run();
        }

        /**
         *装饰者，持有被装饰者的引用
         */
        public abstract class SurperVehicle extends Vehicle {
            public Vehicle vehicle;
            public SurperVehicle(Vehicle vehicle) {
                super();
                this.vehicle = vehicle;
            }
        }

        /**
         *被装饰者
         */
        public class Car extends Vehicle {
            @Override
            public void run() {
                System.out.println("可以在陆地上跑！");
            }
        }

        /**
         * 自动驾驶汽车
         */
        public class AutoCar extends SurperVehicle {

            public AutoCar(Vehicle vehicle) {
                super(vehicle);
            }
            public void autoRun(){
                System.out.println("可以自动驾驶！");
            }
            @Override
            public void run() {
                autoRun();
                vehicle.run();
            }

        }

## 策略模式 ##

**场景**某个市场人员接到单后的报价策略。报价策略很复杂，可以简单做如下分类：

* 普通客户小批量报价
* 普通客户大批量报价
* 老客户小批量报价
* 老客户大批量报价

具体采用哪个报价策略，这需要根据实际情况来确定，这时候我们就可以采用策略模式。

可以采用条件判断来实现策略，但是不符合“开放封闭原则”，而且随着逻辑越来越复杂，代码也越来越冗余。 

**定义：**策略模式对应于解决某一个问题的一个算法族，允许用户从该算法族中任选一个算法解决某个问题，同时可以方便的更换算法或者增加新的算法。并且由客户端决定调用哪个算法。

**组成部分：**

* Manager：里面包含算法实例对象和具体的实现方法，负责和具体的策略类打交道，客户端直接与Manager类打交道即可。
* Strategy:算法接口
* 具体的算法类。



    /**
     *策略接口
     */
    public interface IStrategy {
        /**
         * 展示价格
         * @param price
         * @return
         */
        double showPrice(double price);
    }

    public class NewBigStrategy implements IStrategy {
        @Override
        public double showPrice(double price) {
            return price*0.90;
        }
    }

    public class NewLittleStrategy implements IStrategy {
        @Override
        public double showPrice(double price) {
            return price*0.98;
        }
    }

    public class OldBigStrategy implements IStrategy {
        @Override
        public double showPrice(double price) {
            return price*0.8;
        }
    }

    public class OldLittleStrategy implements IStrategy {
        @Override
        public double showPrice(double price) {
            return price*0.88;
        }
    }

    /**
     *策略管理类，客户端只要跟这个类打交道就ok。
     */
    public class StrategyManager {
        public double showPrice(IStrategy strategy,double price){
            return strategy.showPrice(price);
        }
    }

    public static void main(String[] args) {
        StrategyManager strategyManager = new StrategyManager();
        double price = strategyManager.showPrice(new OldLittleStrategy(), 100);
        System.out.println(price);
    }

“`

前端控制器模式

前端控制器模式:是用来提供一个集中的请求处理机制,所有的请求都将由一个单一的处理程序处理,该处理程序可以做认证/授权/记录日志,或者跟踪请求,然后把请求传给然后把请求传给相应的处理程序。

案例:struts2的前端控制器StrutsPrepareAndExecuteFilter

责任链模式

责任链模式:为请求创建了一个接收者对象的链,这种模式给予请求的类型,对请求的发送者和接收者进行解耦,这种类型的设计模式属于行为型模式.

宏微
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式学习一概览
liushangzaibeijing的博客
06-14 1万+
学习设计模式专栏开篇博文，介绍了学习设计模式的重要性和学习步骤，后面会针对所有设计模式进行详细的学习使用。
设计模式学习之策略模式
一个码农的博客
04-11 7万+
写代码时总会出很多的if…else，或者case。如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿，维护的成本也会加大，而策略模式就能较好的解决这个问题，本篇博客就带你详细了解策略模式。策略模式的定义和使用场景定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替
Java设计模式学习总结
Java技术江湖
07-08 5689
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
软件设计模式学习总结
Aatroy的博客
11-27 9337
软件设计模式的个人理解软件设计模式的简单分类面向对象的设计的7项原则简介创建型模式 软件设计模式的简单分类 GoF（Gang of Four）的 23 种设计模式： 创建型模式：单原工抽建 结构型模式：代适桥装，外享组 行为型模式：模策命，取状观，中迭访备解 面向对象的设计的7项原则简介 软件开发中，程序员要尽量根据以下7条原则来开发程序，从而提高软件的开发效率、节约软件开发成本和维护成本。 开闭原则 里氏替换原则 依赖倒置原则 单一职责原则 接口隔离原则 迪米特法则 合成复用原则 创建
23种设计模式学习
weixin_48838762的博客
08-28 1471
设计模式 参考：bilibili尚硅谷教程 一、七大设计原则 设计模式目的： 1)代码重用性(即:相同功能的代码，不用多次编写) 2)可读性(即:编程规范性，便于其他程序员的阅读和理解) 3)可扩展性(即:当需要增加新的功能时，非常的方便，称为可维护) 4)可靠性(即:当我们增加新的功能后，对原来的功能没有影响) 5)使程序呈现高内聚，低耦合的特性 核心思想： 1)找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 2)针对接口编程，而不是针对实现编程。 3)为了交互对象之间的
设计模式23模式介绍
热门推荐
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式学习汇总
大鱼的博客
03-04 1万+
设计模式学习汇总 设计模式——工厂模式 持续更新！！！！！ 写作不易，如果您觉得写的不错，欢迎给博主点赞、收藏、评论、收藏来一波~让博主更有动力吧！ 路漫漫其修远兮，吾必将上下求索~ ...
设计模式学习心得
01-11 2665
最近看了点设计模式，以前就听说各种设计模式看了以后会觉得他们非常像，别说还真是，看到现在也是感觉脑子一团浆糊，真是觉得各种模式很像，比如说适配器模式和代理模式，都是持有目标对象然后去调用他们的方法，中间的区别就在于，适配器模式和目标对象不用实现同一个接口，而代理模式和被代理对象是需要实现同一个接口，不仅感慨设计模式这个东西还真是一个细致的东西，学习了一阵之后最大的一个感悟就是，设计模式最终的目的就
设计模式学习之访问者模式
一个码农的博客
04-23 3万+
访问者模式，是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。 访问者模式的基本想法是，软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是
23种设计模式学习导航（Java完整版）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-04 7065
本篇文章是作者对23种设计模式学习的一个总结，包含设计模式的三大分类（创建型5种，结构型7种，行为型11种）和七个面向对象设计原则，为了方便大家学习，现将23种设计模式的连接进行了整理，希望对大家有所帮助。ps：后续会带来设计模式的组合使用，敬请期待。
设计模式学习资料设计模式学习资料
07-09
设计模式学习资料设计模式学习资料
设计模式学习资料
03-01
Java设计模式，解说通俗易懂，推荐新手学习使用，文档中包含类图
C++20设计模式学习笔记-第7章桥接模式学习代码
02-06
C++20设计模式学习笔记-第7章桥接模式学习代码
结构型设计模式—桥接模式
最新发布
-
09-03 691
桥接模式是一种很实用的结构型设计模式。如果软件系统中某个类存在两个独立变化的维度，通过该模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合单一职责原则。与多层继承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。桥接模式用一种巧妙的方式处理多层继承存在的问题。
设计模式 18 备忘录模式
小小程序猿
09-02 713
备忘录模式的核心思想是将对象的状态保存在一个备忘录对象中，并允许在未来的某个时刻恢复该状态。备忘录模式保证了状态的封装性，外部对象无法直接访问备忘录中的内容，从而保护了原发器对象的内部细节。备忘录模式通过保存对象的状态，提供了恢复该状态的机制。它通过封装状态，确保了对象内部细节的保护，同时又允许状态的恢复。该模式非常适合用于实现“撤销/恢复”功能，并在需要管理复杂状态变更的场景中提供了很好的解决方案。
设计模式之原型模式
2301_76862031的博客
08-31 504
原型模式实现克隆的两种方式，深克隆，创建对象克隆，java代码实现，运行结果 通过复制一个现有的对象实例来创建新对象，而不是通过直接实例化对象。这样可以避免构造过程中的开销，并允许根据需要定制对象的创建过程。
java设计模式day01--（类之间的关系、软件设计原则、单例设计模式）
m0_62388400的博客
08-29 1089
用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。
设计模式-原型&适配器&桥接&外观
m0_74380601的博客
09-03 854
原型模式是一种不太常见的创建型模式，我们平时的工作中几乎不会遇到这种模式，但是在一些框架设计中会用到，这里我们只做了解即可。在类适配器模式中，适配器与被适配者之间是继承关系。在对象适配器模式中，适配器与被适配者之间是关联关系；不论是类适配器还是对象适配器，适配器模式都将现有接口转化为客户类所期望的接口，实现了对现有类的复用（不用修改目标抽象类）。推荐使用对象适配方式，因为耦合度低，符合合成复用原则。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值