设计模式

设计模式：解决某一类问题最行之有效的方法。

java中23种设计模式,仅总结了4中设计模式：单例设计模式、模板方法设计模式、装设设计模式和享元设计模式。

单例设计模式：解决一个类在内存只存在一个对象，想要保证对象唯一。

1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？

1，将构造函数私有化。

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

单例设计模式中，有两种设计方法，一种是饿汉式，这种方式一般在自己类中就创建出对象，然后向外提供。另一种是懒汉式，这种方式是在方法被调用时才进行初始化，也叫做对象的延时加载。

饿汉式：

class Single
{
	private  Single(){};  //私有化构造函数
	private static Single s = new Single(); //自己创造对象
	public static  Single getInstance()//对外提供对象的方法
	{
		return s;
	}
}
class SingleDemo 
{
	public static void main(String[] args) 
	{
		Single s1 = Single t. getInstance();
		Single s2 = Single. getInstance()；
	}
}

懒汉式：

class Single
{
	private static Single s = null;
	private Single(){}//私有化构造函数
	public static Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{				
				if(s==null)
					s = new Single();//被调用时才创建对象
			}
		}
		return s;
	}
}
class SingleDemo 
{
	public static void main(String[] args) 
	{
		Single s1 = Single t. getInstance();
		Single s2 = Single. getInstance()；
	}
}

模板方法设计模式：在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。代码如下：

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();
	}
}

这种模式实际上就是通过子类复写父类的方法来完成的。

装饰类设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类于类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

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();
		SuperPerson sp = new SuperPerson(p);
		sp.superChifan();
	}
}

享元模式：也叫做Flyweight。避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).

为什么使用?

面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被共享的类,另外,还有一些特性是取决于应用(context), 是不可共享的,这也Flyweight中两个重要概念内部状态intrinsic 和外部状态extrinsic之分. 说白点,就是先捏一个的原始模型,然后随着不同场合和环境,再产生各具特征的具体模型,很显然,在这里需要产生不同的新对象,所以Flyweight 模式中常出现Factory模式.Flyweight 的内部状态是用来共享的,Flyweight factory 负责维护一个Flyweight pool( 模式池)来存放内部状态的对象. Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中.

比如：

Integer a=3;

Integer b-3;

a和b其实是一个对象，也就是说a==b；在内存中，Integer类的对象，只要在1个字节内的数据都共用对象，也就是在（-128--127）内公用对象。