安卓7.0演示模式是什么(模式开发截图演示)

圈圈笔记 44

前言

我曾经也有个决心,想把23种设计模式全部记住,但总是背了又忘,忘了又继续背,总是记不住。虽然网上有一大堆教学,分析,自己写一遍,比看十遍深刻多了。顺便学几个单词。话说回来,我们无时无刻都在根据设计模式写代码。

设计模式的七大原则

尽量用最简单的话描述

1、开闭原则(Open Closed Principle)

对类的扩展是开放,对修改关闭。在程序需要扩展的时候,对于一个类,不要去修改原来的代码,而是通过继承的方式去扩展这个类。目的:降低维护风险

2、单一职责原则(Single Responsiblity Principle)

每个类应该且只有一个职责。目的:提高可读性

3、里式替换原则(Liskov Substitution Principle)

子类继承父类时,可以实现父类的抽象方法,不要 重写 父类的方法,子类增加自己特有的方法。目的:防止继承带来的问题

4、依赖倒转原则(Dependency Inversion Principle)

程序要依赖于抽象接口,不要依赖,于具体实现,针对接口编程。目的:利于代码升级

5、接口隔离原则(Interface Segregation Principle)

庞大的接口拆分成更小的和更具体的接口,一个接口只用于一个业务逻辑。目的:使功能解耦,高内聚、低耦合

6、迪米特原则(Principle of Least Knowledge)

一个对象应当对 其他 对象尽可能少的了解。 目的:自己做自己的事情

7、合成复用原则(Composite Reuse Principle)

使用对象组合,而不是继承来达到复用的目的。继承破坏了封装性,父类的任何改变,都可能导致子类出问题。优先考虑 合成复用,A类和B类的合成使用,而不是B继承A的使用。目的:少用继承 降低耦合

23种设计模式

23种设计模式分为三类创建型模式、结构型模式、行为型模式顾名思义,创建型 就是怎么创建对象的。结构型就是对象与对象的关系,变成更大的结构。行为型 就是运行时复杂流程的 控制。

创建型

1、单例模式(Singleton Pattern)

目的:主要就是一个类,频繁的创建,销毁优点:内存中只有一个实例,减少开销缺点:没有接口,不能继承,违背了单一职责原则实现:1.懒汉式 静态方法,用到的时候再创建对象2.饿汉式 静态变量,直接new出对象3.双重锁 两个if判断,第一个if是为了防止不必要的线程同步,第二个if判断是为了避免 第二个线程 重复创建对象,volatile为了防止指令重排4.kotlin关键字object也可以创建单例,原理和懒汉式类似在static块中创建5.枚举的方式,枚举编译后,也是在static块中new出对象

//双重锁publicclassSingleton{privatevolatilestaticSingleton instance;privateSingleton(){};publicstaticSingletongetInstance(){if(instance==null){ sychronized(Singleton.class){if(instance==null) instance=newSingleton(); } }returninstatnce; } } 复制代码

在android中有个隐藏抽象类

publicabstractclassSingleton<T>{publicSingleton(){ }privateT mInstance;protectedabstractTcreate();publicfinalTget(){synchronized(this) {if(mInstance ==null) { mInstance = create(); }returnmInstance; } } }privatestaticfinalSingleton IActivityTaskManagerSingleton =newSingleton() {@OverrideprotectedIActivityTaskManagercreate(){finalIBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);returnIActivityTaskManager.Stub.asInterface(b); } }; 复制代码

这里用来获取了AMS对象,如果获取不到,就通过ServiceManager去获取。这个Singleton是隐藏类,直接用不了,可以直接copy出来用。

2、工厂模式(Factory Pattern)

目的:解决接口选择问题优点:想要创建对象,只要知道名字就行,屏蔽了内部实现,只要关心接口缺点:增加一个产品的时候,需要增加一个实现类 和 一个工厂,比如Dagger2,新增一个注入的Bean,Dagger2就会为我们生成一个Factory类。空间增大了实现:

publicinterfaceClothes{voidgetClothes(); }publicclassJacketimplementsClothes{@OverridepublicvoidgetClothes(){ System.out.println("夹克衫"); } }publicclassSweaterimplementsClothes{@OverridepublicvoidgetClothes(){ System.out.println("毛衣"); } } 工厂 假设他是衣柜publicclassWardrobeFactory{publicClothesgetShape(String shape){switch(shape) {case"Jacket":returnnewJacket();case"Sweater":returnnewSweater(); }returnnull; } } 复制代码

衣柜假设是个工厂,衣柜里有衣服,抽象出衣服,衣服可以有夹克衫或者是毛衣在android中根据名字去拿对象,比如获取系统服务

context.getSystemService(Service.ALARM_SERVICE)StringALARM_SERVICE ="alarm"复制代码

获取闹铃服务

3、抽象工厂模式(Abstract Factory Pattern)

目的:解决接口选择问题优点:当产品种类很多的时候 ,根据名字拿到的当前产品种类的对象缺点:扩展非常困难,增加一个同类新的产品,就需要增加一个新的工厂实现:

//裤子publicinterfaceTrousers{voidgetTrousers(); }//牛仔裤publicclassJeansimplementsTrousers{@OverridepublicvoidgetTrousers(){ System.out.println("牛仔裤"); } }//短裤publicclassShortsimplementsTrousers{@OverridepublicvoidgetTrousers(){ System.out.println("短裤"); } }//衣服publicinterfaceClothes{voidgetClothes(); }//毛衣publicclassSweaterimplementsClothes{@OverridepublicvoidgetClothes(){ System.out.println("毛衣"); } }//夹克衫publicclassJacketimplementsClothes{@OverridepublicvoidgetClothes(){ System.out.println("夹克衫"); } }//衣服和裤子都有了,抽象工厂//抽象工厂,这个工厂需要完成 那衣服 和 裤子publicabstractclassAbsFactory{publicabstractTrousersgetTrousers(String trousers);publicabstractClothesgetClothes(String clothes); }//生产衣服publicclassClothesFactoryextendsAbsFactory{@OverridepublicTrousersgetTrousers(String trousers){returnnull; }@OverridepublicClothesgetClothes(String clothes){switch(clothes){case"Jacket":returnnewJacket();case"Sweater":returnnewSweater(); }returnnull; } }//生产裤子publicclassTrousersFactoryextendsAbsFactory{@OverridepublicTrousersgetTrousers(String trousers){switch(trousers){case"Shorts":returnnewShorts();case"Jeans":returnnewJeans(); }returnnull; }@OverridepublicClothesgetClothes(String shape){returnnull; } }//衣橱类publicclassWardrobeFactory{publicstaticAbsFactorygetFactory(String choice){switch(choice){case"Clothes":returnnewClothesFactory();case"Trousers":returnnewTrousersFactory(); }returnnull; } }//使用//拿裤子AbsFactory absFactory = WardrobeFactory.getFactory("Trousers");//具体拿什么裤子Trousers shorts = absFactory.getTrousers("Shorts");//拿短裤shorts.getTrousers(); 复制代码

代码比较多,还是比较清晰的,把工厂抽象了一下。工厂模式关注 生产的产品抽象工程模式关注 产品之间的关系在android中,抽象工厂比较少,可以把整个Service看做一个大抽象工厂,通过名字去拿服务,拿到服务对象,再调用对象里的抽象方法。

4、原型模式(Prototype Pattern)

目的:快速,高效的创建对象优点:提高性能,没有构造函数的限制缺点:配合克隆方法进行,需要考虑深拷贝和浅拷贝的问题实现:

publicclassSheepimplementsCloneable{ String name;publicSheep(String name){this.name = name; }publicObjectclone(){ Object obj =null;try{ obj =super.clone(); }catch(CloneNotSupportedException e) { e.printStackTrace(); }returnobj; } } 复制代码

完成Cloneable方法,增加一个clone方法,Object也有一个克隆方法,这是调用了Native方法,底层去克隆了一个对象。在android中

publicclassIntentimplementsParcelable,Cloneable{@OverridepublicObjectclone(){returnnewIntent(this); } }//okhttp中 也用到了@OverridepublicRealCallclone(){returnRealCall.newRealCall(client, originalRequest, forWebSocket); } 复制代码

说到底也就是复制一个新对象。

5、建造者模式(Builder Pattern)

目的:配置一个复杂对象优点:独立,容易扩展缺点:如果对象复杂,会有很多建造者类实现:

publicclassDialog{ String title;booleanmCancelable =false; Dialog(String title,booleanmCanclable){this.title = title;this.mCancelable = mCanclable; }publicvoidshow(){ System.out.print("show"); }staticclassBuilder{ String title;booleanmCancelable =false;publicBuildersetCancelable(booleanflag){ mCancelable = flag;returnthis; }publicBuildersetTitle(String title){this.title = title;returnthis; }publicDialogbuild(){returnnewDialog(this.title,this.mCancelable); } } } 复制代码

这个建造者不拘泥于形式,建造者模式用于创建一个复杂对象。 在android中,Dialog就用到了建造者模式,第三方库的okhttp、Retrofit

结构型

6、代理模式(Proxy Pattern)

目的:增强他的职责,比如访问远程的服务器,如果直接访问可能会带来一些麻烦,通过一个代理去帮我们访问优点:职责清晰,易扩展缺点:增加了代理可能会导致速度慢,代理类会比较复杂实现:

//访问数据库接口publicinterfaceDataBase{voidselect(); }//正真 做查询操作publicclassRealImageimplementsDataBase{@Overridepublicvoidselect(){ System.out.println("查询"); } }//代理类publicclassProxyDBimplementsDataBase{ RealImage realImage;publicProxyDB(){if(realImage==null){ realImage =newRealImage(); } }@Overridepublicvoidselect(){ realImage.select(); } }//使用DataBase proxyDb =newProxyDB(); proxyDb.select(); 复制代码

这里用了ProxyDB 这个代理类,去访问数据,并没有直接去访问数据库。 在android中,当我们编写好AIDL文件后,编译器会自动给我们增加一些代码

publicinterfaceIRemoteServiceextendsandroid.os.IInterface{publicstaticabstractclassStubextendsandroid.os.Binderimplements...{publicstaticcom.learnaidl.IRemoteServiceasInterface(..){returnnew..Proxy(obj); }privatestaticclassProxyimplementscom.learnaidl.IRemoteService{ ... } } }//使用IRemoteService.Stub() 复制代码

通过IRemoteService的Stub类拿对象,这个对象是通过一个代理类创建出来的。换个角度看,代理模式也就是 实现了一个接口,并完成了一个方法,这个方法可以去做任何事情。

7、外观模式(Facade Pattern)

目的:降低系统复杂度优点:提高灵活性,安全性缺点:违反了开闭原则、迪米特原则,改东西相对麻烦实现:

//接口 有个打开的动作publicinterfaceAction{voidopen(); }//灯 实现了 开灯publicclassLampimplementsAction{@Overridepublicvoidopen(){ System.out.println("开灯"); } }//电视 实现了 打开电视publicclassTVimplementsAction{@Overridepublicvoidopen(){ System.out.println("开电视"); } }//遥控器 可以控制灯 和电视publicclassRemoteControl{ Action lamp; Action tv;publicRemoteControl(){ lamp =newLamp(); tv =newTV(); }publicvoidopenLamp(){ lamp.open(); }publicvoidopenTv(){ tv.open(); } } 复制代码

遥控器既可以开灯,又可以开电视。可见这个遥控器职责并不单一。也不用局限于接口,如果是功能聚合到一个类中,依然可以叫外观模式。想象成 前台、接待员在android中,Context就用了外观模式,Context可以打开Activity,可打开Service,广播等等。

8、装饰器模式(Decorator Pattern)

目的:解决扩展子类膨胀的问题,比如摊煎饼,可以摊煎饼前,煎个鸡蛋,摊煎饼后,撒点酱优点:灵活扩展缺点:过多的装饰,会很复杂实现

//一个煎饼接口publicinterfacePancake{voidpancake(); }//牛肉煎饼publicclassBeefPancakeimplementsPancake{ @Overridepublicvoidpancake(){ System.out.println("牛肉煎饼"); } }//工作人员publicclassWorker{ Pancake pancake;publicWorker(){ pancake =newBeefPancake(); }publicvoidmakePancake(){ System.out.println("煎鸡蛋"); pancake.pancake(); System.out.println("撒酱"); } }//使用Worker worker =newWorker(); worker.makePancake(); 复制代码

说白了,装饰模式,装饰东西,实际作用的前后装饰一些其他内容。在android中,Context,ContextImpl也就是个装饰模式,我们肯定会在startActivity()前后做点业务操作。

9、享元模式(Flyweight Pattern)

目的:为了解决大量创建相同对象,可能造成OOM优点:减少重复创建对象,降低内存缺点:提高了系统的复杂度,如果固定了一些对象,当被改变时候,会造成混乱实现:

//假设有个请求的类publicclassRequest{ }//通过一个地方 去拿请求publicclassHttpFactory{publicstaticfinal HashMap requestMap =newHashMap<>();publicRequestgetRequestList(String name){ Request request = (Request) requestMap.get(name);if(request==null){ request =newRequest(); requestMap.put(name,request); }returnrequest; } }//使用HttpFactory factory =newHttpFactory(); Request request1 = factory.getRequestList("baidu");//假设过了一会Request request2 = factory.getRequestList("baidu"); 复制代码

相当于是缓存了一块地方,把对象放进去,需要对象的时候就从这里面取,如果相同需求,则会返回已有的对象。在android中,获取Message,可以通过Message.obtain()去获取Message。在JVM中缓存了很多字符串。 可以说我们任何时候都在使用享元模式。

10、组合模式(Composite Pattern)

目的:用来描述整体和部分的关系,比如在树中,一个结点可以是根节点,也可以是叶子节点优点:调用简单,结点可以自由增加缺点:在组合模式中,依赖的都是实现类,而不是接口,违反了依赖倒置原则实现:

//二叉树publicclassListNode{ int data;ListNodeleft;ListNoderight; } 复制代码

二叉树的结点,既可以是根节点,又可以是叶子节点。 在android中,View和ViewGroup的关系,ViewGroup既可以是一个View,又可以包含View。

11、适配器模式(Adapter Pattern)

目的:解决两个不兼容接口的桥梁,兼容转换优点:让两个没有关联的类一起运行,提高复用缺点:使用过多,会让系统变的凌乱实现:

//定义适配器类publicclassAdapter{publicvoidgetView(inti){ System.out.println("给出View"+i); } }//ListView 继承了AdapterpublicclassListViewextendsAdapter{publicvoidshow(){ System.out.print("循环显示View");for(inti=0;i<3;i++){ getView(i); } } }//GridView继承了AdapterpublicclassGridViewextendsAdapter{publicvoidshow(){ ... getView(i); } } 复制代码

适配器模式可以用继承实现,这里没有更高的抽象,当然也可以把Adapter的内容抽象出去,仅仅演示,ListView、GridView适配了Adapter类。在android中,ListView、RecyclerView都是用了适配器模式,ListView适配了Adapter,ListView只管ItemView,不管具体怎么展示,Adapter只管展示。就像读卡器,读卡器作为 内存和电脑 之间的 适配器。

12、桥接模式(Bridge Pattern)

目的:将两个能够独立变化的类分开,不用继承,继承会造成类的爆炸增长优点:抽象分离,易扩展,细节透明缺点:会增加系统的设计难度实现:

//颜色接口publicinterfaceColor{voiddraw(String box); }//红色 完成方法 红色的somethingpublicclassRedColorimplementsColor{@Overridepublicvoiddraw(String sth){ System.out.println("red "+ sth); } }//抽象类 盒子publicabstractclassBox{ Color color;publicBox(Color color){this.color = color; }abstractvoidgetBox(); }//实现类 红色盒子publicclassRedBoxextendsBox{publicRedBox(Color color){super(color); }@OverridevoidgetBox(){this.color.draw("box"); } }//使用RedColor redColor =newRedColor(); Box box =newRedBox(redColor); box.getBox(); 复制代码

如果类存在两个维度的变化,比如颜色可能有红色、绿色,包可能有手提包,钱包。对于这两个维度的变化,适合用桥接。更直观的说,比如一个USB线左边可以插不同的手机,右边可以插不同的电源。在android中,整个View的视图,View、Button、ViewGroup等等都是在View这个维度上的变化,都有onDraw()方法来实现不同的视图。另一个维度就是把View绘制到屏幕上。私以为,这RexBox相当于一个View,RedColor相当于绘制到屏幕上。

行为型

13、模板模式(Template Pattern)

目的:固定了一些方法,只要照着做就行,比如把大象放进冰箱,打开冰箱,放进冰箱,关闭冰箱优点:行为由父类控制,便于维护缺点:导致类增多,系统变大实现:

publicabstractclassBaseActivity{abstractvoidonCreate();abstractvoidonDestory(); }publicclassHomeActivityextendsBaseActivity{@OverridevoidonCreate(){ }@OverridevoidonDestory(){ } } 复制代码

它的主旨就是抽象出公共的方法,子类照着重写就行,行为由父类控制这个。。。作为android开发者天天都在用。。。

14、策略模式(Strategy Pattern)

目的:解决很多if else的情况优点:可以避免多重判断条件,扩展性好缺点:类会增多实现:

//假如RecyclerView 这样写publicclassRecyclerView{privateLayout layout;publicvoidsetLayout(Layout layout){this.layout = layout;if(layout =="横着"){ }elseif(layout =="竖着"){ }elseif(layout=="格子"){ }else{ }this.layout.doLayout(); } }//这样写if就很多了//排列的方式publicinterfaceLayout{voiddoLayout(); }//竖着排列publicclassLinearLayoutimplementsLayout{@OverridepublicvoiddoLayout(){ System.out.println("LinearLayout"); } }//网格排列publicclassGridLayoutimplementsLayout{@OverridepublicvoiddoLayout(){ System.out.println("GridLayout"); } }publicclassRecyclerView{privateLayout layout;publicvoidsetLayout(Layout layout){this.layout = layout;this.layout.doLayout(); } } 复制代码

这里直接举了android中RecyclerView的案列,我们给RecyclerView选择布局方式的时候,就是选择一个策略。

15、中介者模式(Mediator Pattern)

目的:解决对象与对象之间的耦合关系优点:降低复杂度,各个类之间解耦缺点:中介者会过于庞大不好维护实现:

//聊天室publicclassChatRoom{publicstaticvoidshowMessage(User user,String msg){ System.out.println(user.name+":"+msg); } }//用户publicclassUser{ String name;publicUser(String name){this.name = name; }publicvoidsendMessage(String msg){ ChatRoom.showMessage(this,msg); } }//使用User h1 =newUser("h1"); User h2 =newUser("h2"); h1.sendMessage("hello"); h2.sendMessage("you too~"); 复制代码

这个聊天室就相当于个中介者,给两个人传递消息。如果聊天室新增功能,会导致聊天室的代码越来越多,不好维护。在android中,无时无刻都在使用中介者,MVP 的 P ,MVC的 C ,MVVM 的 VM,你和我。???

16、观察者模式(Observer Pattern)

目的:一个对象改变通知其他对象,保证协作优点:观察者和被观察者是抽象耦合的,也就是说通过抽象方法,给具体的类通知缺点:如果观察者有很多,被观察者发消息,会慢,如果不小心观察者和被观察者有依赖,会循环引用实现:

//抽象类 做作业publicabstractclassDoWork{protectedTeacher teacher;abstractvoiddoHomeWork(inti); }//老师publicclassTeacher{privateList students =newArrayList<>();privateintindex;publicvoidattach(Student student){this.students.add(student); }publicvoiddispatchHomeWork(intindex){this.index = index; notifyAllStudent(); }publicvoidnotifyAllStudent(){for(Student stu:students) { stu.doHomeWork(index); } } }//学生类publicclassStudentextendsDoWork{publicStudent(Teacher teacher){this.teacher = teacher;this.teacher.attach(this); }@OverridevoiddoHomeWork(inti){ System.out.println(this+":做作业"+i); } }//使用Teacher teacher =newTeacher();newStudent(teacher);newStudent(teacher);newStudent(teacher); teacher.dispatchHomeWork(1); teacher.dispatchHomeWork(3); 复制代码

这个很好实,关键代码就是通过一个ArrayList保存观察着。其实在java中,jdk已经实现好的观察者模式。点开源码就会发现他保存的是个向量

publicclassObservable{privatebooleanchanged =false;privateVector obs; } 复制代码

17、状态模式(State Pattern)

目的:对象依赖一个状态,对象可以根据状态改变自己的行为优点:状态转换与逻辑合在一起,而不是通过if语句隔开缺点:会使结构比较复杂,也会增加类的个数实现:

//状态接口publicinterfaceState{voiddoAction(MediaPlayer activity); }//开始状态publicclassOnStartimplementsState{@OverridepublicvoiddoAction(MediaPlayer activity){ System.out.println(activity+":OnStart"); } }//结束状态publicclassOnStopimplementsState{@OverridepublicvoiddoAction(MediaPlayer activity){ System.out.println(activity+":OnStop"); } }//播放器publicclassMediaPlayer{ State state;publicvoidsetState(State state){this.state = state; }publicStategetState(){returnstate; } }//使用MediaPlayer activity =newMediaPlayer(); OnStart onStart =newOnStart(); onStart.doAction(activity); OnStop onStop =newOnStop(); onStop.doAction(activity); 复制代码

定义了两个状态,开始和结束,让播放器 依赖这两个状态进行操作。在android中,就比如播放器,依赖自身的状态,进行播放暂停操作。再比如Fragment,Fragment走自己的onCreate等方法,也是依赖Activity的生命周期状态进行操作。

18、责任链模式(Chain of Responsibility Pattern)

目的:主要用来解耦,客户只要把消息发到责任链上,无需关注请求细节和传递过程优点:解耦,简化操作缺点:性能会有一点影响,调试不太方便实现:

//责任链接口publicinterfaceInterceptor{Stringchain(String inData); }//缓存publicclassCacheInterceptorimplementsInterceptor{@OverridepublicStringchain(String inData){returninData +="加了缓存"; } }//呼叫服务器publicclassCallServerInterceptorimplementsInterceptor{@OverridepublicStringchain(String inData){returninData +="呼叫了服务器"; } }//把责任 集合起来publicclassRealInterceptor{ List list =newArrayList<>();publicRealInterceptor(){ list.add(newCacheInterceptor()); list.add(newCallServerInterceptor()); }publicStringrequest(String st){ String result ="";for(inti=0;i责任链就是想链条一样,也可以在中间增加或减少,像"击鼓传花",一个个传递。在android中,事件分发机制,父View接到事件,传递给子View。在第三方库okhttp中一个网络请求用的也是拦截器模式。

19、备忘录模式(Memento Pattern)

目的:不破坏封装的前提下,捕获一个对象的内部状态,并保存,之后能根据状态恢复到原来的样子优点:提供了一种可以恢复的机制,封装了信息,用户不需要过多关心细节缺点:消耗资源,如果保存内容过多过大,会占用很多资源实现:

//Layer表示 一层publicclassLayer{privateString state;publicLayer(String state){this.state = state; }publicStringgetState(){returnstate; }publicvoidsetState(String state){this.state = state; } }//管理 层publicclassManager{privateLayer mLayer;publicLayersave(String state){returnnewLayer(state); }publicvoidrestore(Layer layer){ mLayer = layer; }publicLayergetmLayer(){returnmLayer; } }//正真用这个层publicclassPhotoShop{privateList layerList =newArrayList<>();publicvoidctrl_S(Layer mLayer){ layerList.add(mLayer); }publicLayerctrl_Z(intindex){returnlayerList.get(index); } }//使用PhotoShop ps =newPhotoShop(); Manager manager =newManager(); ps.ctrl_S(manager.save("第一层")); ps.ctrl_S(manager.save("第二层")); manager.restore(ps.ctrl_Z(1)); System.out.println("当前是:"+manager.getmLayer().getState() ); ps.ctrl_S(manager.save("第三层")); ps.ctrl_S(manager.save("第四层")); manager.restore(ps.ctrl_Z(3)); System.out.println("当前是:"+ manager.getmLayer().getState()); 复制代码

就像Ps一样,Ctrl+S 保存一层,Ctrl+Z回退一层。就像玩游戏的存档一样在android中,Activity的onSaveInstanceState保存数据在onCreate里 恢复数据

20、迭代器模式(Iterator Pattern)

目的:遍历一个对象优点:访问一个聚合数据,聚合数据不会暴露内部内容缺点:会增加类的个数,增加系统复杂性实现:

//迭代接口publicinterfaceIterator{booleanhasNext();Objectnext(); }//容器接口publicinterfaceContainer{IteratorgetIterator(); }//容器publicclassNameContainerimplementsContainer{publicString[] names = {"name1","name2","name3","name4"};@OverridepublicIteratorgetIterator(){returnnewNameIterator(); }classNameIteratorimplementsIterator{intindex;@OverridepublicbooleanhasNext(){if(index < names.length){returntrue; }returnfalse; }@OverridepublicObjectnext(){if(this.hasNext()){returnnames[index++]; }returnnull; } } }//使用NameContainer nameContainer =newNameContainer(); Iterator it = nameContainer.getIterator();while(it.hasNext()){ String name = (String) it.next(); System.out.println(name); } 复制代码

Iterator接口,必须实现下一个 对象 和 是否有下一个对象。Container接口 需要返回一个实现Iterator接口的类。在java中HashMap的内部类KeySet有Iterator,android中访问数据库有Cursor,都是是用了迭代器模式

21、解释器模式(Interpreter Pattern)

目的:对于一些固定问法结构如xml,构建一个类解释它优点:扩展性好、灵活、增加了新的表达方式缺点:使用场景少,难维护,通常要用到递归实现:

//先看 使用SelectInterpreter selectInterpreter =newSelectInterpreter(); selectInterpreter.interpreter("查t_name");//解释器接口publicinterfaceInterpreter{Stringinterpreter(String sql); }//查询的 解释器publicclassSelectInterpreterimplementsInterpreter{@OverridepublicStringinterpreter(String sql){// select * from t_user// select t_userif(sql.indexOf("查")==0){intstart = sql.indexOf("查")+1;intend = sql.length(); String tableName = sql.substring(start,end); System.out.println("查询表:"+tableName); }else{ System.out.println("sql error"); }returnnull; } } 复制代码

sql是一种描述语言,通常sql查询一个表需要select * from t_user,这是数据库定义的语法。现在由我来 解释,想要查询我的数据库,直接查t_name,就可以了。虽然有点扯,但应该最好理解了。在android中,通常会定义xml布局,然后setContentView(xml),把xml放进去,这个里面就用了解释器模式,通过XmlResourceParser等一些方法,把xml解释成对象。

22、命令模式(Command Pattern)

目的:也是用来解耦的。通常请求者和实现者是一种耦合关系,但一些场合对行为记录、撤销、重做,这种请求和处理就不太适合在一起优点:解耦,易扩展缺点:命令类可能会变的很多实现:

//命令接口publicinterfaceOrder{voidexecute(); }//买的命令publicclassBuyStockimplementsOrder{ Stock stock ;publicBuyStock(Stock stock){this.stock = stock; }@Overridepublicvoidexecute(){this.stock.buy(); } }//卖的命令publicclassSellStockimplementsOrder{ Stock stock ;publicSellStock(Stock stock){this.stock = stock; }@Overridepublicvoidexecute(){this.stock.sell(); } }//业务类 股票publicclassStock{publicvoidbuy(){ System.out.println("buy"); }publicvoidsell(){ System.out.println("sell"); } }//经理人publicclassManager{privateList list =newArrayList<>();publicvoidtakeOrder(Order order){this.list.add(order); }publicvoidplaceOrder(){for(Order order:list) { order.execute(); } list.clear(); } }//使用//经理人Manager manager =newManager();//一个股票Stock stock =newStock();//命令1 买股票Order order1 =newBuyStock(stock);//命令2 卖股票Order order2 =newSellStock(stock); manager.takeOrder(order1); manager.placeOrder(); manager.takeOrder(order2); manager.placeOrder(); 复制代码

4个类,一个买股票的类,一个卖股票的类,一个经理人,一个股票。买和卖相当于一条命令,也可以增加其他的命令。一句话,定义一条买股票的命令,把命令交给经理人,经理人去执行。 在android中,PackageManagerService用到了命令模式,实现对apk的解析、管理等操作。私以为这个命令模式比较宽泛,将一个请求封装成一个对象,对这个请求有记录或者撤销等操作。比如线程池使用、okhttp一个请求用的Call,都可以视作命令。

23、访问者模式(Visitor Pattern)

目的:解决稳定的数据结构和易变的操作耦合问题优点:符合单一职责,易扩展缺点:违反了迪米特原则、依赖倒置原则,依赖了具体实现类,不是依赖抽象实现:

//行为模式中最复杂的一个模式,先看代码//抽象类 动作publicabstractclassAction{abstractvoidaccept(Visitor visitor); }//相机系统publicclassCameraSystemextendsAction{@Overridevoidaccept(Visitor visitor){ visitor.visitor(this); } }//图片系统publicclassImageSystemextendsAction{@Overridevoidaccept(Visitor visitor){ visitor.visitor(this); }publicintgetSize(){return10; } }//访问者 接口publicinterfaceVisitor{voidvisitor(ImageSystem imageSystem);voidvisitor(CameraSystem cameraSystem); }//app1 实现 访问者接口publicclassApp1implementsVisitor{@Overridepublicvoidvisitor(ImageSystem imageSystem){ System.out.print("访问图片"); System.out.print("一共"+ imageSystem.getSize()); }@Overridepublicvoidvisitor(CameraSystem cameraSystem){ System.out.print("访问相机"); } }//使用App1 app1 =newApp1(); ImageSystem imageSystem =newImageSystem(); imageSystem.accept(app1); 复制代码

看上去代码不是非常复杂,我写了一个比较好理解的代码,访问者肯定是访问内容一个动作的抽象类,图片系统和相机系统完成了这个动作。App1 实现了访问者接口,表示App1可以 访问 图片系统和相机系统。再换个案列,比如棉花和纸,在做衣服的工厂可以做成毛衣和标签牌子,在造钱的工厂,可以做成纸币和包装袋访问者的目的是:稳定的数据结构 和 异变的操作 ,耦合问题,我觉着应该不用在解释了。

总结

23种设计模式,分为创建型、结构型、行为型,都是围绕七大设计原则,当然有些设计模式牺牲了一些原则,换取更好的效果。

抛开设计模式来看,所有的代码,无非用到了,抽象类、接口、实现类,再加上接口和实现类的组合、实现类与实现类的组合而写成的代码。

设计模式是代码设计经验的总结,我们根据这些总结,开发出易于他人理解、可靠可重用的代码。

最后的话,我这边整理了一份包含从设计模式出发做性能优化的学习手册,感兴趣的朋友,可以后台私信我获取!

性能优化目录截图

性能优化部分解析内容截图

上一篇:

下一篇:

  推荐阅读

分享