<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