设计模式

一、模板设计模式

/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。

什么是模版方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。


*/

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) 
	{
		//GetTime gt = new GetTime();
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

二、单例模式

单例设计模式保证在内存中只有一个某个类的实例对象。
思路：

1.将构造方法私有化

2.在类的内部创建一个静态的实例对象
3.编写一个公用的public方法获取该类在内部创建的实例对象

//单例模式

//饿汉式
class Singleton
{
	private static final Singleton s=new Singleton();
    

	private Singleton(){} //将构造方法私有化
	public static Singleton getInstance()
	{
        return s;
	}
}


//懒汉式(延迟加载)
class Singleton
{
	private static Singleton s=null;
    private Singleton(){} //将构造方法私有化

    public static Singleton getInstance()
	{
		if(s==null)
		{   
			s=new Singleton();
			return s;
		}
	}
}



//懒汉式(延迟加载)
//被多线程访问时存在线程安全问题，所以可以采用同步方法
//保障线程安全，但这么做的缺点是,需要对锁反复进行判断，
//比较低效
class Singleton
{
	private static Singleton s=null;
    private Singleton(){} //将构造方法私有化

    public synchronized static Singleton getInstance()
	{
		if(s==null)
		{
			s=new Singleton();
		}
		return s;
	}
}



//双重判断 可以减少锁的判断 提高代码执行效率
class Singleton
{
	private static Singleton s=null;
    private Singleton(){} //将构造方法私有化

    public  static Singleton getInstance()
	{ 
	  if(s==null)
		  {
			  synchronized(Singleton.class)
				{
					if(s==null)
					{
						s=new Singleton();
					}
					
				}
	      }
	 return s;
	}
}