设计模式学习——代理模式(Proxy Pattern)

放假啦~学生们要买车票回家了,有汽车票、火车票,等。但是,车站很远,又要考试,怎么办呢?找代理买啊,虽然要多花点钱,但是,说不定在搞活动,有折扣呢~

 1  ///
 2  /// @file    Selling_Tickets.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:35:28
 5  ///
 6
 7 #ifndef __SELLING_TICKETS_H__
 8 #define __SELLING_TICKETS_H__
 9
10 #include <iostream>
11
12 namespace marrs{
13
14 using std::cout;
15 using std::endl;
16
17 class SellingTickets
18 {
19     public:
20         virtual ~SellingTickets(){}
21
22     public:
23         virtual void Selling() = 0;
24         virtual void Price() = 0;
25
26 };
27
28 }
29
30 #endif // __SELLING_TICKETS_H__
 1  ///
 2  /// @file    Tickets.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:39:17
 5  ///
 6
 7 #ifndef __TICKETS_H__
 8 #define __TICKETS_H__
 9
10 #include "Selling_Tickets.h"
11
12 namespace marrs{
13
14 class Tickets
15 : public SellingTickets
16 {
17
18 };
19
20 }
21
22 #endif // __TICKETS_H__
 1  ///
 2  /// @file    Bus_Ticket.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:41:08
 5  ///
 6
 7 #ifndef __BUS_TICKET_H__
 8 #define __BUS_TICKET_H__
 9
10 #include "Tickets.h"
11
12 namespace marrs{
13
14 class BusTicket
15 : public Tickets
16 {
17     public:
18         void Selling()
19         {
20             cout << "selling : BusTicket" << endl;
21         }
22
23         void Price()
24         {
25             cout << "price   : 80 RMB" << endl;
26         }
27 };
28
29 }
30
31 #endif // __BUS_TICKET_H__
 1  ///
 2  /// @file    Train_Ticket.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:41:08
 5  ///
 6
 7 #ifndef __TRAIN_TICKET_H__
 8 #define __TRAIN_TICKET_H__
 9
10 #include "Tickets.h"
11
12 namespace marrs{
13
14 class TrainTicket
15 : public Tickets
16 {
17     public:
18         void Selling()
19         {
20             cout << "selling : TrainTicket" << endl;
21         }
22
23         void Price()
24         {
25             cout << "price   : 100 RMB" << endl;
26         }
27 };
28
29 }
30
31 #endif // __TRAIN_TICKET_H__
 1  ///
 2  /// @file    Proxy.h
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:46:13
 5  ///
 6
 7 #ifndef __PROXY_H__
 8 #define __PROXY_H__
 9
10 #include "Tickets.h"
11
12 namespace marrs{
13
14 class Proxy
15 : public SellingTickets
16 {
17     public:
18         Proxy(Tickets * ticket)
19         : _ticket(ticket)
20         {
21         }
22
23         ~Proxy()
24         {
25             delete _ticket;
26         }
27
28     public:
29         void Selling()
30         {
31             _ticket->Selling();
32         }
33
34         void Price()
35         {
36             _ticket->Price();
37             Proxy_Price();
38             Discount();
39         }
40
41     private:
42         void Proxy_Price()
43         {
44             cout << "proxy price : 50 RMB" << endl;
45         }
46
47         void Discount()
48         {
49             cout << "discount    : 50%" << endl;
50         }
51
52     private:
53         Tickets * _ticket;
54
55 };
56
57 }
58
59 #endif // __PROXY_H__
 1  ///
 2  /// @file    Student.cc
 3  /// @author  marrs([email protected])
 4  /// @date    2017-08-13 20:51:42
 5  ///
 6
 7 #include "Proxy.h"
 8 #include "Bus_Ticket.h"
 9 #include "Train_Ticket.h"
10
11 using namespace marrs;
12
13 int main()
14 {
15     Proxy * proxy;
16     proxy = new Proxy(new BusTicket);
17     proxy->Selling();
18     proxy->Price();
19     delete proxy;
20
21     proxy = new Proxy(new TrainTicket);
22     proxy->Selling();
23     proxy->Price();
24     delete proxy;
25
26     return 0;
27 }

编译,运行

[[email protected] ~/object-oriented/Proxy_Pattern]$>g++ * -o Tickets.exe
[[email protected] ~/object-oriented/Proxy_Pattern]$>./Tickets.exe
selling : BusTicket
price   : 80 RMB
proxy price : 50 RMB
discount    : 50%
selling : TrainTicket
price   : 100 RMB
proxy price : 50 RMB
discount    : 50%
时间: 2024-10-28 10:23:57

设计模式学习——代理模式(Proxy Pattern)的相关文章

设计模式之代理模式---Proxy Pattern

模式的定义 代理模式(Proxy Pattern)也叫做委托模式,定义如下: Provide a surrogate or placeholder for another object to control access to is. 为其他对象提供一种代理以控制对这个对象的访问. 类型 结构类 模式的使用场景 想想现实世界中,打官司为什么要找个律师?因为你不想参与中间过程的是是非非,只要完成自己的工作就可以,其它的事情比如事前调查,事后追查都可以由律师来负责,这就可以减少你的负担.代理模式使用

二十三种设计模式[12] - 代理模式(Proxy Pattern)

前言 代理模式,属于对象结构型模式.在<设计模式 - 可复用的面向对象软件>一书中将之描述为" 为其它对象提供一种代理以控制对这个对象的访问 ". 在代理模式中,通常使用一个类来代表另一个类的功能,并由这个代理对象去控制原对象的引用. 结构 Subjuet(公共接口):代理类和被代理类的公共接口,保证任何使用目标的地方都可以被代理类替换: RealSubject(被代理类):代理类所代表的目标类: Proxy(代理类):包含对目标类的引用,目标类的封装: 场景 在日常生活中

设计模式 - 代理模式(proxy pattern) 未使用代理模式 详解

代理模式(proxy pattern) 未使用代理模式 详解 本文地址: http://blog.csdn.net/caroline_wendy 部分代码参考: http://blog.csdn.net/caroline_wendy/article/details/37698747 如果需要监控(monitor)类的某些状态, 则需要编写一个监控类, 并同过监控类进行监控. 但仅仅局限于本地, 如果需要远程监控, 则需要使用代理模式(proxy pattern). 具体方法: 1. 类中需要提供

设计模式三: 代理模式(Proxy) -- JDK的实现方式

设计模式三: 代理模式(Proxy) -- JDK的实现方式 简介 代理模式属于行为型模式的一种, 控制对其他对象的访问, 起到中介作用. 代理模式核心角色: 真实角色,代理角色; 按实现方式不同分为静态代理和动态代理两种; 意图 控制对其它对象的访问. 类图 实现 JDK自带了Proxy的实现, 下面我们先使用JDK的API来演示代理如何使用, 随后再探究Proxy的实现原理,并自己来实现Proxy. JDK代理类的使用: (InvocationHandler,Proxy) 使用JDK实现的代

设计模式之代理模式(Proxy)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

Android设计模式之代理模式 Proxy

一.概述 代理模式也是平时比较常用的设计模式之一,代理模式其实就是提供了一个新的对象,实现了对真实对象的操作,或成为真实对象的替身.在日常生活中也是很常见的.例如A要租房,为了省麻烦A会去找中介,中介会替代A去筛选房子,A坐享中介筛选的结果,并且交房租也是交给中介,这就是一个典型的日常生活中代理模式的应用.平时打开网页,最先开到的一般都是文字,而图片等一些大的资源都会延迟加载,这里也是使用了代理模式. 代理模式的组成: Abstract Subject:抽象主题-声明真实主题和代理主题共同的接口

大熊君说说JS与设计模式之------代理模式Proxy

一,总体概要 1,笔者浅谈 当我们浏览网页时,网页中的图片有时不会立即展示出来,这就是通过虚拟代理来替代了真实的图片,而代理存储了真实图片的路径和尺寸,这就是代理方式的一种. 代理模式是比较有用途的一种模式,而且变种较多(虚代理.远程代理.copy-on-write代理.保护代理.Cache代理.防火墙代理.同步代理.智能指引),应用场合覆盖从小结构到整个系统的大结构, 我们也许有代理服务器等概念,代理概念可以解释为:在出发点到目的地之间有一道中间层,意为代理. 代理对象角色内部含有对真实对象的

设计模式学习——代理模式(Proxy Pattern)之 强制代理(强校验,防绕过)

上周温习了代理模式:http://www.cnblogs.com/chinxi/p/7354779.html 在此进行拓展,学习强制代理.但是发现网上大多例子都有个"天坑"(我是这么认为的),在得到代理类之后,真实对象也可以使用自己的方法,绕过了代理,这样使得代理没有了意义. 关于强制代理,字面上意思很清晰,即: 1.只能通过真实对象获取代理类来访问方法 2.其他方法比如直接new 一个代理类 访问方法(不通过本体获取),或是自己通过本体直接调用,都不行 网络上搜到的例子大多是这样的:

设计模式(结构型)之代理模式(Proxy Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(结构型)之享元模式(Flyweight Pattern)>http://blog.csdn.net/yanbober/article/details/45477551 概述 代理模式是常用的结构型设计模式之一,当无法直接访问某个对象或访问某个对象存在困难时可以通过一个

设计模式之(二)---代理模式Proxy Pattern

什么是代理模式呢?我很忙,忙的没空理你,那你要找我呢就先找我的代理人吧,那代理人总要知道 被代理人能做哪些事情不能做哪些事情吧,那就是两个人具备同一个接口,代理人虽然不能干活,但是被 代理的人能干活呀. 比如西门庆找潘金莲,那潘金莲不好意思答复呀,咋办,找那个王婆做代理,表现在程序上时这样的: 先定义一种类型的女人(接口): package com.fc.Proxy; public interface KindWoman { public void makeEyesWithMan(); //抛媚