<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">1单例模式（Singleton）</span>1）单例是指只拥有一个实例对象(全局可见)的类
2）问题解决
A.确保一个类只有一个或有限数量的实例对象
B.不同场景共享同一个实例对象
3）提供一个私有的构造方法，定义一个公共的静态方法控制创建的实例对象
4）缺点
eg Logger（昂贵对象）：无状态，占用大量存储空间
public class Logger {
<span style="color:#ff0000;">private static</span> Logger logger;
<span style="color:#ff0000;">private</span> Logger(){
System.out.println("Logger 实例化");
};
public <span style="color:#ff0000;">static</span> Logger getInstance(){
if(null == logger) <span style="white-space:pre"> </span>//多线程不安全
logger = new Logger();
System.out.println("获取logger");
return logger;
}
}public class Client {
public static void main(String []arg){
Logger g1 = Logger.getInstance();
Logger g2 = Logger.getInstance();
if(g1 == g2)
System.out.println("对象一致");
}
}输出：
Logger 实例化
获取logger
获取logger
对象一致
解决多线程不安全的问题
（1）饿汉式: 类加载时创建对象
public class Logger {
private static Logger <span style="color:#ff0000;">logger = new Logger()</span>;
private Logger(){
System.out.println("Logger 实例化");
};
public static Logger getInstance(){
System.out.println("获取logger");
return logger;
}
}（2）懒汉式
public class Logger {
private static Logger logger;
private Logger(){
System.out.println("Logger 实例化");
};
<span style="color:#ff0000;">synchronized</span> public static Logger getInstance(){
if(null == logger)
logger = new Logger();
System.out.println("获取logger");
return logger;
}
}改进版，双重锁定检查
public class Logger {
private static Logger logger;
private Logger(){
System.out.println("Logger 实例化");
};
public static Logger getInstance(){
if(<span style="color:#ff0000;">null == logger</span>){
<span style="color:#ff0000;">synchronized (Logger.class)</span> {
<span style="color:#ff0000;">if(null == logger)</span>
logger = new Logger();
}
}
System.out.println("获取logger");
return logger;
}
}
public class Logger {
private Logger(){
System.out.println("Logger 实例化");
};
<span style="color:#ff0000;">private static class HolderClass{
private final static Logger logger = new Logger();
}</span>
public static Logger getInstance(){
return <span style="color:#ff0000;">HolderClass.logger</span>;
}
}2. The prototype pattern原型模式
1）原型是指一种对象，这种对象包括clone方法去拷贝类似的对象，用于减小类的数量
2）问题解决
A．如何减少类的数量并共享相似的行为和关系
3）解决
定义一个类代替相似的类（共享相似的行为和关系）。保存该类的原型，用该原型的clone方法生成新对象
| public class C implements Cloneable{ @override publicObject clone(){ …… return (C) super.clone(); } } |
| C o=new C(); C o1=o.clone(); C o2=o.clone(); C o3=o.clone(); |
| class User implements Cloneable{ public Object clone(){ User object = null; try{ object = (User)super.clone(); }catch (CloneNotSupportedException e) { e.printStackTrace(); } return object; } } class Prototype implements Cloneable{ private String name; private User user; public Prototype(String name){ this.name = name; } public Prototype clone(){ Prototype object = null; try{ object = (Prototype)super.clone(); object.user=(User)this.user.clone();//深拷贝 }catch (CloneNotSupportedException e) { e.printStackTrace(); } return object; } public String toString(){ return name; } } |
2.flyweight 享元模式
1）享元：被不同客户端共享的对象
2）解决问题
A.减少实例的创建
B.共享实例，提高效率和资源利用率
3）解决
（1）抽象享元(Flyweight)角色 ：给出一个抽象接口，以规定出所有具体享元角色需要实现的方法。
（2）具体享元(ConcreteFlyweight)角色：实现抽象享元角色所规定出的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。
（3）复合享元(ConcreteCompositeFlyweight)角色 ：复合享元角色所代表的对象是不可以共享的，但是一个复合享元对象可以分解成为多个本身是单纯享元对象的组合。复合享元角色又称作不可共享的享元对象。
（4）享元工厂(FlyweightFactory)角色 ：本角色负责创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享。当一个客户端对象调用一个享元对象的时候，享元工厂角色会检查系统中是否已经有一个符合要求的享元对象。如果已经有了，享元工厂角色就应当提供这个已有的享元对象；如果系统中没有一个适当的享元对象的话，享元工厂角色就应当创建一个合适的享元对象。
| public interface Flyweight { public void operation(String state); } public class ConcreteFlyweightimplements Flyweight { private Character intrinsicState = null; public ConcreteFlyweight(Characterstate){ this.intrinsicState = state; } @Override public void operation(String state) { System.out.println("Intrinsic State = " +this.intrinsicState); System.out.println("Extrinsic State = " + state); } } public classConcreteCompositeFlyweightimplements Flyweight { privateMap<Character,Flyweight>files = new HashMap<Character,Flyweight>(); public void add(Character key , Flyweightfly){ files.put(key,fly); } @Override public void operation(String state) { Flyweight fly = null; for(Object o : files.keySet()){ fly = files.get(o); fly.operation(state); } } }
public class FlyweightFactory { privateMap<Character,Flyweight>files = new HashMap<Character,Flyweight>(); public Flyweightfactory(List<Character> compositeState){ ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight(); for(Character state :compositeState){ compositeFly.add(state,this.factory(state)); } return compositeFly; } public Flyweight factory(Characterstate){ Flyweight fly = files.get(state); if(fly == null){ fly = new ConcreteFlyweight(state); files.put(state, fly); } return fly; } } public class Client { public static void main(String[] args) { List<Character> compositeState = new ArrayList<Character>(); compositeState.add('a'); compositeState.add('b'); FlyweightFactoryflyFactory = new FlyweightFactory(); FlyweightcompositeFly1 = flyFactory.factory(compositeState); FlyweightcompositeFly2 = flyFactory.factory(compositeState); compositeFly1.operation("CompositeCall"); System.out.println("---------------------------------"); System.out.println("复合享元模式是否共享对象：" + (compositeFly1 == compositeFly2)); Character state = 'a'; Flyweight fly1 =flyFactory.factory(state); Flyweight fly2 =flyFactory.factory(state); System.out.println("单纯享元模式是否共享对象：" + (fly1 == fly2)); } } |
http://blog.sina.com.cn/s/blog_8e392fc20101c36y.html
http://blog.sina.com.cn/s/blog_8e392fc20101c410.html
http://www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html
扫一扫
289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
