一、設計模式概念
1、定義
Java包含23種設計模式，是一套對代碼設計經驗的總結，被人們反復利用，多人熟知的代碼設計方式。
2、目的
為了提高代碼的可讀性，可擴展性以及代碼的復用性，為了解決在寫代碼過程中遇到的代碼設計問題。
3、設計模式的六大原則
3.1開閉原則
對擴展開放，對修改關閉（盡可能對代碼少修改）
3.2里氏替換原則
它是面向對象基本原則之一，任何父類（基類）出現的地方，子類都可以出現，也就是子類可以替換父類的任何功能（體現了父類的可擴展性）
3.3依賴倒轉原則
盡可能面向接口編程，依賴接口而不依賴類
3.4接口隔離原則
一個類如果能實現多個接口，盡可能實現多個，為了降低依賴，降低耦合
3.5最少知道原則
一個實體盡可能少的與其他實體產生相互關聯關系，將實體的功能獨立
3.6合成復用原則
盡量使用合成，聚合的方式，而不使用繼承
4、設計模式的分類
Java設計模式分為三大類
創建型模式：對象實例化的模式，創建型模式用於解耦對象的實例化過程。
結構型模式：把類或對象結合在一起形成一個更大的結構。
行為型模式：類和對象如何交互，及划分責任和算法。
如下圖所示：
二、常用的幾種設計模式
1、單例模式
單例模式是創建對象的一種特殊方式，程序從始至終都只創建一個對象叫單例（單實例）
分為兩類
1.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方法");
}
}
1.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;
}
}
2、工廠方法模式
創建對象的過程不再由當前類實例化，而是由工廠類完成，在工廠類中只需要告知對象類型即可。工廠模式中必須依賴接口
2.1簡單工廠模式
簡單工廠模式的工廠類一般是使用靜態方法，通過接收的參數的不同來返回不同的對象實例。不修改代碼的話，是無法擴展的。
以生產“電腦”為例，電腦有辦公的功能，可以生產一體機或筆記本
代碼與靜態工廠一樣
2.2靜態工廠模式
//電腦接口
public interface Computer {
//電腦辦公
public void work();
}
//筆記本
public class PersonComputer implements Computer{
@Override
public void work() {
System.out.println("這是筆記本電腦，正在辦公");
}
}
//一體機
public class WorkComputer implements Computer{
@Override
public void work() {
System.out.println("這是一體機正在辦公");
}
}
//用於生產電腦的工廠 （這個工廠既可以生產台式機也可以生產筆記本）
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;
}
//靜態工廠方法模式
public class ComputerFactory2 {
/**
* 靜態工廠方法
* @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();
Computer computer3 = ComputerFactory2.produce("workComputer");
computer3.work();
}
}
3.3工廠方法模式
工廠方法是針對每一種產品提供一個工廠類。通過不同的工廠實例來創建不同的產品實例。在同一等級結構中，支持增加任意產品。
例如：
//汽車接口
public interface Car {
public void showInfo();
}
public class AudiCar implements Car {
@Override
public void showInfo() {
System.out.println("這是一台奧迪汽車。。");
}
}
public class BMWCar implements Car {
@Override
public void showInfo() {
System.out.println("這是一台寶馬汽車。");
}
}
/**
生產汽車的工廠接口
**/
public interface CarFactory {
public Car produce();
}
public class AudiCarFactory implements CarFactory {
@Override
public Car produce() {
return new AudiCar();// 這里AudiCar是Car的實現類
}
}
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();
// 這個工廠生產的汽車就是 寶馬
Car bmw = bmwFactory.produce();
bmw.showInfo();
//這個模式對於同一級別的產品，可擴展性高
//可以擴展不同品牌的汽車，此時不需要修改代碼，只需要增加代碼即可
// 創建一個新的品牌汽車 大眾汽車
CarFactory dazhongFactory = new DazhongCarFactory();
Car car = dazhongFactory.produce();
car.showInfo();
}
}
3、抽象工廠模式
對於在工廠方法的基礎上，對同一個品牌的產品有不同的分類，並對分類產品創建的過程 ，一個汽車產品 會分為不同的種類（迷你汽車 ，SUV汽車 ）
/**
* 迷你汽車接口
*/
public interface MiniCar {
public void showInfo();
}
/**
* SUV汽車接口
*/
public interface SUVCar {
public void showInfo();
}
public class AudiMiniCar implements MiniCar {
@Override
public void showInfo() {
System.out.println("這是奧迪迷你汽車 ");
}
}
public class BMWMiniCar implements MiniCar {
@Override
public void showInfo() {
System.out.println("這是寶馬Cooper迷你汽車");
}
}
public class AudiSUVCar implements SUVCar {
@Override
public void showInfo() {
System.out.println("這是一輛 奧迪SUV汽車");
}
}
public class BMWSUVCar implements SUVCar {
@Override
public void showInfo() {
System.out.println("這寶馬的SUV系列");
}
}
public interface CarFactory {
//生成不同型號的汽車 ，兩條產品線
public MiniCar produceMiniCar();
public SUVCar produceSUVCar();
}
public class AudiCarFactory implements CarFactory {
@Override
public MiniCar produceMiniCar() {
return new AudiMiniCar();
}
@Override
public SUVCar produceSUVCar() {
return new AudiSUVCar();
}
}
public class BMWCarFactory implements CarFactory {
// 生成迷你汽車的方法，返回MiniCar
@Override
public MiniCar produceMiniCar() {
return new BMWMiniCar();
}
//生成SUV汽車的方法， 返回SUVCar
@Override
public SUVCar produceSUVCar() {
return new BMWSUVCar();
}
}
/**
* 測試類
*/
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 Student extends AbstractPerson {
@Override
public void getUp() {
System.out.println("學生起床，起不來，鬧鍾響3次");
}
@Override
public void dressing() {
System.out.println("學生穿衣服，找不到衣服");
}
@Override
public void eat() {
System.out.println("學生吃早餐，來不及吃早餐");
}
}
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();
}
}