面試準備——java設計模式

1 整體來講，設計模式分爲三大類：

設計模式（design pattern）是對軟件設計中廣泛存在（反覆出現）的各類問題，所提出的解決方案。

建立型模式（五種）：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式

結構型模式（七種）：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式

行爲型模式（十一種）：策策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。

 

2 常見的設計模式介紹：

Singleton（單例模式）

一句話總結：一個類在Java虛擬機中只有一個對象，並提供一個全局訪問點。

解決什麼問題：對象的惟一性，性能浪費太多。

項目裏面怎麼用：數據庫鏈接對象，屬性配置文件的讀取對象。

模式結構：分爲餓漢式和懶漢式（若是考慮性能問題的話，就使用懶漢式，由於懶漢式是在方法裏面進行初始化的），構造器私 有化，對外提供方法加同步關鍵字。

餓漢式代碼：

public class HurgrySingleton {
private static HurgrySingleton hurgry=new HurgrySingleton();
private HurgrySingleton(){};
     public static HurgrySingleton getSinletonHurgry(){
         return hurgry;
        }
}

懶漢式代碼：

public class LarzySingleton {
   private static LarzySingleton larzy=null;
   private LarzySingleton(){};
   public static synchronized Larzy getSinletonLarzy(){
        if(larzy==null){
              larzy=new LarzySingleton();
        }
        return larzy;
    }
}

 

 

Factory（簡單的工廠模式）

一句話總結：用一個方法來代替new關鍵字

解決什麼問題：對象產生過多，或者常常有子類替換生成。

項目裏面怎麼用：對於常常生成的對象，或者父子類替換的對象。

模式結構：寫一個對外聲明的方法，方法裏面使用new關鍵字代替。

框架裏面使用：spring的核心就是工廠模式。

 

工廠方法模式：

有四個角色，抽象工廠模式，具體工廠模式，抽象產品模式，具體產品模式。再也不是由一個工廠類去實例化具體的產品，而是由抽象工廠的子類去實例化產品

// 抽象產品角色
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（代理模式）

一句話總結：爲其餘對象提供一個代理，以控制對當前對象的訪問。

解決什麼問題：不能直接訪問該對象，或者太大的資源耗費多。

項目裏面怎麼用：權限，或者大對象的訪問權限。

模式結構：代理類和被代理類實現同一個接口，用戶訪問的時候先訪問代理對象，而後讓代理對象去訪問被代理對象。

框架裏面使用：Spring裏面的AOP實現。

 

代理模式代碼：

建立一個接口：

public interface SellHouse {
    void sell(double money);
}

建立一個被代理類：

public class Hoster implements SellHouse {
        @Override
        public void sell(double money) {
            System.out.println("祝你居住愉快");
        }
    }

建立一個代理類：

public class Medium implements SellHouse {
    SellHouse hoster=new Hoster();
    @Override
    public void sell(double money) {
        if(money>=1000){
            hoster.sell(money);
        }else{
            System.out.println("你的價格過低了");
        }
    }
}

測試類：

public class Renter {
    public static void main(String[] args) {
        SellHouse renter=new Medium();
        renter.sell(500);
    }
}

Strategy（策略模式）

一句話總結：定義一系列算法並能夠互相替換。

生活中的例子：圖片的格式，壓縮文件的格式。

解決什麼問題：作一件事情有不少種方法。

項目裏面怎麼用：購物車裏面的付款方式。

模式結構：聲明一個頂級接口，定義一個策略方法，具體的實例都要實現這個接口。

 

定義一個頂級接口：

public interface Person {
    void repast();
}

具體的實例類1：

public class African implements Person {
    @Override
    public void repast() {
        System.out.println("非洲人用手吃飯");
    }
}

具體的實例類2：

public class America implements Person {
    @Override
    public void repast() {
        System.out.println("美國人用刀叉吃飯");
    }
}

具體的實例類3：

public class Chinese implements Person {
    @Override
    public void repast() {
        System.out.println("中國人用筷子吃飯");
    }
}

測試類：

public class Test {
    public static void main(String[] args) {
        Person chinese=new Chinese();
        Person america=new America();
        Person african=new African();
        chinese.repast();
        america.repast();
        african.repast();
    }
}

 

 

Adapter（適配器模式）

一句話總結：將兩個原來不兼容的類兼容起來一塊兒工做。

解決什麼問題：已經存在的相同功能的代碼，可是接口不兼容，不能直接調用。

項目裏面怎麼用：在使用舊的API的時候，沒有源碼，和新的不能兼容。

模式結構：分爲類適配器和對象適配，通常經常使用的就是對象適配器，由於組合因爲繼承。

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");
    }
}

裝飾者模式 

一句話總結：對已有的業務邏輯進一步的封裝，使其增長額外的功能

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()+"+蔬菜";
    }

}

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());
    }
}