设计模式：策略、代理、单例

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了设计模式：策略、代理、单例，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4630字，纯文字阅读大概需要7分钟。

内容图文

一. 策略模式

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

先说这个场景中的要素：三个妙计，一个锦囊，一个赵云。

1）妙计：(一个接口，三个具体妙计)

                1
                package
                 com.henry.strategy;

                2
                3
                public
                interface
                 IStrategy {

                4
                5
                public
                void
                 operate();

                6
                7 }

IStrategy.java

                 1
                package
                 com.henry.strategy;

                 2
                 3
                public
                class BackDoor implements IStrategy {
 4 5    @Override
 6publicvoid operate() {
 7// TODO Auto-generated method stub 8         System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
 9    }
1011 }

BackDoor.java

                 1
                package
                 com.henry.strategy;

                 2
                 3
                public
                class GivenGreenLight implements IStrategy {
 4 5    @Override
 6publicvoid operate() {
 7// TODO Auto-generated method stub 8         System.out.println("求吴国太开个绿灯,放行！");
 9    }
1011 }

GivenGreenLight.java

                 1
                package
                 com.henry.strategy;

                 2
                 3
                public
                class BlockEnemy implements IStrategy {
 4 5    @Override
 6publicvoid operate() {
 7// TODO Auto-generated method stub 8         System.out.println("孙夫人断后，挡住追兵");
 9    }
1011 }

BlockEnemy.java

2）接下来就是锦囊了，用来放妙计的东东。

                 1
                package
                 com.henry.strategy;

                 2
                 3
                public
                class
                 Context {

                 4
                 5
                private
                 IStrategy strategy;

                 6
                 7
                public
                 Context(IStrategy strategy) {

                 8
                this.strategy = strategy;
 9    }
1011publicvoid operate() {
12this.strategy.operate();
13    }
14 }

Context.java

3) 最后就是赵子龙登场的时候了。

                 1
                package
                 com.henry.strategy;

                 2
                 3
                public
                class
                 ZhaoYun {

                 4
                 5
                public
                static
                void
                 main(String[] args) {

                 6
                        Context context;

                 7
                 8
                //
                刚刚到吴国的时候拆第一个
                 9         System.out.println("-----------刚刚到吴国的时候拆第一个-------------");
10         context = new Context(new BackDoor()); //拿到妙计11         context.operate(); //拆开执行12         System.out.println("");
1314//刘备乐不思蜀了，拆第二个了15         System.out.println("-----------刘备乐不思蜀了，拆第二个了-------------");
16         context = new Context(new GivenGreenLight());
17         context.operate(); //执行了第二个锦囊了18         System.out.println("");
1920//孙权的小兵追了，咋办？拆第三个21         System.out.println("-----------孙权的小兵追了，咋办？拆第三个-------------");
22         context = new Context(new BlockEnemy());
23         context.operate(); //孙夫人退兵24         System.out.println("");
25    }
2627 }

ZhaoYun.java

二. 代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

场景：比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时这样的：
1) 先定义一种类型的女人：

                1
                package
                 com.henry.proxy;

                2
                3
                public
                interface
                 KindWomen {

                4
                5
                public
                void
                 makeEyesWithMan();

                6
                public
                void
                 happyWithMan();

                7
                8 }

KindWomen.java

2) 再定一个丑陋的王婆：

                 1
                package
                 com.henry.proxy;

                 2
                 3
                public
                class WangPo implements KindWomen {
 4 5private KindWomen kindWomen;
 6 7public WangPo() {
 8this.kindWomen = new PanJinLian();
 9    }
1011public WangPo(KindWomen kindWomen) {
12this.kindWomen = kindWomen;
13    }
1415    @Override
16publicvoid makeEyesWithMan() {
17// TODO Auto-generated method stub18this.kindWomen.makeEyesWithMan();
19    }
2021    @Override
22publicvoid happyWithMan() {
23// TODO Auto-generated method stub24this.kindWomen.happyWithMan();
25    }
2627 }

WangPo.java

3) 两个女主角都上场了，男主角也该出现了：

                 1
                package
                 com.henry.proxy;

                 2
                 3
                public
                class
                 XiMenQing {

                 4
                 5
                public
                static
                void
                 main(String[] args) {

                 6         WangPo wangPo = new WangPo();
 7 8        wangPo.makeEyesWithMan();
 9        wangPo.happyWithMan();
10    }
1112 }

XiMenQing.java

　　那这就是活生生的一个例子，通过代理人实现了某种目的，如果真去掉王婆这个中间环节，直接是西
门庆和潘金莲勾搭，估计很难成就武松杀嫂事件。

　　那我们再考虑一下，水浒里还有没有这类型的女人？有，卢俊义的老婆贾氏（就是和那个固管家苟合
的那个），这名字起的：“假使”，那我们也让王婆做她的代理：

4）把贾氏素描出来：

                 1
                package
                 com.henry.proxy;

                 2
                 3
                public
                class JiaShi implements KindWomen {
 4 5    @Override
 6publicvoid makeEyesWithMan() {
 7// TODO Auto-generated method stub 8         System.out.println("贾氏抛媚眼");
 9    }
1011    @Override
12publicvoid happyWithMan() {
13// TODO Auto-generated method stub14         System.out.println("贾氏正在happy中......");
15    }
1617 }

JiaShi

5) 西门庆勾贾氏:

                 1
                package
                 com.henry.proxy;

                 2
                 3
                public
                class
                 XiMenQing2 {

                 4
                 5
                public
                static
                void
                 main(String[] args) {

                 6         JiaShi jiaShi = new JiaShi();
 7         WangPo wangPo = new WangPo(jiaShi);
 8 9        wangPo.makeEyesWithMan();
10        wangPo.happyWithMan();
11    }
1213 }

XiMenQing2.java

(1).职责清晰

真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

(2).代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的作用。

(3).高扩展性

三. 单例模式

                 1
                package
                 com.henry.singleton;

                 2
                 3
                public
                class
                 Emperor {

                 4
                private
                static Emperor emperor = null;
 5 6private Emperor() {
 7    }
 8 9publicstatic Emperor getInstance() {
10if(emperor == null) {
11             emperor = new Emperor();
12        }
13return emperor;
14    } 
1516publicstaticvoid emperorInfo(){
17         System.out.println("我就是皇帝asdasdsdssd");
18    }
19 }

Emperor.java

                 1
                package
                 com.henry.singleton;

                 2
                 3
                public
                class
                 Minister {

                 4
                public
                static
                void
                 main(String[] args) {

                 5
                //
                First Day
                 6         Emperor emperor1 = Emperor.getInstance();
 7        emperor1.emperorInfo();
 8 9//Second day10         Emperor emperor2 = Emperor.getInstance();
11        emperor2.emperorInfo();
1213//Third day14         Emperor emperor3 = Emperor.getInstance();
15        emperor3.emperorInfo();
16    }
17 }

Minister.java

原文：http://www.cnblogs.com/fanszone/p/4024644.html

内容总结

以上是互联网集市为您收集整理的设计模式：策略、代理、单例全部内容，希望文章能够帮你解决设计模式：策略、代理、单例所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1308364.html

来源：【匿名】

【下一篇】【设计模式】MVC，MVP 和 MVVM 的区别

更多 ►

【设计模式：策略、代理、单例】教程文章相关的互联网学习教程文章

一. 策略模式定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。先说这个场景中的要素：三个妙计，一个锦囊，一个赵云。1）妙计：(一个接口，三个具体妙计)1package com.henry.strategy; 23publicinterface IStrategy { 45publicvoid operate(); 67 }IStrategy.java 1package com.henry.strategy;2 3publicclass BackDoor implements IStrategy...

设计模式—代理模式【代码】

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。意图：为其他对象提供一种代理以控制对这个对象的访问。主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上...

设计模式(4)--代理模式【代码】

//4.代理模式 //ver1 //被追求者类 class SchoolGirl { private:string _name; public:SchoolGirl(){}SchoolGirl(string name){_name = name;}string GetName(){return _name;}void SetName(string name){_name = name;} };//接口函数类 class GiveGift { public:GiveGift(){}//Interfacevirtual void GiveToy(){//...}virtual void GiveFlower(){//...} };//追求者类 class Pursuit : public GiveGift { private:SchoolGirl _mm; ...

代理设计模式

package designmode;interface Subject { // 整个操作的核心主题 public void make();// 整个操作的核心功能}class RealSubject implements Subject { public void make() { System.out.println("核心主题正在操作！！！！！"); }}class ProxySubject implements Subject { private Subject sub; // 代理主题要接收一个真实主题的操作对象 public ProxySubject(Subject sub) {// 代理主题实为真实主题服务 this.sub = sub; } pub...

设计模式之：代理模式【图】

代理模式，通过一个代理类（Proxy）访问另外一个被代理类（RealSubject）的方法，两者共同实现的方法抽象为一个interface类，也称为主题类（Subject）。好处：通过访问代理类中的方法，间接访问真是实现类的方法，也就是代理类的方法，可以在代理中丰富扩展，或者是限定原先实现方法的功能，从一定程度上进行了解耦。模式的实现，如上述所言，核心只有三个类，三个类之间的关系如类图所示：其中，在代理类中构造了真实主题类的对象...

设计模式之代理模式【代码】

1、代理模式，就是接口 + 真实实现类 + 代理类。其中真实实现类和代理类都是要实现接口的，实例化的时候使用代理类。Spring AOP要做的是生成一个代理类来替换掉真实实现的类以对外提供服务。　　在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。代理模式为其他对象提供一种代理以控制对这个对象的访问。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。2、首...

设计模式——代理模式与装饰模式的异同【代码】【图】

两种模式的特点装饰模式：　　在不改变接口的前提下，动态扩展对象的访问。　　动态继承，让类具有在运行期改变行为的能力。　　装饰模式，突出的是运行期增加行为，这和继承是不同的，继承是在编译期增加行为。　　强调：增强代理模式：　　在不改变接口的前提下，控制对象的访问。　　1.从封装的角度讲，是为了解决类与类之间相互调用而由此导致的耦合关系，可以说是接口的另外一个层引用。　　　　比如：在a类->b代理->c类...

Java设计模式----代理模式【代码】【图】

# 标签：读博客我的补充：和装饰者模式一样，代理模式中也实现了相同的接口。然而不同的是，代理模式强调的重点是使用代替实际对象工作，减少对实际对象的操作（干实事儿的还是实际对象啊）；装饰者模式则是，给被装饰者添加附加功能才是重点（修饰被装饰者）。上面是题外话，原文很精彩，自己看咯：（如果你赶时间的话，就别看了，因为原作者写的老长啦）本文转载自：http://www.cnblogs.com/cbf4life/archive/2010/01/27/165743...

设计模式十一之代理模式

代理以通过Internet为它们的代理对象搬运的整个方法调用而出名，它也可以代替某些懒惰的对象做一些事情。　　所谓的代理，就是代表某个真实地对象。在这个案例中，代理就是糖果机对象一样，但其实幕后是它利用网络和一个远程的真正糖果机沟通。我们必须确定糖果机能够通过网络请求并且提供服务；我们也需要让监视器有办法取得代理对象的引用。　　远程代理就好比"远程对象的本地代表"，这种对象活在不同的Java虚拟机堆中(在不同的...

【设计模式】-代理模式【代码】【图】

模式动机在某些情况下，一个客户不想或者不能直接引用一个对象，此时可以通过一个称之为“代理”的第三者来实现间接引用。代理对象可以在客户端和目标对象之间起到中介的作用，并且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。通过引入一个新的对象（如小图片和远程代理对象）来实现对真实对象的操作或者将新的对象作为真实对象的一个替身，这种实现机制即为代理模式，通过引入代理对象来间接...

设计模式之GOF23代理模式02【图】

静态代理模拟经纪人与明星开演唱会public interface Star { /** * 面谈 */ void confer(); /** * 签合同 */ void signContract(); /** * 唱歌 */ void sing(); /** * 收尾款 */ void coleectMoney();}public class RealStar implements Star { private String name; public RealStar(String name) { this.name = name; } @Override public void confer() { System.out.println("RealStar.confer()");...

php设计模式 Proxy (代理模式)

代理，指的就是一个角色代表另一个角色采取行动，就象生活中，一个红酒厂商，是不会直接把红酒零售客户的，都是通过代理来完成他的销售业务。而客户，也不用为了喝红酒而到处找工厂，他只要找到厂商在当地的代理就行了，具体红酒工厂在那里，客户不用关心，代理会帮他处理。代理模式，就是给某一对象提供代理对象，并由代理对象控制具体对象的引用。代理模式涉及的角色：抽象主题角色，声明了代理主题和真实主题的公共接口，使任...

设计模式----代理模式【代码】【图】

今天，我们来说说代理模式，所谓代理，就是代理啦（哈哈），现实世界里，我们常常会听过什么拿下某某代理，今天我们要讲的也是这种代理，在程序的世界里，我们可以称之为封装（也就是包一层），好，废话不多说，直接撸代码。。///<summary>/// 业务接口///</summary>publicinterface ISubject{///<summary>/// get///</summary>///<returns></returns>bool GetSomething();///<summary>/// DO///</summary>void DoSomething();} ...

大话设计模式C++实现-第7章-代理模式【图】

一、UML图二、概念代理模式：为其他对象提供一种代理以控制对这个对象的访问。三、应用场景（1）远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。（2）虚拟代理，是根据需要创建开销很大的对象。通过他来存放实例化需要很长时间的真实对象。例如：图片加载的时候。（3）安全代理，用来控制真是对象访问时的权限。（4）智能指引，是指当调用真实的对象的时候，代理处理另外...

【设计模式】代理模式【代码】【图】

这就是一个代理模式，让王工改需求，需要联系李总，李总再把工作安排给王工，最终完成了同样的目的，但是有个了中间人。同样在Java里的代理模式，也这个道理，客户端不直接访问实际的对象，而是通过中间的代理对象来访问实际对象。代理模式分为静态代理和动态代理静态代理代理和被代理对象在代理之前是确定的。都实现了相同的接口或继承相同的抽象类。举例：创建IUser接口/*** 用户接口*/publicinterface IUser {void login(); }...

设计模式 - 相关标签

设计模式六大原则设计模式之禅

设计模式 - 最热教程

Java的设计模式（7）— 生产者-消费者模...PHP设计模式——策略模式_PHP教程 JavaScript设计模式经典之简单工厂模式...Java设计模式：代理模式 php – Laravel – 在视图中处理if / e...CoreJava学习第十五课-反射，枚举，标注...Java设计模式的常见应用场景 Java设计模式偷跑系列(十八)建模和责任...C#设计模式(6)——原型模式（Prototype...java – 当if-else增长时,应该使用什么...