Java設(shè)計模式面試題（1~9題）

1、你所知道的設(shè)計模式有哪些

Java中一般認為有 23 種設(shè)計模式，我們不需要所有的都會，但是其中常用的幾種設(shè)計模式應(yīng)該去掌握。下面列出了所有的設(shè)計模式。需要掌握的設(shè)計模式已經(jīng)單獨列出來了，當然能掌握的越多越好。

● 總體來說設(shè)計模式分為三大類：

創(chuàng)建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

結(jié)構(gòu)型模式，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態(tài)模式、訪問者模式、中介者模式、解釋器模式。

2、單例設(shè)計模式？

最好理解的一種設(shè)計模式，分為懶漢式和餓漢式。

餓漢式：

public class Singleton {
   
    // 直接創(chuàng)建對象
    public static Singleton instance = new Singleton();
   
    // 私有化構(gòu)造函數(shù)
    private Singleton() {
    }

    // 返回對象實例
    public static Singleton getInstance() {
        return instance;
  
  }

懶漢式：

public class Singleton {
    // 聲明變量
    private static volatile Singleton singleton = null;
    // 私有構(gòu)造函數(shù)
    private Singleton() {
    }
    // 提供對外方法
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

3、工廠設(shè)計模式？

工廠模式分為工廠方法模式和抽象工廠模式。

工廠方法模式分為三種：

● 普通工廠模式，就是建立一個工廠類，對實現(xiàn)了同一接口的一些類進行實例的創(chuàng)建。多個工廠方法模式，是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字符串出錯，則不能正確創(chuàng)建對象。

● 多個工廠方法模式，是提供多個工廠方法，分別創(chuàng)建對象。

● 靜態(tài)工廠方法模式，將上面的多個工廠方法模式里的方法置為靜態(tài)的，不需要創(chuàng)建實例，直接調(diào)用即可。

● 普通工廠模式

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mail sender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}
public class SendFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmsSender();
        } else {
            System.out.println("請輸入正確的類型!");
            return null;
        }
    }
}

● 多個工廠方法模式

該模式是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字符串出錯，則不能正確創(chuàng)建對象，而多個工廠方法模式是提供多個工廠方法，分別創(chuàng)建對象。

public class SendFactory {
    public Sender produceMail() {
        return new MailSender();
    }
    public Sender produceSms() {
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
        sender.send();
    }
}

● 靜態(tài)工廠方法模式

將上面的多個工廠方法模式里的方法置為靜態(tài)的，不需要創(chuàng)建實例，直接調(diào)用即可。

public class SendFactory {
    public static Sender produceMail() {
        return new MailSender();
    }
    public static Sender produceSms() {
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        Sender sender = SendFactory.produceMail();
        sender.send();
    }
}

● 抽象工廠模式

工廠方法模式有一個問題就是，類的創(chuàng)建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進行修改，這違背了閉包原則，所以，從設(shè)計角度考慮，有一定的問題，如何解決？就用到抽象工廠模式，創(chuàng)建多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。

public interface Provider {
    public Sender produce();
}
public interface Sender {
    public void send();
}
public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("this is mail sender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("this is sms sender!");
    }
}
public class SendSmsFactory implements Provider {
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}
public class SendMailFactory implements Provider {
    @Override
    public Sender produce() {
        return new MailSender();
    }
}
public class Test {
    public static void main(String[] args) {
        Provider provider = new SendMailFactory();
        Sender sender = provider.produce();
        sender.send();
    }
}

4、建造者模式（Builder）

工廠類模式提供的是創(chuàng)建單個類的模式，而建造者模式則是將各種產(chǎn)品集中起來進行管理，用來創(chuàng)建復(fù)合對象， 所謂復(fù)合對象就是指某個類具有不同的屬性，其實建造者模式就是前面抽象工廠模式和最后的 Test 結(jié)合起來得到的。

public class Builder {
    private List<Sender> list = new ArrayList<Sender>();
    public void produceMailSender(int count) {
        for (int i = 0; i < count; i++) {
            list.add(new MailSender());
        }
    }
    public void produceSmsSender(int count) {
        for (int i = 0; i < count; i++) {
            list.add(new SmsSender());
        }
    }
}
public class Builder {
    private List<Sender> list = new ArrayList<Sender>();
    public void produceMailSender(int count) {
        for (int i = 0; i < count; i++) {
            list.add(new MailSender());
        }
    }
    public void produceSmsSender(int count) {
        for (int i = 0; i < count; i++) {
            list.add(new SmsSender());
        }
    }
}
public class TestBuilder {
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}

5、適配器設(shè)計模式

適配器模式將某個類的接口轉(zhuǎn)換成客戶端期望的另一個接口表示，目的是消除由于接口不匹配所造成的類的兼容性問題。主要分為三類：類的適配器模式、對象的適配器模式、接口的適配器模式。

● 類的適配器模式

public class Source {
    public void method1() {
        System.out.println("this is original method!");
    }
}
public interface Targetable {
    /* 與原類中的方法相同 */
    public void method1();
    /* 新類的方法 */
    public void method2();
}
public class Adapter extends Source implements Targetable {
    @Override
    public void method2() {
        System.out.println("this is the targetable method!");
    }
}
public class AdapterTest {
    public static void main(String[] args) {
        Targetable target = new Adapter();
        target.method1();
        target.method2();
    }
}

● 對象的適配器模式

基本思路和類的適配器模式相同，只是將 Adapter 類作修改，這次不繼承 Source 類，而是持有 Source 類的實例，以達到解決兼容性的問題。

public class Wrapper implements Targetable {
    private Source source;
    public Wrapper(Source source) {
        super();
        this.source = source;
    }
    @Override
    public void method2() {
        System.out.println("this is the targetable method!");
    }
    @Override
    public void method1() {
        source.method1();
    }
}
public class AdapterTest {
    public static void main(String[] args) {
        Source source = new Source();
        Targetable target = new Wrapper(source);
        target.method1();
        target.method2();
    }
}

● 接口的適配器模式

接口的適配器是這樣的：有時我們寫的一個接口中有多個抽象方法，當我們寫該接口的實現(xiàn)類時，必須實現(xiàn)該接口的所有方法，這明顯有時比較浪費，因為并不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了接口的適配器模式，借助于一個抽象類，該抽象類實現(xiàn)了該接口，實現(xiàn)了所有的方法，而我們不和原始的接口打交道，只和該抽象類取得聯(lián)系，所以我們寫一個類，繼承該抽象類，重寫我們需要的方法就行。

6、裝飾模式（Decorator）

顧名思義，裝飾模式就是給一個對象增加一些新的功能，而且是動態(tài)的，要求裝飾對象和被裝飾對象實現(xiàn)同一個接口，裝飾對象持有被裝飾對象的實例。

public interface Sourceable {
    public void method();
}
public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
public class Decorator implements Sourceable {
    private Sourceable source;
    public Decorator(Sourceable source) {
        super();
        this.source = source;
    }
    @Override
    public void method() {
        System.out.println("before decorator!");
        source.method();
        System.out.println("after decorator!");
    }
}

public class DecoratorTest {
    public static void main(String[] args) {
        Sourceable source = new Source();
        Sourceable obj = new Decorator(source);
        obj.method();
    }
}

7、策略模式（strategy）

策略模式定義了一系列算法，并將每個算法封裝起來，使他們可以相互替換，且算法的變化不會影響到使用算法的客戶。需要設(shè)計一個接口，為一系列實現(xiàn)類提供統(tǒng)一的方法，多個實現(xiàn)類實現(xiàn)該接口，設(shè)計一個抽象類（可有可無，屬于輔助類），提供輔助函數(shù)。策略模式的決定權(quán)在用戶，系統(tǒng)本身提供不同算法的實現(xiàn)，新增或者刪除算法，對各種算法做封裝。因此，策略模式多用在算法決策系統(tǒng)中，外部用戶只需要決定用哪個算法即可。

public interface ICalculator {
    public int calculate(String exp);
}
public class Minus extends AbstractCalculator implements ICalculator {
    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp， "-");
        return arrayInt[0] - arrayInt[1];
    }
}
public class Plus extends AbstractCalculator implements ICalculator {
    @Override
    public int calculate(String exp) {
        int arrayInt[] = split(exp， "\\+");
        return arrayInt[0] + arrayInt[1];
    }
}
public class AbstractCalculator {
    public int[] split(String exp， String opt) {
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}
public class StrategyTest {
    public static void main(String[] args) {
        String exp = "2+8";
        ICalculator cal = new Plus();
        int result = cal.calculate(exp);
        System.out.println(result);
    }
}

8、觀察者模式（Observer）

觀察者模式很好理解，類似于郵件訂閱和RSS訂閱，當我們?yōu)g覽一些博客或wiki時，經(jīng)常會看到RSS圖標，就這的意思是，當你訂閱了該文章，如果后續(xù)有更新，會及時通知你。其實，簡單來講就一句話：當一個對象變化時，其它依賴該對象的對象都會收到通知，并且隨著變化！對象之間是一種一對多的關(guān)系。

public interface Observer {
    public void update();
}
public class Observer1 implements Observer {
    @Override
    public void update() {
        System.out.println("observer1 has received!");
    }
}
public class Observer2 implements Observer {
    @Override
    public void update() {
        System.out.println("observer2 has received!");
    }
}
public interface Subject {
    /*增加觀察者*/
    public void add(Observer observer);
    /*刪除觀察者*/
    public void del(Observer observer);
    /*通知所有的觀察者*/
    public void notifyObservers();
    /*自身的操作*/
    public void operation();
}
public abstract class AbstractSubject implements Subject {
    private Vector<Observer> vector = new Vector<Observer>();
    @Override
    public void add(Observer observer) {
        vector.add(observer);
    }
    @Override
    public void del(Observer observer) {
        vector.remove(observer);
    }
    @Override
    public void notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }
}
public class MySubject extends AbstractSubject {
    @Override
    public void operation() {
        System.out.println("update self!");
        notifyObservers();
    }
}
public class ObserverTest {
    public static void main(String[] args) {
        Subject sub = new MySubject();
        sub.add(new Observer1());
        sub.add(new Observer2());
        sub.operation();
    }
}

9、JVM 垃圾回收機制和常見算法

理論上來講Sun公司只定義了垃圾回收機制規(guī)則而不局限于其實現(xiàn)算法，因此不同廠商生產(chǎn)的虛擬機采用的算法也不盡相同。

GC（Garbage Collector）在回收對象前首先必須發(fā)現(xiàn)那些無用的對象，如何去發(fā)現(xiàn)定位這些無用的對象？常用的搜索算法如下：

● 引用計數(shù)器算法（廢棄）

引用計數(shù)器算法是給每個對象設(shè)置一個計數(shù)器，當有地方引用這個對象的時候，計數(shù)器+1，當引用失效的時候，計數(shù)器-1，當計數(shù)器為0的時候，JVM就認為對象不再被使用，是“垃圾”了。引用計數(shù)器實現(xiàn)簡單，效率高；但是不能解決循環(huán)引用問問題（A對象引用B對象，B對象又引用A對象，但是A，B對象已不被任何其他對象引用），同時每次計數(shù)器的增加和減少都帶來了很多額外的開銷，所以在JDK1.1之后，這個算法已經(jīng)不再使用了。

● 根搜索算法（使用）

根搜索算法是通過一些“GC Roots”對象作為起點，從這些節(jié)點開始往下搜索，搜索通過的路徑成為引用鏈（Reference Chain），當一個對象沒有被GC Roots的引用鏈連接的時候，說明這個對象是不可用的。

● GC Roots對象包括：

虛擬機棧（棧幀中的本地變量表）中的引用的對象。

方法區(qū)域中的類靜態(tài)屬性引用的對象。

方法區(qū)域中常量引用的對象。

本地方法棧中JNI（Native方法）的引用的對象。

通過上面的算法搜索到無用對象之后，就是回收過程，回收算法如下：

標記—清除算法（Mark-Sweep）（DVM使用的算法）

標記—清除算法包括兩個階段：“標記”和“清除”。在標記階段，確定所有要回收的對象，并做標記。清除階段緊隨標記階段，將標記階段確定不可用的對象清除。標記—清除算法是基礎(chǔ)的收集算法，標記和清除階段的效率不高，而且清除后回產(chǎn)生大量的不連續(xù)空間，這樣當程序需要分配大內(nèi)存對象時，可能無法找到足夠的連續(xù)空間。

● 復(fù)制算法（Copying）

復(fù)制算法是把內(nèi)存分成大小相等的兩塊，每次使用其中一塊，當垃圾回收的時候，把存活的對象復(fù)制到另一塊上，然后把這塊內(nèi)存整個清理掉。復(fù)制算法實現(xiàn)簡單，運行效率高，但是由于每次只能使用其中的一半，造成內(nèi)存的利用率不高。現(xiàn)在的JVM用復(fù)制方法收集新生代，由于新生代中大部分對象（98%）都是朝生夕死的，所以兩塊內(nèi)存的比例不是1:1(大概是8:1)

● 標記—整理算法（Mark-Compact）

標記—整理算法和標記—清除算法一樣，但是標記—整理算法不是把存活對象復(fù)制到另一塊內(nèi)存，而是把存活對象往內(nèi)存的一端移動，然后直接回收邊界以外的內(nèi)存。標記—整理算法提高了內(nèi)存的利用率，并且它適合在收集對象存活時間較長的老年代。

● 分代收集（Generational Collection）

分代收集是根據(jù)對象的存活時間把內(nèi)存分為新生代和老年代，根據(jù)各個代對象的存活特點，每個代采用不同的垃圾回收算法。新生代采用復(fù)制算法，老年代采用標記—整理算法。垃圾算法的實現(xiàn)涉及大量的程序細節(jié)，而且不同的虛擬機平臺實現(xiàn)的方法也各不相同。