一、設計模式概念

1、定義

? Java包含23種設計模式，是一套對代碼設計經驗的總結，被人們反復利用，多人熟知的代碼設計方式，

2、目的：

? 為了提高代碼的可讀性，可擴展性以及代碼的復用性，為了解決在寫代碼程序中遇到的代碼設計問題，

3、設計模式的六大原則

? 3.1 開閉原則：對擴展開發，對修改關閉（盡可能對代碼少修改）

? 3.2 里式替換原則：它是面向物件基本原則之一，任何父類（基類）出現的地方，子類都可以出現，也就是子類可以替換父類的任何功能（體現了父類的可擴展性）

? 3.3 依賴倒轉原則：盡可能面向介面編程，依賴介面而不依賴類

? 3.4 介面隔離原則：一個類如果能實作多個介面，盡可能實作多個，為了降低依賴，降低耦合

? 3.5 最少知道原則：一個物體盡可能少的與其他物體產生相互關聯關系，將物體的功能獨立

? 3.6 合成復用原則：盡量使用合成，聚合的方式，而不使用繼承

4、設計模式的分類：

1、創建型模式（5個）

? 工廠方法模式、抽象工廠模式、單例模式，建造者模式，原型模式

2、結構型模式（7個）

? 配接器模式，裝飾模式，代理模式，外觀模式，橋接模式，享元模式，組合模式

3、行為型模式（11個）

? 策略模式，模板方法模式，觀察者模式，迭代子模式，責任鏈模式，命令模式，狀態模式，訪問者模式，中介模式，解釋器模式，備忘錄模式

5、單例模式

單例模式是創建物件的一種特殊方式，程式從始至終都只創建一個物件叫單例（單實體）

分為兩類

1、懶漢式單例

public class Person {
    // 為了不讓其他類直接訪問該成員  懶漢式單例，在使用時創建物件
    // 1 私有靜態變數
    private static Person person=null;

    //2、將構造器私有化
    private Person (){

    }
    //3 提供一個靜態的方法，并可回傳該類的物件
    public static Person getInstance(){
        if(person==null){ // 第一次訪問
            person = new Person();
        }
        return person;
    }

    public void sayHello(){
        System.out.println("sayHello方法");
    }
}

2、餓漢式單例

public class Student {
    //1、 餓漢式單例模式，  在類加載時創建一個物件
    private static Student student = new Student();

    // 2 構造器私有化
    private Student(){

    }
    // 3 提供回傳類物件的靜態方法
    public static Student getInstance(){
        if(student !=null){
            return student;
        }
         return null;
    }
}

6、工廠方法模式

? 創建物件的程序不再由當前類實體化，而是由工廠類完成，在工廠類中只需要告知物件型別即可，工廠模式中必須依賴介面

1、簡單工廠模式

? 以生產 “電腦 ” 為例，電腦有辦公的功能，可以生產一體機或筆記本

代碼與靜態工廠一樣

? 2、靜態工廠模式

  /**
     * 簡單工廠模式
     * @param type
     * @return
     */
//創建一體機與筆記本的共同介面 Computer
public interface Computer {
    //創建方法work：電腦辦公 
    public void work(); 
}

//創建私人電腦類 PersonComputer 實作介面 Computer 
public class PersonComputer implements  Computer{
    @Override  //重寫 實作介面方法
    public void work() {
        System.out.println("這是筆記本電腦，正在辦公");
    }
}

//創建一體機類 workComputer 實作介面方法
public class WorkComputer implements  Computer{

    @Override   //重寫 實作介面方法
    public void work() {
        System.out.println("這是一體機正在辦公");
    }
}

//創建工廠類 CompuerFactory
public class ComputerFactory {

    /**
     * 根據不同的型別 生產不同的產品
     * @param type
     * @return
     */
    public Computer produce(String type){
        Computer computer =null;   //定義一個空物件
        if(type.equals("personComputer")){  //判要斷實作的物件
            computer = new PersonComputer();   //實作物件的賦值，獲取要實作的物件
        }else if(type.equals("workComputer")){
            computer = new WorkComputer();
        }else{
            System.out.println("不能生產");
        }
        return computer;  //回傳獲得的物件
    }
    
     /**
     *  靜態工廠方法
     * @param type
     * @return
     */
    public static Computer produce(String type){
        // 定義一個介面的參考    通過介面new 一個實作類的物件
        // 提高擴展性
        Computer computer=null;
         if(type.equals("workComputer")){
             computer = new WorkComputer();
         }else if(type.equals("personComputer")){
             computer = new PersonComputer();
         }else{
             System.out.println("不能創建物件");
         }
         return computer;
    }
}

//測驗實作 簡單工廠模式與靜態工廠方法
public class Test1 {
 public static void main(String[] args) {
         // 通過工廠類創建物件
        ComputerFactory factory = new ComputerFactory();//通過工廠創建物件
        // 要物件 找工廠  （簡單工廠模式）
        Computer computer1 = factory.produce("workComputer"); //通過工廠方法獲取要呼叫的物件
        computer1.work();  //由回傳獲得的物件呼叫它的方法  
        // 創建筆記本
        Computer computer2 = factory.produce("personComputer");
        computer2.work();
     
        //靜態的方法呼叫，不需要通過工廠new物件來呼叫方法，可直接呼叫工廠方法獲取要實作的物件 （靜態工廠模式）
        Computer computer3 = ComputerFactory2.produce("workComputer");
        computer3.work();
 }
}

? 3、工廠方法模式

//創建BMWCar類與AudiCar類共同介面Car
public interface Car {
    public void  showInfo();
}
//創建AudiCar類
public class AudiCar implements Car {
    @Override
    public void showInfo() {
        System.out.println("這是一臺奧迪汽車，，");
    }
}
//創建BMWCar類
public class BMWCar implements Car {
    @Override
    public void showInfo() {
        System.out.println("這是一臺寶馬汽車，");
    }
}
/**
生產汽車的工廠介面 CarFactory
**/
public interface CarFactory {
    public Car produce();
}

//創建工廠介面的實作類AudiCarFactory
public class AudiCarFactory implements  CarFactory {
    @Override
    public Car produce() {
        return  new AudiCar();// 這里AudiCar是Car的實作類（要呼叫方法需要的物件）；回傳要呼叫的物件
    }
}
//創建工廠介面的實作類BMWCarFactory
public class BMWCarFactory implements CarFactory {
    @Override
    public Car produce() {
        return new BMWCar();// 因為BWMCar是Car的實作類
    }
}
//測驗
 public class Test1 {
        public static void main(String[] args) {
            //先創建 汽車工廠 物件 
            CarFactory bmwFactory = new BMWCarFactory();
            // 通過工廠物件呼叫方法produce()來獲取要呼叫的物件（回傳值）
            Car bmw = bmwFactory.produce();  
            bmw.showInfo();    //通過獲取的物件呼叫它的方法
    
            //這個模式對于同一級別的產品，可擴展性高
            //可以擴展不同品牌的汽車，此時不需要修改代碼，只需要增加代碼即可
            // 創建一個新的品牌汽車  大眾汽車
    
            CarFactory dazhongFactory = new DazhongCarFactory();
            Car car = dazhongFactory.produce();
            car.showInfo();
        }
    }

7、抽象工廠模式

? 對于在工廠方法的基礎上，對同一個品牌的產品有不同的分類，并對分類產品創建的程序，一個汽車產品會分為不同的種類（迷你汽車， SUV汽車）

/**
 * 迷你汽車介面
 */
public interface MiniCar {
    public void showInfo();
}
//SUV汽車介面
public interface SUVCar {
    public void showInfo();

}
//迷你介面實作類（奧迪汽車：AudiMiniCar）
public class AudiMiniCar implements  MiniCar {
    @Override
    public void showInfo() {
        System.out.println("這是奧迪迷你汽車 ");
    }
}
//迷你介面實作類（寶馬汽車：BMWMiniCar）
public class BMWMiniCar implements  MiniCar {
    @Override
    public void showInfo() {
        System.out.println("這是寶馬Cooper迷你汽車");
    }
}
//SUV汽車介面實作類（奧迪汽車：AudiMiniCar）
public class AudiSUVCar implements  SUVCar {
    @Override
    public void showInfo() {
        System.out.println("這是一輛 奧迪SUV汽車");
    }
}
//SUV汽車介面實作類（寶馬汽車：BMWMiniCar）
public class BMWSUVCar implements  SUVCar {
    @Override
    public void showInfo() {
        System.out.println("這寶馬的SUV系列");
    }
}

//工廠介面
public interface CarFactory {
    //生成不同型號的汽車 ，兩條產品線
    public MiniCar produceMiniCar();

    public SUVCar produceSUVCar();
}
//工廠介面的實作類（奧迪汽車：AudiCarFactoryr）
public class AudiCarFactory implements  CarFactory {
    @Override
    public MiniCar produceMiniCar() {  //迷你型汽車方法
        return new AudiMiniCar();  //回傳物件AudiMiniCar()
    }

    @Override
    public SUVCar produceSUVCar() {  //SUV型汽車方法
        return new AudiSUVCar(); //回傳物件AudiMiniCar()
    }
}
//工廠介面的實作類（寶馬汽車：BMWCarFactory）
public class BMWCarFactory implements  CarFactory {
    // 生成迷你汽車的方法，回傳MiniCar
    @Override
    public MiniCar produceMiniCar() {//迷你型汽車方法
        return new BMWMiniCar(); //回傳物件BMWMiniCar()
    }
    //生成SUV汽車的方法， 回傳SUVCar
    @Override
    public SUVCar produceSUVCar() {//SUV型汽車方法
        return new BMWSUVCar(); //回傳物件BMWMiniCar()
    }
}
//測驗：
public class Test1 {
    public static void main(String[] args) {
        //創建寶馬迷你汽車  找工廠（創建工廠物件）
        CarFactory factory = new BMWCarFactory(); 
        MiniCar car = factory.produceMiniCar(); //通過工廠物件呼叫方法獲取目標物件
        car.showInfo(); //通過獲取的物件呼叫方法
    }
}

總結：對于簡單工廠，工廠方法模式和抽象工廠的區別和用途

1、對于簡單工廠（靜態和非靜態），用于生產同一結構中的任意產品，對于新增產品不適用，

2、對于工廠方法，在簡單工廠的基礎上，生產同一個等級結構中的固定產品，可以支持新增產品，

3、抽象工廠：用于生產不同種類（品牌）的相同型別（迷你，SUV），對于新增品牌可以，不支持新增型別，

8、模板方法

? 定義：

? 模板方法是一種行為模式，父類的一個方法定義完成這個方法的步驟，但不具體實作具體細節，由子類完成各個步驟的實作，在創建子類物件時，最終的實作程序是子類的方法，

? 模板方法的準備：

? 1、繼承關系

? 2、父類是抽象類：抽象類實作了模板方法，定義了演算法的估計

3、子類繼承抽象類：實作抽象方法，完成完整的演算法

public abstract class AbstractPerson {
    /**
     *  定義一個模板方法，用于實作這個方法的基本“骨架”
     *  每一步驟的具體實作由子類完成
     */
    public void preparedSchool(){   
        getUp();
        dressing();
        eat();
    }
    //起床
    public abstract void getUp();
    //穿衣服
    public abstract void dressing();
    //吃早餐
    public abstract void eat();

}

public class Teacher extends  AbstractPerson {
    @Override
    public void getUp() {
        System.out.println("老師起床，7點半起床");
    }

    @Override
    public void dressing() {
        System.out.println("老師要衣服得體，穿工裝");
    }

    @Override
    public void eat() {
        System.out.println("老師吃早餐，");
    }
}

public class Test1 {
    public static void main(String[] args) {
          Student stu = new Student();//創建學生類物件
          stu.preparedSchool();

          Teacher teacher = new Teacher(); //創建老師類物件
          teacher.preparedSchool();

    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/174094.html

標籤：設計模式

上一篇：【Java設計模式】單例模式

下一篇：【C++設計模式一】C++簡單工廠模式

JAVA筆記整理-Java設計模式