單例模式
簡單點說,就是一個應用程序中,某個類的實例對象只有一個,你沒有辦法去new,因爲構造器是被private修飾的,一般通過getInstance()的方法來獲取它們的實例。
getInstance()的返回值是一個對象的引用,並不是一個新的實例,所以不要錯誤的理解成多個對象。單例模式實現起來也很容易,直接看demo吧
public class Singleton {
private static Singleton singleton;
private Singleton() {
}
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
按照我的習慣,我恨不得寫滿註釋,怕你們看不懂,但是這個代碼實在太簡單了,所以我沒寫任何註釋,如果這幾行代碼你都看不明白的話,那你可以洗洗睡了,等你睡醒了再來看我的博客說不定能看懂。
上面的是最基本的寫法,也叫懶漢寫法(線程不安全)下面我再公佈幾種單例模式的寫法:
懶漢式寫法(線程安全)
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
餓漢式寫法
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
靜態內部類
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
枚舉
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
這種方式是Effective Java作者Josh Bloch 提倡的方式,它不僅能避免多線程同步問題,而且還能防止反序列化重新創建新的對象,可謂是很堅強的壁壘啊,不過,個人認爲由於1.5中才加入enum特性,用這種方式寫不免讓人感覺生疏。
雙重校驗鎖
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
總結:我個人比較喜歡靜態內部類寫法和餓漢式寫法,其實這兩種寫法能夠應付絕大多數情況了。其他寫法也可以選擇,主要還是看業務需求吧。
觀察者模式
對象間一對多的依賴關係,當一個對象的狀態發生改變時,所有依賴於它的對象都得到通知並被自動更新。
觀察者模式UML圖
看不懂圖的人端着小板凳到這裏來,給你舉個栗子:假設有三個人,小美(女,22),小王和小李。小美很漂亮,小王和小李是兩個程序猿,時刻關注着小美的一舉一動。有一天,小美說了一句:“誰來陪我打遊戲啊。”這句話被小王和小李聽到了,結果樂壞了,蹭蹭蹭,沒一會兒,小王就衝到小美家門口了,在這裏,小美是被觀察者,小王和小李是觀察者,被觀察者發出一條信息,然後觀察者們進行相應的處理,看代碼:
public interface Person {
//小王和小李通過這個接口可以接收到小美髮過來的消息
void getMessage(String s);
}
l
這個接口相當於小王和小李的電話號碼,小美髮送通知的時候就會撥打getMessage這個電話,撥打電話就是調用接口,看不懂沒關係,先往下看
public class LaoWang implements Person {
private String name = "小王";
public LaoWang() {
}
@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打過來的電話,電話內容是:" + s);
}
}
public class LaoLi implements Person {
private String name = "小李";
public LaoLi() {
}
@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打過來的電話,電話內容是:->" + s);
}
}
代碼很簡單,我們再看看小美的代碼:
public class XiaoMei {
List<Person> list = new ArrayList<Person>();
public XiaoMei(){
}
public void addPerson(Person person){
list.add(person);
}
//遍歷list,把自己的通知發送給所有暗戀自己的人
public void notifyPerson() {
for(Person person:list){
person.getMessage("你們過來吧,誰先過來誰就能陪我一起玩兒遊戲!");
}
}
}
我們寫一個測試類來看一下結果對不對
public class Test {
public static void main(String[] args) {
XiaoMei xiao_mei = new XiaoMei();
LaoWang lao_wang = new LaoWang();
LaoLi lao_li = new LaoLi();
//小王和小李在小美那裏都註冊了一下
xiao_mei.addPerson(lao_wang);
xiao_mei.addPerson(lao_li);
//小美向小王和小李發送通知
xiao_mei.notifyPerson();
}
}
完美~
裝飾者模式
對已有的業務邏輯進一步的封裝,使其增加額外的功能,如Java中的IO流就使用了裝飾者模式,用戶在使用的時候,可以任意組裝,達到自己想要的效果。 舉個栗子,我想喫三明治,首先我需要一根大大的香腸,我喜歡喫奶油,在香腸上面加一點奶油,再放一點蔬菜,最後再用兩片面包夾一下,很豐盛的一頓午飯,營養又健康。(ps:不知道上海哪裏有賣好喫的三明治的,求推薦~)那我們應該怎麼來寫代碼呢? 首先,我們需要寫一個Food類,讓其他所有食物都來繼承這個類,看代碼:
public class Food {
private String food_name;
public Food() {
}
public Food(String food_name) {
this.food_name = food_name;
}
public String make() {
return food_name;
};
}
代碼很簡單,我就不解釋了,然後我們寫幾個子類繼承它:
//麪包類
public class Bread extends Food {
private Food basic_food;
public Bread(Food basic_food) {
this.basic_food = basic_food;
}
public String make() {
return basic_food.make()+"+麪包";
}
}
//奶油類
public class Cream extends Food {
private Food basic_food;
public Cream(Food basic_food) {
this.basic_food = basic_food;
}
public String make() {
return basic_food.make()+"+奶油";
}
}
//蔬菜類
public class Vegetable extends Food {
private Food basic_food;
public Vegetable(Food basic_food) {
this.basic_food = basic_food;
}
public String make() {
return basic_food.make()+"+蔬菜";
}
}
這幾個類都是差不多的,構造方法傳入一個Food類型的參數,然後在make方法中加入一些自己的邏輯,如果你還是看不懂爲什麼這麼寫,不急,你看看我的Test類是怎麼寫的,一看你就明白了
public class Test {
public static void main(String[] args) {
Food food = new Bread(new Vegetable(new Cream(new Food("香腸"))));
System.out.println(food.make());
}
}
看到沒有,一層一層封裝,我們從裏往外看:最裏面我new了一個香腸,在香腸的外面我包裹了一層奶油,在奶油的外面我又加了一層蔬菜,最外面我放的是麪包,是不是很形象,哈哈~ 這個設計模式簡直跟現實生活中一摸一樣,看懂了嗎? 我們看看運行結果吧
運行結果
一個三明治就做好了~
適配器模式
將兩種完全不同的事物聯繫到一起,就像現實生活中的變壓器。假設一個手機充電器需要的電壓是20V,但是正常的電壓是220V,這時候就需要一個變壓器,將220V的電壓轉換成20V的電壓,這樣,變壓器就將20V的電壓和手機聯繫起來了。
public class Test {
public static void main(String[] args) {
Phone phone = new Phone();
VoltageAdapter adapter = new VoltageAdapter();
phone.setAdapter(adapter);
phone.charge();
}
}
// 手機類
class Phone {
public static final int V = 220;// 正常電壓220v,是一個常量
private VoltageAdapter adapter;
// 充電
public void charge() {
adapter.changeVoltage();
}
public void setAdapter(VoltageAdapter adapter) {
this.adapter = adapter;
}
}
// 變壓器
class VoltageAdapter {
// 改變電壓的功能
public void changeVoltage() {
System.out.println("正在充電...");
System.out.println("原始電壓:" + Phone.V + "V");
System.out.println("經過變壓器轉換之後的電壓:" + (Phone.V - 200) + "V");
}
}
工廠模式
簡單工廠模式:一個抽象的接口,多個抽象接口的實現類,一個工廠類,用來實例化抽象的接口
// 抽象產品類
abstract class Car {
public void run();
public void stop();
}
// 具體實現類
class Benz implements Car {
public void run() {
System.out.println("Benz開始啓動了。。。。。");
}
public void stop() {
System.out.println("Benz停車了。。。。。");
}
}
class Ford implements Car {
public void run() {
System.out.println("Ford開始啓動了。。。");
}
public void stop() {
System.out.println("Ford停車了。。。。");
}
}
// 工廠類
class Factory {
public static Car getCarInstance(String type) {
Car c = null;
if ("Benz".equals(type)) {
c = new Benz();
}
if ("Ford".equals(type)) {
c = new Ford();
}
return c;
}
}
public class Test {
public static void main(String[] args) {
Car c = Factory.getCarInstance("Benz");
if (c != null) {
c.run();
c.stop();
} else {
System.out.println("造不了這種汽車。。。");
}
}
}
工廠方法模式:有四個角色,抽象工廠模式,具體工廠模式,抽象產品模式,具體產品模式。不再是由一個工廠類去實例化具體的產品,而是由抽象工廠的子類去實例化產品
// 抽象產品角色
public interface Moveable {
void run();
}
// 具體產品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}
// 抽象工廠
public abstract class VehicleFactory {
abstract Moveable create();
}
// 具體工廠
public class PlaneFactory extends VehicleFactory {
public Moveable create() {
return new Plane();
}
}
public class BroomFactory extends VehicleFactory {
public Moveable create() {
return new Broom();
}
}
// 測試類
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BroomFactory();
Moveable m = factory.create();
m.run();
}
}
抽象工廠模式:與工廠方法模式不同的是,工廠方法模式中的工廠只生產單一的產品,而抽象工廠模式中的工廠生產多個產品
/抽象工廠類
public abstract class AbstractFactory {
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();
}
//具體工廠類,其中Food,Vehicle,Weapon是抽象類,
public class DefaultFactory extends AbstractFactory{
@Override
public Food createFood() {
return new Apple();
}
@Override
public Vehicle createVehicle() {
return new Car();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
//測試類
public class Test {
public static void main(String[] args) {
AbstractFactory f = new DefaultFactory();
Vehicle v = f.createVehicle();
v.run();
Weapon w = f.createWeapon();
w.shoot();
Food a = f.createFood();
a.printName();
}
}
代理模式(proxy)
有兩種,靜態代理和動態代理。先說靜態代理,很多理論性的東西我不講,我就算講了,你們也看不懂。什麼真實角色,抽象角色,代理角色,委託角色。。。亂七八糟的,我是看不懂。之前學代理模式的時候,去網上翻一下,資料一大堆,打開鏈接一看,基本上都是給你分析有什麼什麼角色,理論一大堆,看起來很費勁,不信的話你們可以去看看,我是看不懂他們在說什麼。咱不來虛的,直接用生活中的例子說話。(注意:我這裏並不是否定理論知識,我只是覺得有時候理論知識晦澀難懂,喜歡挑刺的人一邊去,你是來學習知識的,不是來挑刺的)
到了一定的年齡,我們就要結婚,結婚是一件很麻煩的事情,(包括那些被父母催婚的)。有錢的家庭可能會找司儀來主持婚禮,顯得熱鬧,洋氣~好了,現在婚慶公司的生意來了,我們只需要給錢,婚慶公司就會幫我們安排一整套結婚的流程。整個流程大概是這樣的:家裏人催婚->男女雙方家庭商定結婚的黃道即日->找一家靠譜的婚慶公司->在約定的時間舉行結婚儀式->結婚完畢
婚慶公司打算怎麼安排婚禮的節目,在婚禮完畢以後婚慶公司會做什麼,我們一概不知。。。別擔心,不是黑中介,我們只要把錢給人家,人家會把事情給我們做好。所以,這裏的婚慶公司相當於代理角色,現在明白什麼是代理角色了吧。
代碼實現請看:
//代理接口
public interface ProxyInterface {
//需要代理的是結婚這件事,如果還有其他事情需要代理,比如喫飯睡覺上廁所,也可以寫
void marry();
//代理喫飯(自己的飯,讓別人喫去吧)
//void eat();
//代理拉屎,自己的屎,讓別人拉去吧
//void shit();
}
文明社會,代理喫飯,代理拉屎什麼的我就不寫了,有傷社會風化~~~能明白就好
好了,我們看看婚慶公司的代碼:
public class WeddingCompany implements ProxyInterface {
private ProxyInterface proxyInterface;
public WeddingCompany(ProxyInterface proxyInterface) {
this.proxyInterface = proxyInterface;
}
@Override
public void marry() {
System.out.println("我們是婚慶公司的");
System.out.println("我們在做結婚前的準備工作");
System.out.println("節目彩排...");
System.out.println("禮物購買...");
System.out.println("工作人員分工...");
System.out.println("可以開始結婚了");
proxyInterface.marry();
System.out.println("結婚完畢,我們需要做後續處理,你們可以回家了,其餘的事情我們公司來做");
}
}
看到沒有,婚慶公司需要做的事情很多,我們再看看結婚家庭的代碼:
public class NormalHome implements ProxyInterface{
@Override
public void marry() {
System.out.println("我們結婚啦~");
}
}
這個已經很明顯了,結婚家庭只需要結婚,而婚慶公司要包攬一切,前前後後的事情都是婚慶公司來做,聽說現在婚慶公司很賺錢的,這就是原因,乾的活多,能不賺錢嗎?
來看看測試類代碼:
public class Test {
public static void main(String[] args) {
ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
proxyInterface.marry();
}
}
運行結果如下:
生產者/消費者模式
什麼是生產者/消費者模式?
某個模塊負責產生數據,這些數據由另一個模塊來負責處理(此處的模塊是廣義的,可以是類、函數、線程、進程等)。產生數據的模塊,就形象地稱爲生產者;而處理數據的模塊,就稱爲消費者。在生產者與消費者之間在加個緩衝區,我們形象的稱之爲倉庫,生產者負責往倉庫了進商品,而消費者負責從倉庫裏拿商品,這就構成了生產者消費者模式。結構圖如下:
生產者消費者模式有如下幾個優點:
1、解耦
由於有緩衝區的存在,生產者和消費者之間不直接依賴,耦合度降低。
2、支持併發
由於生產者與消費者是兩個獨立的併發體,他們之間是用緩衝區作爲橋樑連接,生產者只需要往緩衝區裏丟數據,就可以繼續生產下一個數據,而消費者只需要從緩衝區了拿數據即可,這樣就不會因爲彼此的處理速度而發生阻塞。
3、支持忙閒不均
緩衝區還有另一個好處。如果製造數據的速度時快時慢,緩衝區的好處就體現出來 了。當數據製造快的時候,消費者來不及處理,未處理的數據可以暫時存在緩衝區中。 等生產者的製造速度慢下來,消費者再慢慢處理掉。
生產者-消費者模型準確說應該是“生產者-倉儲-消費者”模型,這樣的模型遵循如下的規則:
1、生產者僅僅在倉儲未滿時候生產,倉滿則停止生產。
2、消費者僅僅在倉儲有產品時候才能消費,倉空則等待。
3、當消費者發現倉儲沒產品可消費時候會通知生產者生產。
4、生產者在生產出可消費產品時候,應該通知等待的消費者去消費
此模型將要結合java.lang.Object的wait與notify、notifyAll方法來實現以上的需求。實例代碼如下:
創建所謂的“倉庫”,此類是(本質上:共同訪問的)共享數據區域
//此類是(本質上:共同訪問的)共享數據區域
public class SyncStack {
private String[] str = new String[10];
private int index;
//供生產者調用
public synchronized void push(String sst){
if(index == sst.length()){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.notify();//喚醒在此對象監視器上等待的單個線程
str[index] = sst;
index++;
}
//供消費者調用
public synchronized String pop(){
if(index == 0){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.notify();
index--;
String product = str[index];
return product;
}
//就是定義一個返回值爲數組的方法,返回的是一個String[]引用
public String[] pro(){
return str;
}
}
創建生產者:
public class Producter implements Runnable {
private SyncStack stack;
public Producter(SyncStack stack){
this.stack = stack;
}
public void run(){
for(int i = 0;i<stack.pro().length;i++){
String producter = "產品" + i;
stack.push(producter);
System.out.println("生產了:" + producter);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
創建消費者:
public class Consumer implements Runnable {
private SyncStack stack;
public Consumer(SyncStack stack){
this.stack = stack;
}
public void run(){
for(int i=0;i<stack.pro().length;i++){
String consumer = stack.pop();
System.out.println("消費了:" + consumer );
try {
Thread.sleep(400);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
測試類:
public class TestDeam {
public static void main(String[] args) {
SyncStack stack = new SyncStack();
Consumer p = new Consumer(stack);
Producter c = new Producter(stack);
new Thread(p).start();
new Thread(c).start();
}
}
測試結果:
生產了:產品0
消費了:產品0
生產了:產品1
生產了:產品2
消費了:產品2
生產了:產品3
消費了:產品3
生產了:產品4
生產了:產品5
生產了:產品6
消費了:產品5
生產了:產品7
消費了:產品6
消費了:產品7
生產了:產品8
生產了:產品9
消費了:產品8
消費了:產品9
消費了:產品4
消費了:產品1