1）：單例模式

package designMode.singleton;
/**
 * 單例模式形成的原因：
 * 
 * 構造器私有---> 外界無法例項化，就在類內部建立一個例項物件，用static修飾，可以用類名直接呼叫---> 但是，類的一般用法都講究封裝，例項化物件封裝 
 * ---> 建立getInstance()方法 ---> 由於instance是靜態屬性，所以方法需要static修飾
 *
 */
public class Singleton {
	private static Singleton instance = new Singleton();
	
	private Singleton(){
		
	}
	
	public static Singleton getInstance(){
		return instance;
	}
	public void print(){
		System.out.println("單例模式！");
	}
	
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();//訪問類中的靜態方法，取得類中的靜態例項
		Singleton s2 = Singleton.getInstance();
		Singleton s3 = Singleton.getInstance();
		s1.print();								//輸出資訊
		s2.print();
		s3.print();
		
	}
}
 

結果：

單例模式！
單例模式！
單例模式！

2）：工廠模式：

程式在介面和子類之間加入了一個過度端，通過此過度端取得介面的例項化物件，一般都會稱這個過渡端為工廠類；

因為介面物件的例項是從工廠取得的，以後如果再有子類擴充，直接修改工廠類客戶端既可以根據標記得到相應的例項，靈活性較高。

package designMode.factory;
/**
 * 父介面
 *
 */
public interface Fruit {

	void eat();
}

package designMode.factory;

public class Apple implements Fruit {

	@Override
	public void eat() {
        System.out.println("**吃蘋果");
	}

}
 

package designMode.factory;

public class Orange implements Fruit{

	@Override
	public void eat() {
		 System.out.println("**吃橘子");
		
	}

}

package designMode.factory;

public class Factory {
	
	public static Fruit getInstance(String fruitString){
		Fruit fruit = null;
		if(fruitString.equals("apple")){
			fruit = new Apple();
		}
		if(fruitString.equals("orange")){
			fruit = new Orange();
		}
		return fruit;
	}
}
 

package designMode.factory;
/**
 * 工廠模式
 *
 */
public class FactoryDemo {
	public static void main(String[] args) {
		Fruit fruit = null;
		fruit = Factory.getInstance("designMode.factory.Orange ");
		fruit.eat();
	}
}

結果：

**吃橘子

將反射應用在工廠模式上

package designMode.factory;
/**
 * 工廠模式
 *
 */
public class FactoryDemo {
	public static void main(String[] args) {
		Fruit fruit = null;
		fruit = Factory.getInstance("orange");
		fruit.eat();
	}
}

結果；

**吃橘子

對比：運用反射的好處，

無論增加多少個子類，子類增加多個個屬性，工廠類不用做任何的修改。

3）：代理模式：

使用者只關心上網，代理處理如何上網，

定義一個上網介面，使用者和代理都實現該介面，分別做自己要做的事情，

package designMode.proxy;

public interface Network {
	void browse();
}

package designMode.proxy;

public class Real implements Network{	//真實的上網操作。

	@Override
	public void browse() {
		System.out.println("真實的上網操作");
		
	}

}

package designMode.proxy;

public class Proxy implements Network {
	
	private Network network;
	
	public Proxy(Network network){
		this.network = network;
	}
	
	public void check(){
		System.out.println("代理檢查使用者是否合法");
	}
	@Override
	public void browse() {
		check();
		network.browse();
	}

}

package designMode.proxy;
/**
 * 代理模式
 *
 */
public class ProxyDemo {

	public static void main(String[] args) {
		new Proxy(new Real()).browse();		//有參構造，例項化代理，執行代理的方法。
	}
}

結果：

代理檢查使用者是否合法
真實的上網操作

4）：介面卡模式：

主介面有太多的方法，如果直接實現，就必須覆寫全部的方法，如果我只想操作其中的幾個，就需要是用介面卡進行適配。

package designMode.adapter;

public interface Window {//定義介面，，定義了很多的方法，但是隻需要使用其中個別的方法，就需要使用代理模式了
	void open();
	void close();
	void activated();
	void iconified();
	void deiconified();
}

package designMode.adapter;

public abstract class WindowAdapter implements Window {//用抽象類實現介面，方法體為空
	@Override
	public void activated() {
		// TODO Auto-generated method stub

	}

	@Override
	public void close() {
		// TODO Auto-generated method stub

	}

	@Override
	public void deiconified() {
		// TODO Auto-generated method stub

	}

	@Override
	public void iconified() {
		// TODO Auto-generated method stub

	}

	@Override
	public void open() {
		// TODO Auto-generated method stub

	}

}

package designMode.adapter;

import java.awt.event.WindowAdapter;

public class WindowImpl extends WindowAdapter  { //例項體繼承 抽象類。重寫需要的方法
	public void open(){
		System.out.println("視窗開啟");
	}
	
	public void close(){
		System.out.println("視窗關閉");
	}
}

package designMode.adapter;

public class AdapterDemo {
	public static void main(String[] args) {	//呼叫介面父類，執行需要的方法，其他的方法沒有結果，在公司的eclipse上執行成功了，可是我自己的卻不行，不知道是什麼原因
		Window window = (Window) new WindowImpl();
		window.open();
		window.close();
		window.activated();
		System.out.println();
		window.iconified();
		System.out.println();
		window.deiconified();
		
	}
}

結果：

視窗開啟
視窗關閉

5）：觀察者設計模式

什麼叫做觀察者

舉個例子，現在很多人買房，都在關注房價，如果價格變動，所有的購房者都可以觀察到，（購房者就是觀察者，這就叫觀察者設計模式）java中使用Observable類和Observer介面，輕鬆實現上述功能。

package library.watch;

import java.util.Observable;


public class House extends Observable{
	
	private float price;
	
	public House(float price){
		this.price = price;
	}

	public float getPrice() {
		return price;
	}

	public void setPrice(float price) {
		super.setChanged();           //設定變化點
		super.notifyObservers(price); //通知所有觀察者價格改變
		this.price = price;
	}

	@Override
	public String toString() {
		return "房子價格為： price=" + price;
	}
	
}

package library.watch;

import java.util.Observable;
import java.util.Observer;

public class HousePriceObserver implements Observer {
	private String name;

	public HousePriceObserver(String name) {
		super();
		this.name = name;
	}

	@Override
	public void update(Observable o, Object arg) {
		if (arg instanceof Float) {		//判斷引數型別
			System.out.print(this.name +"觀察到價格更改為：");
			System.out.println(((Float)arg).floatValue());
		}
	}
public static void main(String[] args) {
	House h = new House(1000000);
	HousePriceObserver hpo1 = new HousePriceObserver("購房者A");
	HousePriceObserver hpo2 = new HousePriceObserver("購房者B");
	HousePriceObserver hpo3 = new HousePriceObserver("購房者C");
	h.addObserver(hpo1);	//加入觀察者
	h.addObserver(hpo2);
	h.addObserver(hpo3);
	System.out.println(h);	//輸出房子價格
	h.setPrice(600000);		//修改房子價格
	System.out.println(h);
}
}

結果：

房子價格為： price=1000000.0
購房者C觀察到價格更改為：600000.0
購房者B觀察到價格更改為：600000.0
購房者A觀察到價格更改為：600000.0
房子價格為： price=600000.0

抽象類--->摸具（繼承的子類都具有父類的全部特徵）

介面   --->指定標準（子類需要全部執行這些標準）

JDK1.8開始，可以在介面中定義普通方法：

產生背景：如果一個介面已經產生了至少30萬個子類，突然有一天需要增加介面功能，並且這些方法對於所有的子類實現都是相同的，難道要子類覆寫30萬次？

如此，1.8之後，放寬介面的定義要求，可以定義抽象方法和靜態方法，並且這些方法可以根據子類繼承的原則被所有的介面子類繼承。