JAVA經常使用設計模式(靜態化調用和實例化調用的區別,編輯可見 )

用newInstance()與用new是區別的,區別在於建立對象的方式不同,前者是使用類加載機制,後者是建立一個新類,且newInstance()只能調用無參構造函數。java

最大的區別在於內存。
靜態方法在程序開始時生成內存,實例方法在程序運行中生成內存,
因此靜態方法能夠直接調用,實例方法要先成生實例,經過實例調用方法,靜態速度很快,可是多了會佔內存。
任何語言都是對內存和磁盤的操做,至因而否面向對象,只是軟件層的問題,底層都是同樣的,只是實現方法不一樣。
靜態內存是連續的,由於是在程序開始時就生成了,而實例申請的是離散的空間,因此固然沒有靜態方法快,
並且靜態內存是有限制的,太多了程序會啓動不了。
設計模式

1.單例設計模式安全

       所謂單例設計模式簡單說就是不管程序如何運行,採用單例設計模式的類(Singleton類)永遠只會有一個實例化對象產生。具體實現步驟以下:服務器

      (1) 將採用單例設計模式的類的構造方法私有化(採用private修飾)。網絡

      (2) 在其內部產生該類的實例化對象,並將其封裝成private static類型。ide

      (3) 定義一個靜態方法返回該類的實例。函數

         示例代碼以下:this

 }spa

1、單例模式的介紹      Singleton是一種建立型模式,指某個類採用Singleton模式,則在這個類被建立後,只可能產生一個實例供外部訪問,而且提供一個全局的訪問點
2、單例模式的實現
實現的方式有以下四種:
.net

Java代碼 複製代碼 收藏代碼
  1. /**
  2. * 單例模式的實現:餓漢式,線程安全 但效率比較低
  3. */ 
  4. public class SingletonTest {  
  5.  
  6.     private SingletonTest() {  
  7.     }  
  8.  
  9.     private static final SingletonTest instance = new SingletonTest();  
  10.  
  11.     public static SingletonTest getInstancei() {  
  12.         return instance;  
  13.     }  
  14.  
  1. /**
  2. *
  3. * 單例模式的實現:餓漢式,線程安全 但效率比較低
  4. */ 
  5. public class SingletonTest { 
  6.  
  7.     private SingletonTest() { 
  8.     } 
  9.  
  10.     private static final SingletonTest instance = new SingletonTest(); 
  11.  
  12.     public static SingletonTest getInstancei() { 
  13.         return instance; 
  14.     } 
  15.  
 

 

 

2.工廠設計模式

     簡單工廠模式是屬於建立型模式,又叫作靜態工廠方法(Static Factory Method)模式 。簡單工廠模式是由一個工廠對象決定建立出哪種產品類的實例。

 

 

 

 

interface Animal{  public void say(); } class Dog implements Animal{  public void say(){   System.out.println("A");  }  } class Cat implements Animal{  public void say(){   System.out.println("B");  } } class Factory { // 定義工廠類      public static Animal getInstance(String className) {       Animal a = null; // 定義接口對象        if ("Cat".equals(className)) { // 判斷是哪一個子類的標記           a = new Cat(); // 經過Cat子類實例化接口          }         if ("Dog".equals(className)) { // 判斷是哪一個子類的標記             a = new Dog(); // 經過Dog子類實例化接口         }          return a;     }  }

 

public class FactoryDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   Factory b =new Factory();      //  Animal  a = new  Animal();接口是不能被實例化的       Animal  a = b.getInstance("Dog"); // 經過工廠獲取實例         a.say(); // 調用方法   } }

 

 

 

3.代理設計模式

       指由一個代理主題來操做真實主題,真實主題執行具體的業務操做,而代理主題負責其餘相關業務的處理。好比生活中的經過代理訪問網絡,客戶經過網絡代理鏈接網絡(具體業務),由代理服務器完成用戶權限和訪問限制等與上網相關的其餘操做(相關業務)。

      示例代碼以下:

Java代碼 複製代碼 收藏代碼
  1. interface Network { // 定義Network接口 
  2.     public void browse(); // 定義瀏覽的抽象方法 
  3. }  
  4.  
  5. class Real implements Network { // 真實的上網操做 
  6.     public void browse() { // 覆寫抽象方法 
  7.         System.out.println("上網瀏覽信息!");  
  8.     }  
  9. }  
  10.  
  11. class Proxy implements Network { // 代理上網 
  12.     private Network network;  
  13.  
  14.     public Proxy(Network network) {// 設置代理的真實操做 
  15.         this.network = network; // 設置代理的子類 
  16.     }  
  17.  
  18.     public void check() { // 身份驗證操做 
  19.         System.out.println("檢查用戶是否合法!");  
  20.     }  
  21.  
  22.     public void browse() {  
  23.         this.check(); // 調用具體的代理業務操做 
  24.         this.network.browse(); // 調用真實的上網操做 
  25.     }  
  26. }  
  27.  
  28. public class ProxyDemo {  
  29.     public static void main(String args[]) {  
  30.         Network net = null; // 定義接口對象 
  31.         net = new Proxy(new Real()); // 實例化代理,同時傳入代理的真實操做 
  32.         net.browse(); // 調用代理的上網操做  
  33.     }  
  1. interface Network { // 定義Network接口 
  2.     public void browse(); // 定義瀏覽的抽象方法 
  3.  
  4. class Real implements Network { // 真實的上網操做 
  5.     public void browse() { // 覆寫抽象方法 
  6.         System.out.println("上網瀏覽信息!"); 
  7.     } 
  8.  
  9. class Proxy implements Network { // 代理上網 
  10.     private Network network; 
  11.  
  12.     public Proxy(Network network) {// 設置代理的真實操做 
  13.         this.network = network; // 設置代理的子類 
  14.     } 
  15.  
  16.     public void check() { // 身份驗證操做 
  17.         System.out.println("檢查用戶是否合法!"); 
  18.     } 
  19.  
  20.     public void browse() { 
  21.         this.check(); // 調用具體的代理業務操做 
  22.         this.network.browse(); // 調用真實的上網操做 
  23.     } 
  24.  
  25. public class ProxyDemo { 
  26.     public static void main(String args[]) { 
  27.         Network net = null; // 定義接口對象 
  28.         net = new Proxy(new Real()); // 實例化代理,同時傳入代理的真實操做 
  29.         net.browse(); // 調用代理的上網操做 
  30.     } 
interface Network { // 定義Network接口
	public void browse(); // 定義瀏覽的抽象方法
}

class Real implements Network { // 真實的上網操做
	public void browse() { // 覆寫抽象方法
		System.out.println("上網瀏覽信息!");
	}
}

class Proxy implements Network { // 代理上網
	private Network network;

	public Proxy(Network network) {// 設置代理的真實操做
		this.network = network; // 設置代理的子類
	}

	public void check() { // 身份驗證操做
		System.out.println("檢查用戶是否合法!");
	}

	public void browse() {
		this.check(); // 調用具體的代理業務操做
		this.network.browse(); // 調用真實的上網操做
	}
}

public class ProxyDemo {
	public static void main(String args[]) {
		Network net = null; // 定義接口對象
		net = new Proxy(new Real()); // 實例化代理,同時傳入代理的真實操做
		net.browse(); // 調用代理的上網操做
	}
}

4.觀察者設計模式

       所謂觀察者模式,舉個例子如今許多購房者都密切觀察者房價的變化,當房價變化時,全部購房者都能觀察到,以上的購房者屬於觀察者,這即是觀察者模式。

       java中能夠藉助Observable類和Observer接口輕鬆實現以上功能。固然此種模式的實現也不單單侷限於採用這兩個類。

       示例代碼以下:

Java代碼 複製代碼 收藏代碼
  1. import java.util.Observable;  
  2. import java.util.Observer;  
  3.  
  4. class House extends Observable {  
  5.     private float price;  
  6.  
  7.     public void setPrice(float price) {  
  8.         this.setChanged();// 設置變化點 
  9.         this.notifyObservers(price);// 通知全部觀察者價格改變 
  10.         this.price = price;  
  11.     }  
  12.  
  13.     public float getPrice() {  
  14.         return this.price;  
  15.     }  
  16.  
  17.     public House(float price) {  
  18.         this.price = price;  
  19.     }  
  20.  
  21.     public String toString() {  
  22.         return "房子價格爲: " + this.price;  
  23.     }  
  24. }  
  25.  
  26. class HousePriceObserver implements Observer {  
  27.     private String name;  
  28.  
  29.     public HousePriceObserver(String name) {  
  30.         super();  
  31.         this.name = name;  
  32.     }  
  33.  
  34.     @Override 
  35.     public void update(Observable o, Object arg) {// 只要改變了 observable 對象就調用此方法 
  36.         if (arg instanceof Float) {  
  37.             System.out.println(this.name + "觀察的價格更改成:" 
  38.                     + ((Float) arg).floatValue());  
  39.         }  
  40.  
  41.     }  
  42.  
  43. }  
  44.  
  45. public class ObserDeom {  
  46.     public static void main(String[] args) {  
  47.         House h = new House(1000000);  
  48.         HousePriceObserver hpo1 = new HousePriceObserver("購房者A");  
  49.         HousePriceObserver hpo2 = new HousePriceObserver("購房者B");  
  50.         HousePriceObserver hpo3 = new HousePriceObserver("購房者C");  
  51.         h.addObserver(hpo1);// 給房子註冊觀察者  
  52.         h.addObserver(hpo2);// 給房子註冊觀察者  
  53.         h.addObserver(hpo3);// 給房子註冊觀察者  
  54.         System.out.println(h);// 輸出房子價格  
  55.         // 修改房子價格,會觸發update(Observable o, Object arg)方法通知購房者新的房價信息 
  56.         h.setPrice(2222222);//  
  57.         System.out.println(h);// 再次輸出房子價格  
  58.     }  
  1. import java.util.Observable; 
  2. import java.util.Observer; 
  3.  
  4. class House extends Observable { 
  5.     private float price; 
  6.  
  7.     public void setPrice(float price) { 
  8.         this.setChanged();// 設置變化點 
  9.         this.notifyObservers(price);// 通知全部觀察者價格改變 
  10.         this.price = price; 
  11.     } 
  12.  
  13.     public float getPrice() { 
  14.         return this.price; 
  15.     } 
  16.  
  17.     public House(float price) { 
  18.         this.price = price; 
  19.     } 
  20.  
  21.     public String toString() { 
  22.         return "房子價格爲: " + this.price; 
  23.     } 
  24.  
  25. class HousePriceObserver implements Observer { 
  26.     private String name; 
  27.  
  28.     public HousePriceObserver(String name) { 
  29.         super(); 
  30.         this.name = name; 
  31.     } 
  32.  
  33.     @Override 
  34.     public void update(Observable o, Object arg) {// 只要改變了 observable 對象就調用此方法 
  35.         if (arg instanceof Float) { 
  36.             System.out.println(this.name + "觀察的價格更改成:" 
  37.                     + ((Float) arg).floatValue()); 
  38.         } 
  39.  
  40.     } 
  41.  
  42.  
  43. public class ObserDeom { 
  44.     public static void main(String[] args) { 
  45.         House h = new House(1000000); 
  46.         HousePriceObserver hpo1 = new HousePriceObserver("購房者A"); 
  47.         HousePriceObserver hpo2 = new HousePriceObserver("購房者B"); 
  48.         HousePriceObserver hpo3 = new HousePriceObserver("購房者C"); 
  49.         h.addObserver(hpo1);// 給房子註冊觀察者 
  50.         h.addObserver(hpo2);// 給房子註冊觀察者 
  51.         h.addObserver(hpo3);// 給房子註冊觀察者 
  52.         System.out.println(h);// 輸出房子價格 
  53.         // 修改房子價格,會觸發update(Observable o, Object arg)方法通知購房者新的房價信息 
  54.         h.setPrice(2222222);//  
  55.         System.out.println(h);// 再次輸出房子價格 
  56.     } 
相關文章
相關標籤/搜索