一、大約分為三類：
創(chuàng)新互聯(lián)公司是專業(yè)的東遼網(wǎng)站建設(shè)公司，東遼接單;提供成都做網(wǎng)站、成都網(wǎng)站制作,網(wǎng)頁設(shè)計,網(wǎng)站設(shè)計,建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務;采用PHP框架,可快速的進行東遼網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團隊,希望更多企業(yè)前來合作!
1、創(chuàng)建型模式（5種）：工廠方法模式，抽象工廠模式，單例模式，建造者模式，原型模式。
2、結(jié)構(gòu)型模式（7種）：適配器模式，裝飾器模式，代理模式，外觀模式，橋接模式，組合模式，享元模式。
3、行為型模式（11種）：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態(tài)模式、訪問者模式、中介者模式、解釋器模式。
二、設(shè)計模式遵循的原則有6個：
1、開閉原則（OpenClosePrinciple）
對擴展開放，對修改關(guān)閉。
2、里氏代換原則（LiskovSubstitutionPrinciple）
只有當衍生類可以替換掉基類，軟件單位的功能不受到影響時，基類才能真正被復用，而衍生類也能夠在基類的基礎(chǔ)上增加新的行為。
3、依賴倒轉(zhuǎn)原則（DependenceInversionPrinciple）
這個是開閉原則的基礎(chǔ)，對接口編程，依賴于抽象而不依賴于具體。
4、接口隔離原則（InterfaceSegregationPrinciple）
使用多個隔離的借口來降低耦合度。
5、迪米特法則（最少知道原則）（DemeterPrinciple）
一個實體應當盡量少的與其他實體之間發(fā)生相互作用，使得系統(tǒng)功能模塊相對獨立。
6、合成復用原則（CompositeReusePrinciple）
原則是盡量使用合成/聚合的方式，而不是使用繼承。繼承實際上破壞了類的封裝性，超類的方法可能會被子類修改。
.餓漢式單例類
//餓漢式單例類.在類初始化時，已經(jīng)自行實例化
public class Singleton1 {
//私有的默認構(gòu)造子
private Singleton1() {}
//已經(jīng)自行實例化
private static final Singleton1 single = new Singleton1();
//靜態(tài)工廠方法
public static Singleton1 getInstance() {
return single;
}
}
2.懶漢式單例類
//懶漢式單例類.在第一次調(diào)用的時候?qū)嵗?/p>
public class Singleton2 {
//私有的默認構(gòu)造子
private Singleton2() {}
//注意，這里沒有final
private static Singleton2 single=null;
//靜態(tài)工廠方法
public synchronized static Singleton2 getInstance() {
if (single == null) {
single = new Singleton2();
}
return single;
}
}
//對懶漢式單例的改進(錯誤的改進)
//實際上，只有在第一次創(chuàng)建對象的時候需要加鎖，之后就不需要了 ，這樣可以提升性能
public synchronized static Singleton2 getInstance() {
if (instance == null) {
synchronized(instance){ //鎖住當前實例對象
if(instance == null){
instance = new Singleton2();
}
}
}
return instance;
}
錯誤原因：
aA、B線程同時進入了第一個if判斷
bA首先進入synchronized塊，由于instance為null，所以它執(zhí)行instance = new Singleton();
c由于JVM內(nèi)部的優(yōu)化機制，JVM先畫出了一些分配給Singleton實例的空白內(nèi)存，并賦值給instance成員（注意此時JVM沒有開始初始化這個實例），然后A離開了synchronized塊。
dB進入synchronized塊，由于instance此時不是null，因此它馬上離開了synchronized塊并將結(jié)果返回給調(diào)用該方法的程序。
e此時B線程打算使用Singleton實例，卻發(fā)現(xiàn)它沒有被初始化，于是錯誤發(fā)生了。
正確改進（使用內(nèi)部類）：
JVM內(nèi)部的機制能夠保證當一個類被加載的時候，這個類的加載過程是線程互斥的，JVM能夠幫我們保證instance只被創(chuàng)建一次，
并且會保證把賦值給instance的內(nèi)存初始化完畢，這樣我們就不用擔心上面的問題。
同時該方法也只會在第一次調(diào)用的時候使用互斥機制，這樣就解決了低性能問題
public?class?Singleton?{??
??
/*?私有構(gòu)造方法，防止被實例化?*/??
private?Singleton(){
}
/*?此處使用一個內(nèi)部類來維護單例?*/??
private?static?class?SingletonFactory?{??
private?static?Singleton?instance?=?new?Singleton();??
}
/*?獲取實例?*/??
public?static?Singleton?getInstance()?{??
return?SingletonFactory.instance;??
}
/*?如果該對象被用于序列化，可以保證對象在序列化前后保持一致?*/??
public?Object?readResolve()?{??
return?getInstance();??
}
}
其實說它完美，也不一定，如果在構(gòu)造函數(shù)中拋出異常，實例將永遠得不到創(chuàng)建，也會出錯？？？？
第二種改進：
因為我們只需要在創(chuàng)建類的時候進行同步，所以只要將創(chuàng)建和getInstance()分開，
單獨為創(chuàng)建加synchronized關(guān)鍵字，也是可以的
public class Singleton {
private static Singleton instance=null;
private Singleton(){}
private static synchronized void Init(){
if(instance==null)
instance=new Singletion();
}
public static Singleton getInstance(){
if(instance==null){
Init();
}
return instance;
}
}
3.登記式單例類
import java.util.HashMap;
import java.util.Map;
//登記式單例類.
//類似Spring里面的方法，將類名注冊，下次從里面直接獲取。
public class Singleton3 {
private static MapString,Singleton3 map = new HashMapString,Singleton3();
static{
Singleton3 single = new Singleton3();
map.put(single.getClass().getName(), single);
}
//保護的默認構(gòu)造子
protected Singleton3(){}
//靜態(tài)工廠方法,返還此類惟一的實例
public static Singleton3 getInstance(String name) {
if(name == null) {
name = Singleton3.class.getName();
System.out.println("name == null"+"---name="+name);
}
if(map.get(name) == null) {
try {
map.put(name, (Singleton3) Class.forName(name).newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return map.get(name);
}
//一個示意性的商業(yè)方法
public String about() {
return "Hello, I am RegSingleton.";
}
public static void main(String[] args) {
Singleton3 single3 = Singleton3.getInstance(null);
System.out.println(single3.about());
}
}
JDK為程序員提供了大量的類庫 而為了保持類庫的可重用性 可擴展性和靈活性 其中使用到了大量的設(shè)計模式 本文將介紹JDK的I/O包中使用到的Decorator模式 并運用此模式 實現(xiàn)一個新的輸出流類
Decorator模式簡介
Decorator模式又名包裝器(Wrapper) 它的主要用途在于給一個對象動態(tài)的添加一些額外的職責 與生成子類相比 它更具有靈活性
有時候 我們需要為一個對象而不是整個類添加一些新的功能 比如 給一個文本區(qū)添加一個滾動條的功能 我們可以使用繼承機制來實現(xiàn)這一功能 但是這種方法不夠靈活 我們無法控制文本區(qū)加滾動條的方式和時機 而且當文本區(qū)需要添加更多的功能時 比如邊框等 需要創(chuàng)建新的類 而當需要組合使用這些功能時無疑將會引起類的爆炸
我們可以使用一種更為靈活的方法 就是把文本區(qū)嵌入到滾動條中 而這個滾動條的類就相當于對文本區(qū)的一個裝飾 這個裝飾(滾動條)必須與被裝飾的組件(文本區(qū))繼承自同一個接口 這樣 用戶就不必關(guān)心裝飾的實現(xiàn) 因為這對他們來說是透明的 裝飾會將用戶的請求轉(zhuǎn)發(fā)給相應的組件(即調(diào)用相關(guān)的方法) 并可能在轉(zhuǎn)發(fā)的前后做一些額外的動作(如添加滾動條) 通過這種方法 我們可以根據(jù)組合對文本區(qū)嵌套不同的裝飾 從而添加任意多的功能 這種動態(tài)的對對象添加功能的方法不會引起類的爆炸 也具有了更多的靈活性
以上的方法就是Decorator模式 它通過給對象添加裝飾來動態(tài)的添加新的功能 如下是Decorator模式的UML圖
Component為組件和裝飾的公共父類 它定義了子類必須實現(xiàn)的方法
ConcreteComponent是一個具體的組件類 可以通過給它添加裝飾來增加新的功能
Decorator是所有裝飾的公共父類 它定義了所有裝飾必須實現(xiàn)的方法 同時 它還保存了一個對于Component的引用 以便將用戶的請求轉(zhuǎn)發(fā)給Component 并可能在轉(zhuǎn)發(fā)請求前后執(zhí)行一些附加的動作
ConcreteDecoratorA和ConcreteDecoratorB是具體的裝飾 可以使用它們來裝飾具體的Component
Java IO包中的Decorator模式
JDK提供的java io包中使用了Decorator模式來實現(xiàn)對各種輸入輸出流的封裝 以下將以java io OutputStream及其子類為例 討論一下Decorator模式在IO中的使用
首先來看一段用來創(chuàng)建IO流的代碼
以下是代碼片段
try {
DataOutputStream out = new DataOutputStream(new FileOutputStream(
test txt ));
} catch (FileNotFoundException e) {
e printStackTrace();
}
這段代碼對于使用過JAVA輸入輸出流的人來說再熟悉不過了 我們使用DataOutputStream封裝了一個FileOutputStream 這是一個典型的Decorator模式的使用 FileOutputStream相當于Component DataOutputStream就是一個Decorator 將代碼改成如下 將會更容易理解
以下是代碼片段
try {
OutputStream out = new FileOutputStream( test txt );
out = new DataOutputStream(out);
} catch(FileNotFoundException e) {
e printStatckTrace();
}
由于FileOutputStream和DataOutputStream有公共的父類OutputStream 因此對對象的裝飾對于用戶來說幾乎是透明的 下面就來看看OutputStream及其子類是如何構(gòu)成Decorator模式的
OutputStream是一個抽象類 它是所有輸出流的公共父類 其源代碼如下
以下是代碼片段
public abstract class OutputStream implements Closeable Flushable {
public abstract void write(int b) throws IOException;
}
它定義了write(int b)的抽象方法 這相當于Decorator模式中的Component類
ByteArrayOutputStream FileOutputStream 和 PipedOutputStream 三個類都直接從OutputStream繼承 以ByteArrayOutputStream為例
以下是代碼片段
public class ByteArrayOutputStream extends OutputStream {
protected byte buf[];
protected int count;
public ByteArrayOutputStream() {
this( );
}
public ByteArrayOutputStream(int size) {
if (size 〈 ) {
throw new IllegalArgumentException( Negative initial size: + size);
}
buf = new byte[size];
}
public synchronized void write(int b) {
int newcount = count + ;
if (newcount 〉 buf length) {
byte newbuf[] = new byte[Math max(buf length 〈〈 newcount)];
System arraycopy(buf newbuf count);
buf = newbuf;
}
buf[count] = (byte)b;
count = newcount;
}
}
它實現(xiàn)了OutputStream中的write(int b)方法 因此我們可以用來創(chuàng)建輸出流的對象 并完成特定格式的輸出 它相當于Decorator模式中的ConcreteComponent類
接著來看一下FilterOutputStream 代碼如下
以下是代碼片段
public class FilterOutputStream extends OutputStream {
protected OutputStream out;
public FilterOutputStream(OutputStream out) {
this out = out;
}
public void write(int b) throws IOException {
out write(b);
}
}
同樣 它也是從OutputStream繼承 但是 它的構(gòu)造函數(shù)很特別 需要傳遞一個OutputStream的引用給它 并且它將保存對此對象的引用 而如果沒有具體的OutputStream對象存在 我們將無法創(chuàng)建FilterOutputStream 由于out既可以是指向FilterOutputStream類型的引用 也可以是指向ByteArrayOutputStream等具體輸出流類的引用 因此使用多層嵌套的方式 我們可以為ByteArrayOutputStream添加多種裝飾 這個FilterOutputStream類相當于Decorator模式中的Decorator類 它的write(int b)方法只是簡單的調(diào)用了傳入的流的write(int b)方法 而沒有做更多的處理 因此它本質(zhì)上沒有對流進行裝飾 所以繼承它的子類必須覆蓋此方法 以達到裝飾的目的
BufferedOutputStream 和 DataOutputStream是FilterOutputStream的兩個子類 它們相當于Decorator模式中的ConcreteDecorator 并對傳入的輸出流做了不同的裝飾 以BufferedOutputStream類為例
以下是代碼片段
public class BufferedOutputStream extends FilterOutputStream {
private void flushBuffer() throws IOException {
if (count 〉 ) {
out write(buf count);
count = ;
}
}
public synchronized void write(int b) throws IOException {
if (count 〉= buf length) {
flushBuffer();
}
buf[count++] = (byte)b;
}
}
這個類提供了一個緩存機制 等到緩存的容量達到一定的字節(jié)數(shù)時才寫入輸出流 首先它繼承了FilterOutputStream 并且覆蓋了父類的write(int b)方法 在調(diào)用輸出流寫出數(shù)據(jù)前都會檢查緩存是否已滿 如果未滿 則不寫 這樣就實現(xiàn)了對輸出流對象動態(tài)的添加新功能的目的
下面 將使用Decorator模式 為IO寫一個新的輸出流
自己寫一個新的輸出流
了解了OutputStream及其子類的結(jié)構(gòu)原理后 我們可以寫一個新的輸出流 來添加新的功能 這部分中將給出一個新的輸出流的例子 它將過濾待輸出語句中的空格符號 比如需要輸出 java io OutputStream 則過濾后的輸出為 javaioOutputStream 以下為SkipSpaceOutputStream類的代碼
以下是代碼片段
import java io FilterOutputStream;
import java io IOException;
import java io OutputStream;
/**
* A new output stream which will check the space character
* and won t write it to the output stream
* @author Magic
*
*/
public class SkipSpaceOutputStream extends FilterOutputStream {
public SkipSpaceOutputStream(OutputStream out) {
super(out);
}
/**
* Rewrite the method in the parent class and
* skip the space character
*/
public void write(int b) throws IOException{
if(b!= ){
super write(b);
}
}
}
它從FilterOutputStream繼承 并且重寫了它的write(int b)方法 在write(int b)方法中首先對輸入字符進行了檢查 如果不是空格 則輸出
以下是一個測試程序
以下是代碼片段
import java io BufferedInputStream;
import java io DataInputStream;
import java io DataOutputStream;
import java io IOException;
import java io InputStream;
import java io OutputStream;
/**
* Test the SkipSpaceOutputStream
* @author Magic
*
*/
public class Test {
public static void main(String[] args){
byte[] buffer = new byte[ ];
/**
* Create input stream from the standard input
*/
InputStream in = new BufferedInputStream(new DataInputStream(System in));
/**
* write to the standard output
*/
OutputStream out = new SkipSpaceOutputStream(new DataOutputStream(System out));
try {
System out println( Please input your words: );
int n = in read(buffer buffer length);
for(int i= ;i〈n;i++){
out write(buffer[i]);
}
} catch (IOException e) {
e printStackTrace();
}
}
}
執(zhí)行以上測試程序 將要求用戶在console窗口中輸入信息 程序?qū)⑦^濾掉信息中的空格 并將最后的結(jié)果輸出到console窗口 比如
以下是引用片段
Please input your words:
a b c d e f
abcdef
總 結(jié)
lishixinzhi/Article/program/Java/gj/201311/27433
重慶分公司
重慶分公司
