• <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 第一部分 Java基礎
    第二部分 Java進階

    Java設計模式面試題(1~9題)

     

     

    1、你所知道的設計模式有哪些

     

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

     

    ● 總體來說設計模式分為三大類:

     

    創建型模式,共五種:工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

     

    結構型模式,共七種:適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

     

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

     

     

    2、單例設計模式?

     

    最好理解的一種設計模式,分為懶漢式和餓漢式。

     

    餓漢式:

     

    public class Singleton {
       
        // 直接創建對象
        public static Singleton instance = new Singleton();
       
        // 私有化構造函數
        private Singleton() {
        }
    
        // 返回對象實例
        public static Singleton getInstance() {
            return instance;
      
      }

     

    懶漢式:

     

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

     

     

    3、工廠設計模式?

     

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

     

    工廠方法模式分為三種:

     

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

     

    ● 多個工廠方法模式,是提供多個工廠方法,分別創建對象。

     

    ● 靜態工廠方法模式,將上面的多個工廠方法模式里的方法置為靜態的,不需要創建實例,直接調用即可。

     

    ● 普通工廠模式

     

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

     

    ● 多個工廠方法模式

     

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

     

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

     

    ● 靜態工廠方法模式

     

    將上面的多個工廠方法模式里的方法置為靜態的,不需要創建實例,直接調用即可。

     

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

     

    ● 抽象工廠模式

     

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

     

    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)

     

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

     

    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、適配器設計模式

     

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

     

    ● 類的適配器模式

     

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

     

    ● 接口的適配器模式

     

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

     

     

    6、裝飾模式(Decorator)

     

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

     

    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)

     

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

     

    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訂閱,當我們瀏覽一些博客或wiki時,經常會看到RSS圖標,就這的意思是,當你訂閱了該文章,如果后續有更新,會及時通知你。其實,簡單來講就一句話:當一個對象變化時,其它依賴該對象的對象都會收到通知,并且隨著變化!對象之間是一種一對多的關系。

     

    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公司只定義了垃圾回收機制規則而不局限于其實現算法,因此不同廠商生產的虛擬機采用的算法也不盡相同。

     

    GC(Garbage Collector)在回收對象前首先必須發現那些無用的對象,如何去發現定位這些無用的對象?常用的搜索算法如下:

     

    ● 引用計數器算法(廢棄)

     

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

     

    ● 根搜索算法(使用)

     

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

     

     

    ● GC Roots對象包括:

     

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

     

    方法區域中的類靜態屬性引用的對象。

     

    方法區域中常量引用的對象。

     

    本地方法棧中JNI(Native方法)的引用的對象。

     

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

     

    標記—清除算法(Mark-Sweep)(DVM使用的算法)

     

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

     

     

    ● 復制算法(Copying)

     

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

     

     

    ● 標記—整理算法(Mark-Compact)

     

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

     

     

    ● 分代收集(Generational Collection)

     

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

     

    全部教程
  • <nav id="wkkge"><strong id="wkkge"></strong></nav>
  • <menu id="wkkge"></menu>
  • 面对面棋牌游戏