一.java的設計模式大體上分為三大類： 建立型模式（5種）：工廠方法模式，抽象工廠模式，單例模式，建造者模式，原型模式。 結構型模式（7種）：介面卡模式，裝飾器模式，代理模式，外觀模式，橋接模式，組合模式，享元模式。 行為型模式（11種）：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。 二.常用設計模式：

1. 工廠模式（Factory Method） 　　常用的工廠模式是靜態工廠，利用static方法，作為一種類似於常見的工具類Utils等輔助效果，一般情況下工廠類不需要例項化。

   在這裡插入程式碼片
   interface food{}
   class A implements food{}
   class B implements food{}
   class C implements food{}
   public class StaticFactory {
       private StaticFactory(){}
       public static food getA(){  return new A(); }
       public static food getB(){  return new B(); }
       public static food getC(){  return new C(); }
   }
   class Client{
       //客戶端程式碼只需要將相應的引數傳入即可得到物件
       //使用者不需要了解工廠類內部的邏輯。
       public void get(String name){
           food x = null ;
           if ( name.equals("A")) {
               x = StaticFactory.getA();
           }else if ( name.equals("B")){
               x = StaticFactory.getB();
           }else {
               x = StaticFactory.getC();
           }
       }
   }
    
   

2. 抽象工廠模式（Abstract Factory） 一個基礎介面定義了功能，每個實現介面的子類就是產品，然後定義一個工廠介面，實現了工廠介面的就是工廠，這時候，介面程式設計的優點就出現了，我們可以新增產品類（只需要實現產品介面），只需要同時新增一個工廠類，客戶端就可以輕鬆呼叫新產品的程式碼。 抽象工廠的靈活性就體現在這裡，無需改動原有的程式碼，畢竟對於客戶端來說，靜態工廠模式在不改動StaticFactory類的程式碼時無法新增產品，如果採用了抽象工廠模式，就可以輕鬆的新增拓展類。

   interface food{}
   class A implements food{}
   class B implements food{}
   interface produce{ food get();}
   class FactoryForA implements produce{
       @Override
       public food get() {
           return new A();
       }
   }
   class FactoryForB implements produce{
       @Override
       public food get() {
           return new B();
       }
   }
   public class AbstractFactory {
       public void ClientCode(String name){
           food x= new FactoryForA().get();
           x = new FactoryForB().get();
       }
   }
    
   

   3. 單例模式（Singleton） 　　在內部建立一個例項，構造器全部設定為private，所有方法均在該例項上改動，在建立上要注意類的例項化只能執行一次，可以採用許多種方法來實現，如Synchronized關鍵字，或者利用內部類等機制來實現。

public class Singleton {
    private Singleton(){}
    private static class SingletonBuild{
        private static Singleton value = new Singleton();
    }
    public Singleton getInstance(){  return  SingletonBuild.value ;}
    
}
 

4.代理模式（Proxy） 客戶端通過代理類訪問，代理類實現具體的實現細節，客戶只需要使用代理類即可實現操作。 這種模式可以對舊功能進行代理，用一個代理類呼叫原有的方法，且對產生的結果進行控制。

interface Source{ void method();}
class OldClass implements Source{
    @Override
    public void method() {
    }
}
class Proxy implements Source{
    private Source source = new OldClass();
    void doSomething(){}
    @Override
    public void method() {
        new Class1().Func1();
        source.method();
        new Class2().Func2();
        doSomething();
    }
}

5.介面卡模式（Adapter） 介面卡模式的作用就是在原來的類上提供新功能。主要可分為3種： 類適配：建立新類，繼承源類，並實現新介面，例如

class  adapter extends oldClass  implements newFunc{}

物件適配：建立新類持源類的例項，並實現新介面，例如

class adapter implements newFunc { private oldClass oldInstance ;}

介面適配：建立新的抽象類實現舊介面方法。例如

abstract class adapter implements oldClassFunc { void newFunc();}

6.建造者模式（Builder） 　　在瞭解之前，先假設有一個問題，我們需要建立一個學生物件，屬性有name,number,class,sex,age,school等屬性，如果每一個屬性都可以為空，也就是說我們可以只用一個name,也可以用一個school,name,或者一個class,number，或者其他任意的賦值來建立一個學生物件，這時該怎麼構造？

難道我們寫6個1個輸入的建構函式，15個2個輸入的建構函式…嗎？這個時候就需要用到Builder模式了。給個例子，大家肯定一看就懂：

public class Builder {

    static class Student{
        String name = null ;
        int number = -1 ;
        String sex = null ;
        int age = -1 ;
        String school = null ;

　　　　　//構建器，利用構建器作為引數來構建Student物件
        static class StudentBuilder{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
            public StudentBuilder setName(String name) {
                this.name = name;
                return  this ;
            }

            public StudentBuilder setNumber(int number) {
                this.number = number;
                return  this ;
            }

            public StudentBuilder setSex(String sex) {
                this.sex = sex;
                return  this ;
            }

            public StudentBuilder setAge(int age) {
                this.age = age;
                return  this ;
            }

            public StudentBuilder setSchool(String school) {
                this.school = school;
                return  this ;
            }
            public Student build() {
                return new Student(this);
            }
        }

        public Student(StudentBuilder builder){
            this.age = builder.age;
            this.name = builder.name;
            this.number = builder.number;
            this.school = builder.school ;
            this.sex = builder.sex ;
        }
    }

    public static void main( String[] args ){
        Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
        Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
    }
}