java pattern

http://blog.163.com/ren_bozhou/blog/static/51689589200802475141861/

http://sunnylocus.iteye.com/blog/232915

http://anysky131.iteye.com/blog/234714

 

访问模式

http://cy729215495.iteye.com/blog/246900

 

http://news.csdn.net/n/20080805/117902.html

http://8366.iteye.com/blog/234718

OBServer 观察者模式 java.util.*            

 

Decorator 装饰器模式 java.io*       

       

Protetype  原型模式    java.lang.Cloneable    

问题：object.clone() 方法：深拷贝和浅拷贝（默认）的区别?

解决：

浅拷贝：拷贝对象

深拷贝：拷贝对象及其引用对象。深拷贝须实现java.lang.Cloneable接口,重写clone()方法，

因为Object的Clone()方法是protected签名的，而Cloneable接口的作用：把protected权限放大到public，这样才可重写Clone()发法。

问题：若引用的对象又引用了其他对象，是否一直判断并复制，过程繁琐？

解决：

重写Clone()方法时直接把对象序列化到磁盘 然后再反序列化回来，这样不用判断就得到反序列化结果，参照ObjectOutPutStream和ObjectInputStream。

 

 

 

 

 

工厂模式为什么会引入, 方便管理这个类.

理解抽象,abstract :1、抽象类内可以无抽象方法。2、抽象类不能创建实例。只能被继承。
当子类覆盖父类时 子类的修饰符不能比父类更严格。

模板模式：父类有时并不能确定，推迟到子类来实现。
         当多态发生时，将会调用子类的方法。
         自己写一个模板模式： 父类规范了一些原则性的东西，具体的实现推迟到子类来实现、

接口：接口是一个total abstract。

工厂模式：实体类，必须都实现同一个接口； 工厂返回一个接口类。

代理模式: 老板判断员工是否加薪,(没有代理时)工作繁琐.这时可以添加一个代理(秘书),为老板省去大量的繁琐工作,再在提交给老板.

适配器模式: 有俩个类,一个可以打方砖,一个可以打圆状.现在需要一个即能打方的又能打圆的类.
            需要适配器模式, 继承一个,合成一个.

策略模式:  一个接口,引入一系列实现类.当我加一个实现类时,我的程序会很容易切换.不用改变程序的结构   .
           打个比方我们画画是借助于笔的笔芯来画的,笔芯是可以换的.(可换笔芯的笔.)
 
命令模式: 你是命令你就能执行.

最难的是喝咖啡:杯子和咖啡 .  这是个结构和行为交织到一起的类.桥模式

1995年5月23号  叫java语言的 诞生了.

治书先治史.

 

java23种设计模式：

单态模式

http://kang.iteye.com/blog/228735

http://8366.iteye.com/blog/238200

 

 

 

package com.javaeye.lindows.design23;

public class FileOpen {
	/**
	 * @author Lindows
	 */
	public FileOpen() {
		System.out.println("默认构造函数,可以让外界直接new对象");
	}

	public void createFile() {
		System.out.println("创建文件");
	}
}

 

 

package com.javaeye.lindows.design23;

public class FileOpen2 {
	private FileOpen2(){
		System.out.println("定义私有构造函数,不让外界直接new");
	}
       //方式一：饿汉式单例模式:指全局的单例实例在类装载时构建。(一般认为这种方式要更加安全些)	
	public void createFile2(){
		System.out.println("创建文件");
	}
       //在自己内部定义自己的一个private实例,只供内部调用	
	private static final FileOpen2 fileOpen2 = new FileOpen2();

	// 使用我对外界提供本类自己的new的对象,供外部访问本class的静态方法
	public static FileOpen2 getInstance() {
		return fileOpen2;
	}
	
}

 

 

package com.javaeye.lindows.design23;

public class FileOpen3 {
	/*
	 * 使用单态模式，对于多线程不太安全，通过加载同步方法来保证线程安全
	 */
	private FileOpen3(){
		System.out.println("定义私有构造函数,不让外界直接new");
	}
	public void createFile() {
		System.out.println("创建文件");
	}
       //方式二：懒汉式单例模式,指全局的单例实例在第一次被使用时构建。
	private static FileOpen3 fileOpen3 = null;
      //syschronized,互斥锁,同步机制,虽然这样会减低效率
       public static synchronized FileOpen3 getInstance() {
		if (fileOpen3 == null) {
			fileOpen3 = new FileOpen3();
		}
		System.out.println("使用单态模式，对于多线程不太安全，通过加载同步方法来保证线程安全");
		return fileOpen3;
		
	}
}

 

 

 

 

 

package com.javaeye.lindows.design23;

/**
 * @author Lindows
 * 
 */
public class FileOpen4 {
	private FileOpen4() {
		System.out.println("定义私有构造函数,不让外界直接new");
	}

	// 内部类
	private static class MyFileOpen4 {
		private static FileOpen4 fileOpen4 = new FileOpen4();
	}

	public void createFile() {
		System.out.println("创建文件");
	}

	public static FileOpen4 getInstance() {
		return MyFileOpen4.fileOpen4;
	}
	/*
	 * 加载FileOpen4时并不加载它的内部类MyFileOpen4,调用getInstance()后调用
	 * MyFileOpen4时才加载MyFileOpen4,从而调用FileOpen4的构造函数,实例化FileOpen4,从而达到 lazy
	 * loading
	 */
}

 

 

 

 

 

 

package com.javaeye.lindows.design23;

public class SingletonTest {

	/**
	 * @author Lindows
	 * 场景:
	 * 在一个系统中,需要经常对文件系统进行操作,如传建文件、拷贝文件等等,假如这些功能用FileOpen类封装,你如何调用这个类?
	 * FileOpen fo = new FileOpen();
	 * fo.createFile();
	 * 但是我们发现:
	 * 这个类的工作与具体的业务逻辑似乎关系不大,他做的是一些共性工作,每次调用时都实例化,似乎太消耗内存。
	 * 怎样保证在调用的时候，系统只有一个对象?
	 * 1.利用静态变量可以做到
	 * 2.第二种方法
	 * 举例：
	 * Hibernate中,SessionFactory的生成;注意有时候看文档,有些类的构造函数是被保护的,或者没有构造函数,十有八九用的就是单例模式。
	 * 如果：
	 * 模块做的工作比较公共化,或者模块比较消耗内存.
	 * 例如：
	 * 字典的载人,application实际上就是实现了单例模式
	 * Logger logger = Logger.getLogger();
	 * 练习：
	 * 完成DirCreator,要求里面包含创建目录的代码,使用单例模式,测试。 
	 */
	public static void main(String[] args) {
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
		/*
		 * 没有使用单例模式两次new FileOpen();调用了两次构造函数
		 * 假如使用 FileOpen fileOpen1 = fileOpen
		 * 就会强求程序员使用1000行代码前定义的 fileOpen
		 */
		FileOpen fileOpen = new FileOpen();
		fileOpen.createFile();
		// 1000行代码
		FileOpen fileOpen1 = new FileOpen();
		fileOpen1.createFile();
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
		/*
		 * 直接提供FileOpen2类本身对外提供的对象,不再人为的new对象
		 */
		FileOpen2 fo = FileOpen2.getInstance();
		fo.createFile2();
		//1000行代码
		FileOpen2 fo2 = FileOpen2.getInstance();
		fo2.createFile2();
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
		/*
		 * 直接提供FileOpen2类本身对外提供的对象,不再人为的new对象
		 */
		FileOpen3 fOpen3 = FileOpen3.getInstance();
		fOpen3.createFile();
		//1000行代码
		FileOpen3 fOpen32 = FileOpen3.getInstance();
		fOpen32.createFile();
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

		/*
		 * 加载FileOpen4时并不加载它的内部类MyFileOpen4,调用getInstance()后调用
		 * MyFileOpen4时才加载MyFileOpen4,从而调用FileOpen4的构造函数,实例化singleton,从而达到 lazy
		 * loading
		 */
		FileOpen4 fOpen4 = FileOpen4.getInstance();
		fOpen4.createFile();
		// 1000行代码
		FileOpen4 fOpen4a = FileOpen4.getInstance();
		fOpen4a.createFile();
		System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");


	}
	/**
	 * Singleton模式小结：
	 * Singleton模式主要作用是保证在java应用程序中,一个类Class只有一个实例存在.
	 * 在很多操作中,比如建立目录数据库连接,都需要这样的操作。
	 * 适合做公共工作,Singleton模式就为我们提供了这样的实现的可能。
	 * 使用Singleton的好处在于可以节省内存,因为它限制了实例的个数,有利于java的垃圾回收(garbage collection)。
	 */

}

 

 

 

 dsafasfaf

 

 

sadfsafsfsf

 

 

 

asdfasfasd