二十九、简谈设计模式-白红宇

二十九、简谈设计模式

阅读量：4583 次

发布时间：2019-06-09

本文共 4903 字，大约阅读时间需要 16 分钟。

模式设计（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样（百度百科）。本文将介绍几种简单的设计模式。

单例设计模式：

解决一个类在内存中只有一个对象，多个程序使用统一配置信息对象时，需要保证该对对象的唯一性。

保证对象唯一性的实现步骤：

1.将构造函数私有化：为了避免其他程序过多建立该对象，禁止其他程序调用该对象。

2.在类中创建一个本类对象：为了让其他程序可以访问该类对象

3.提供一个方法可以获取到该对象的方法：方便其他程序访问自定义的本类对象。

饿汉式：

所谓饿汉式就是一进内存就创建了对象

class single{     private single(){}1.将构造函数私有化     private static single s=new single();2.在类中创建一个本类对象     public static single getInstance(){3.提供一个方法可以获取到该对象的方法         return s;     } }

调用方式

public class SingleDemo {     public static void main(String[] args) {             single ss=single.getInstance();     } }

懒汉式：

所谓的饿汉式就是什么时候调用什么时候才创建对象,已达到对象的延时加载效果。

class single{     private single(){}     private static single s=null;     public static single getInstance(){ { if （s==null）{          s=single.getInstance(); } }         return s;     } }

两种方式的比较：

饿汉式是比较常用的一种方式，因为它是线程安全的，而懒汉式相对来说使用的较少，因为线程不安全。当然也可以使用同步来保证线程安全

装饰设计模式

顾名思义，所谓的装饰模式就是为了增强一个类的功能，所以在在其他类的基础上进行装饰（包装）。

当想要对已有的独享进行功能增强时，可以定义类，将已有的对象传入，基于已经有的功能，并提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能（在IO流中使用比如BufferedReader等等）。

代码演示：

已知类：

Person() {       public void chifan()          {      } }

增强类：

superPerson() {      private Person p;    superPerson(Person p)   {         this.p=p;   } public void superchifan() {    p.chifan();    ......... }

自定义装饰类

package com.io; import java.io.*; public class MyBufferedReader {         private Reader r;         public MyBufferedReader(Reader r) {             super();             this.r = r;         }         //可以一次读取一行的方法          public String myReadLine() throws IOException          {              //定义一个临时容器。StringBulider容器，应用于存储字符数组              StringBuilder sb=new StringBuilder();              int ch=0;              while((ch=r.read())!=-1){                  if(ch=='\r')                          continue;                  if(ch=='\n')                      return sb.toString();                  else                      sb.append((char)ch);              }                            if(sb.length()!=0)                  return sb.toString();              return null;          }               //复写reader中的抽象方法          //复写close方法          public void close() throws IOException          {              r.close();          }          //复写read方法          public int read (char[] c,int off,int len) throws IOException{                            return r.read(c, off, len);          } }

模板设计模式

在我们定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么就把这不确定的部分暴露出去，由该类的子类完成，这方思想就是模板设计模式

示例

abstract class GetTime {     public final void getTime(){         long start = System.currentTimeMillis();         runcode();         long end = System.currentTimeMillis();         System.out.print("程序运行时间（毫秒）:"+(end-start));     public abstract void runcode();     } } class SubTime extends GetTime {     public void runcode(){         for (int x =0;x<100 ;x++ )         {             System.out.println(x);         }     } }

GetTime类中getTime方法时为了获取某个程序运行的时间，因为不知道会运行什么程序，所以把程序封装进一个抽象类中，当我们引用这个方法时，就必须得复写其中的抽象方法runcode，同时继承了getTime这个方法，从而达到检测不同程序运行时间的效果。这就是模板设计模式。

注意：不确定的部分不是非得是抽象的，因为原有类中可能有默认的方法，我们在使用时，只需把它覆盖即可，写我们需要的内容即可。所以，不确定部分，可以是抽象的，也可以不是抽象的。

简单工厂模式

构建一个工厂出来，在里面进行生产，用的时候直接拿

我的总结：

好处:屏蔽不同子类实现的差异，提高代码的可拓展性和可维护性;

package reviewDemo;//简单工厂模式interface Phone{//制定标准，都要实现send()方法	public void send();}class Iphone implements Phone{	@Override	public void send() {		System.out.println("Iphone手机在发短信");	}}class AndroidPhone implements Phone{	@Override	public void send() {		System.out.println("AndroidPhone手机在发短信");	}}class MyPhone implements Phone{	@Override	public void send() {		System.out.println("MyPhone手机在发短信");	}}class Factory{	public static void show(String type){//传入参数，根据不同的类型个性化定制		if(type.equals("")){//为空的情况，不用往下执行			System.out.println("对不起，类型为空！,请重新输入！");			return;		}		Phone p = null;		if("Iphone".equals(type)){//判断类型			p = new Iphone();		}else if("AndroidPhone".equals(type)){			p = new AndroidPhone();		}else{			p = new MyPhone();		}		p.send();	}}public class FactoryDemo17 {	public static void main(String[] args) {				new Factory().show("Iphone");//调用方法		new Factory().show("AndroidPhone");		new Factory().show("MyPhone");		new Factory().show("YourPhone");		new Factory().show("");	}}

输出：

Iphone手机在发短信

AndroidPhone手机在发短信

MyPhone手机在发短信

对不起，类型为空！

享元模式

-128~127之间的特殊性。为什么要这样设计，好处？

——> 享元模式（Flyweight Pattern）：享元模式的特点是，复用我们内存中已存在的对象，降低系统创建对象实例。

自动装箱：

Integer num1 = 12;

自动拆箱：

System.out.println(num1 + 12);