设计模式

设计模式是一套被反复使用、多数人知晓的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解。设计模式使代码编制真正工程化，它是软件工程的基石脉络，如同大厦的结构一般。

在毕老师的java基础视频中，我学到了以下几种设计模式：

单例设计模式

单例设计模式是一种比较常见的设计模式，使用单例设计模式有什么好处呢？

1.通过线程的同步来控制资源的并发访问。

2.控制实例产生的数量，达到节约资源的目的。

3.作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的线程通信。（查阅网上的资料得来，不太懂）

如何实现单例设计模式呢？

有以下两种方法：

1.在要实现单例模式的的类里将构造函数私有化，然后在类中创建一个本类对象，再提供一个方法来获取该对象。例如：

饿汉式：先初始化对象

class Single｛
private Single（）｛｝
private static Single s = new Single();
public static Single getInstance()
{
      return   s;
}
}

懒汉式：对象在方法被调用时才初始化，也叫做对象的延时加载。

class Single

{

    private static Single s = null;

    private Single( ){ }

    public static Single getInstance ()

    {

          if(s==null)

                s = new Single();

          return s;

    }

}

人们在开发中常用饿汉式，较少用懒汉式，但这可能出现在你的面试题中，所以还是值得一看。


2.用枚举来实现单例设计模式，这可能是最好的实现单例模式的方式。

public enum Student{
     single("LiMing",18);
     private String name;
     private int age;
<pre name="code" class="java">     private Student(String name,int age){
          this.name = name;
          this.age = age;
     }
}



模版方法设计模式

在我们定义功能的时侯，功能有一部分是确定的，另一部分不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

以下参考毕老师的TemplateDemo代码。

abstract class GetTime
{
    public final void getTime()
    {
        long start = System.currentTimeMillis();

        runcode();

        long end = System.currentTimeMillis();

        System.out.println("毫秒："+(end-start));
    }
    public abstract void runcode();

}


class SubTime extends GetTime
{

    public void runcode()
    {
        
        for(int x=0; x<4000; x++)
        {
            System.out.print(x);
        }
    }
}


class  TemplateDemo
{
    public static void main(String[] args)
    {
        SubTime gt = new SubTime();
        gt.getTime();
    }
}

在这段代码中，父类GetTime将不确定的那一部分：runcode方法定义为抽象，留给子类去复写，子类SubTime复写了父类中runcode（）方法后，变成了独特的、更具体的类。我们在设计程序时，也应该有这种思想，将共有的部分抽取出来作为一个模版，让子类去复写其中不确定的部分，并调用已知可用的功能来实现相应的方法。稍微需要注意的是，不是所有方法都需要复写，其中不应该被复写的方法我们可以加上final修饰符，让子类继承时无法复写。

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接受被装饰的对象，并基于被修饰类的对象的功能，提供更强的功能。

好处：装饰体系比继承体系更加灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能，所以装饰类和被装饰类往往是一个体系的。装饰类让继承结构变成组合结构。

class Person
{
	public void chifan()
	{
		System.out.println("吃饭");
	}
}

class SuperPerson 
{
	private Person p ;
	SuperPerson(Person p)
	{
		this.p = p;
	}
	public void superChifan()
	{
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
		System.out.println("来一根");
	}
}



class  PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person();

		//p.chifan();

		SuperPerson sp = new SuperPerson(p);
		sp.superChifan();

	}
}

在这段代码中，我们在person的基础上建立了superPerson这个类，并且加强了chifan方法，这样的设计是站在原有的类的基础上的，比继承更加灵活些。