JAVA筆記整理-Java設計模式
阿新 • • 發佈：2020-10-13
一、設計模式概念
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();
}
}