黑马程序员——设计模式

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

设计模式

      java中有23种设计模式：

         我们现在介绍单例设计和模块设计方式

 单例设计模式：（解决一个类在对象中，只存在一个对象）
 
          * 想要保证对象的唯一
          * 1，为了避免其它程序过多的建立该类对象，先禁止其它程序建立该类对象。
          * 2，还为了让其它程序可以访问到该类对象，只好在本类中，自定义一个对象。
          * 3，为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式。

            模块设计

               

              * 什么是模板方法呢？

              * 在定义功能时，功能的一部分是确定的，但是有一部分是不确定的。

              * 而确定部分正在使用不确定部分，那么这时就将不确定部分暴露出去。

              * 由该类的子类去完成

     

为什么有饿汉式还会有懒汉式？

原因就是对了面试，因为面试都是考懒汉式

 

   懒汉式单例效率低，解决效率低的问题，使用双重if进行判断。

   懒汉式单例存在多线程安全问题，解决安全问题的方法是加同步锁

 

总结：

饿汉式：一上来就对对象初始化。

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

饿汉式

图示

/*
 * 设计模式：
 * java中有23种设计模式：
 * 我们介绍其中一种设计模式：
 * 单例设计模式：（解决一个类在对象中，只存在一个对象）
 * 
 * 想要保证对象的唯一
 * 1，为了避免其它程序过多的建立该类对象，先禁止其它程序建立该类对象。
 * 2，还为了让其它程序可以访问到该类对象，只好在本类中，自定义一个对象。
 * 3，为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式。
 * 
 * 这三步使用代码体现方式？
 * 1，将构造函数私有化。
 * 2，在类中创建一个本类对象。
 * 3，提供一个方法可以获取该对象。
 * 
 * 什么时候使用？
 * 对于事物该怎么描述，还怎么描述
 * 当需要将该事物的对象在内存中唯一时，就将以上三步加上即可。
 * 例如下面代码：Studetn类（对一个特殊学生定义：唯一的学生）
 */

class Single
{
	private int num;
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}
	private Single(){}          //第一步：将初始化构造函数私有化。
	
	//由于不能让外部访问此方法，所以前面要加private 
	private static Single s = new Single();    //第二步：在本类中创建一个本类对象。
	public static Single getInstance() //第三步：提供一个方法，获取该对象。（返回值是：调用哪个方法返回哪个）
	{
		return s;   //因为静态成员只能访问静态成员变量，所以上面的s 也要加上static
	}
}
public class _08设计模式 {
	
	public static void main(String[] args)
	{
		//如何调用上面的对象？因为不能创建对象new....所以只能通过类名.方法名  所以方法加static
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		s1.setNum(33);//赋值
		System.out.println(s2.getNum());
		
		Student d1 = Student.StudetnInstance();
		Student d2 = Student.StudetnInstance();
		d1.setAge(22);//给d1赋值后，再打印d2的年龄；也是22，
		System.out.println(d2.getAge());//结果是：22
	}

}
class Student
{
	private int age;
	public void setAge(int age)
	{
		this.age=age;
	}
	public int getAge()
	{
		return age;
	}
	private Student(){}
	private static Student s = new Student();
	public static Student StudetnInstance()
	{
		return s;
	}
}

懒汉式

/*
 * 第一种方式称为：饿汉式
 * 这是先初始化对象
 * Single类一进入内存，就已经创建好了对象
 */
/*
class Single
{
	private String name;
	private Single(){};
	private static Single s = new Single();
	public static Single SingleInstance()
	{
		return s;
	}
}
*/
/*
 * 第二种方式  称为：懒汉式
 * 对象是被方法调用时，才初始化，也叫做对象的延时加载。
 * Single类进内存，对象还没有存在，只有调用了“SingleInstance方法时，才建立对象”
 */
class Singlee
{
	private static Singlee s = null;
	private Singlee(){}
	public static Singlee SingleInstance()
	{
		if(s==null)//双重if判断
		{
			synchronized(Singlee.class)//上锁
			{
				if(s==null)  //-->A 线程执行的时候，还没有执行完时,有可能会被其它线程抢去，所以需要再次判断
				{
					s = new Singlee();
				}
			}
		}
		return s;
	}
}
public class _09设计模式_单例_懒汉式 {
	
	public static void main(String[] args)
	{
		Singlee s = Singlee.SingleInstance();
		
	}

}

模块设计

/*
 * 需求：获取一段程序运行的时间
 * 原理：获取程序开始和结束的时间并相减即可。
 * 
 * 获取时间的Java提供代码块是：System.currentTimeMillis();
 * 
 * 当代码完成优化后，就可以解决这类问题。
 * 
 * 这种方式，模板方法设计模式
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 什么是模板方法呢？
 * 在定义功能时，功能的一部分是确定的，但是有一部分是不确定的。
 * 而确定部分正在使用不确定部分，那么这时就将不确定部分暴露出去。
 * 由该类的子类去完成
 */
abstract class getTime
{
	public final void getTime() //不允许覆写
	{
		long start = System.currentTimeMillis();//变量要用：long
		TimeRun();//调用方法
		long end = System.currentTimeMillis();
		System.out.println("运行时间："+(end-start)+"毫秒");
	}
	public abstract void TimeRun();//此为抽象方法：因为它具有不确定性   abstract
}
class SubTime extends getTime
{
	public void TimeRun()
	{
		for(int x=0;x<40000;x++)
		{
			System.out.println(x);
		}
	}
}
public class _07设计模式_模块设计 {
	
	public static void main(String[]args)
	{
		SubTime st = new SubTime();
		st.getTime();
	}
}

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------