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