設計模式學習記錄

設計模式23種

  • 創建型
    • 抽象工廠模式
    • 工廠模式
    • 生成器模式
    • 原型模式
    • 單例模式
  • 結構型
    • 適配器模式
    • 橋接模式
    • 組合模式
    • 裝飾模式
    • 外觀模式
    • 享元模式
    • 代理模式
  • 行為型
    • 責任鏈模式
    • 命令模式
    • 解釋器模式
    • 迭代器模式
    • 中介者模式
    • 備忘錄模式
    • 觀察者模式
    • 狀態模式
    • 策略模式
    • 模版方法模式
    • 訪問者模式

創建型

與對象的創建有關

抽象工廠模式

提供一個創建一系列相關或相互依賴的對象的接口

//來1張1費卡  1張2費卡 一系列相關
class Card {
public:virtual void out() = 0;
};
//還可以定義更多的卡牌
class CardCost1:public Card {
public:virtual void out() {cout << "我是1費卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2費卡" << endl;}
};class Factory {
public:virtual Card* CreateCost1() = 0;virtual Card* CreateCost2() = 0;
};
//還可以定義更多的工廠來組合
class CardFactory:public Factory {
public:Card* CreateCost1() {//來一張1費卡return new CardCost1();}Card* CreateCost2() {//來一張2費卡return new CardCost2();}
};
class CardFamaly
int main() {CardFactory *fac = new CardFactory();Card* cost1 = fac->CreateCost1();Card* cost2 = fac->CreateCost2();cost1->out();cost2->out();delete cost1;delete cost2;delete fac;return 0;
}

工廠模式

定義一個用于創建對象的接口,讓子類決定實例化哪個類
//和抽象工廠區別是 1個和多個？

class Card {
public:virtual void out() = 0;
};class CardCost1:public Card {
public:virtual void out() {cout << "我是1費卡" << endl;}
};class CardCost2 :public Card {
public:virtual void out() {cout << "我是2費卡" << endl;}
};
class Factory {
public:virtual Card* Create() = 0;
};class CardCost1Factory:public Factory {
public:Card* Create() {return new CardCost1();}
};class CardCost2Factory :public Factory {
public:Card* Create() {return new CardCost2();}
};
int main() {CardCost1Factory* fac1 = new CardCost1Factory();CardCost2Factory* fac2 = new CardCost2Factory();Card* cost1 = fac1->Create();Card* cost2 = fac2->Create();cost1->out();cost2->out();delete cost1;delete cost2;delete fac1;delete fac2;return 0;
}

生成器模式

在某些情況下，一個對象的創建過程非常復雜，涉及多個步驟，每個步驟都可能有不同的實現方式。如果將所有創建邏輯放在一個類中，會導致該類變得龐大且難以維護。此外，如果需要創建不同的變體對象，就需要在該類中添加更多的邏輯，使得代碼變得混亂。

原型模式

克隆

單例模式

就是單例

結構型

適配器模式

將一個類的接口轉變為另外一個希望的接口

template<typename Type>
void permutation(Type first, int len) {int val = 1;for (int i = 0; i < len; i++) {*first = val;val++;first++;}
}int main() {vector<int> a;//本來vector 不能用 = int 賦值 ++//把vector =>back_insert_iterator(重載++ = ) 調用vector push_backpermutation(back_inserter(a), 10);int b[20];permutation(b, 10);return 0;
}

橋接模式

將抽象部分和其實現部分分離,使它們都可以獨立的變化

//羈絆
class Jiban {
public:virtual void out() = 0;
};class Family :public Jiban {
public:virtual void out() {cout << " 家人 " << endl;}
};class ZhenMan :public Jiban {
public:virtual void out() {cout << " 鐵血屈服者 " << endl;}
};
//英雄
class Hero {
public:virtual void out() = 0;virtual void SetJiban(Jiban* jb) = 0;Jiban* m_jb = nullptr;
};class BaoBao:public Hero {
public:virtual void out() {cout << " 爆爆 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}};class JieSi :public Hero {
public:virtual void out() {cout << " 杰斯 ";m_jb->out();}virtual void SetJiban(Jiban* jb) {m_jb = jb;}
};int main() {Family* family = new Family;ZhenMan* zm = new ZhenMan;JieSi* js = new JieSi();BaoBao* bb = new BaoBao();js->SetJiban(zm);bb->SetJiban(family);js->out();bb->out();return 0;}

組合模式

將對象組合成樹型結構以表示整體與部分的層次結構
文件系統

裝飾模式

動態的給一個對象添加一些額外的職責

class Water {
public:virtual int cost() = 0;virtual void out() = 0;
};class Wahaha :public Water {
public:virtual int cost() {return 2;}virtual void out() {cout << "娃哈哈";}
};class WaterDecorator :public Water {
public:WaterDecorator(Water* self) {m_self = self;}virtual int cost() {return m_self->cost();}virtual void out() {m_self->out();}Water* m_self;
};
//加冰
class IceDecorator :public WaterDecorator {
public:IceDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加冰 ";}
};
//加糖
class SugarDecorator :public WaterDecorator {
public:SugarDecorator(Water* self) :WaterDecorator(self) {}virtual int cost() {return 1 + m_self->cost();}virtual void out() {m_self->out();cout << " 加糖 ";}
};int main() {Wahaha* whh = new Wahaha();{IceDecorator* d = new IceDecorator(whh);SugarDecorator* d2 = new SugarDecorator(d);d2->out();cout << d2->cost() << endl;}return 0;
}

外觀模式

為子系統中一組接口提供一個一致的界面

class Computer {
public:void turnOn() {cout << " 開電腦 ";}void turnOff() {cout << " 關電腦 ";}
};
class Light {
public:void turnOn() {cout << " 開燈 ";}void turnOff() {cout << " 關燈 ";}
};class MyLife {Computer computer;Light light;
public:void play() {computer.turnOn();light.turnOn();cout << endl;}void sleep() {computer.turnOff();light.turnOff();cout << endl;}
};int main() {MyLife* mf = new MyLife;mf->play();mf->sleep();return 0;
}

享元模式

運用共享技術有效的支持大量細粒度的對象

struct Base {
public:string name;int gongji;//攻擊int fangyu;//防御
};class BaoBao{
public:BaoBao(Base *base) {m_base = base;x = y = 0;}Base* m_base;int x, y;//坐標
};class BaoBaoFactory {public:BaoBao* GetHero() {Base* base = nullptr;if (mmp.count("爆爆"))base = mmp["爆爆"];else {base = new Base;base->name = "爆爆";base->gongji = 999;base->fangyu = 999;mmp[base->name] = base;}return new BaoBao(base);}unordered_map<string, Base *> mmp;
};int main() {BaoBaoFactory* fac = new BaoBaoFactory();vector<BaoBao* > all;for (int i = 0; i < 100; i++) {all.push_back(fac->GetHero());}return 0;
}

代理模式

行為型

行為模式涉及算法和對象間職責的分配。行為模式不僅描述對象或類的模式，還描述它們之間的通信模式

責任鏈模式

使多個對象都有機會處理請求，從而避免請求的發送者和接受者之間的耦合關系。將這些對象連成一條鏈，并沿著這條鏈傳遞改請求，直到有一個對象處理它為止。

class Request {
public:Request(int m, string i) :money(m), info(i) {}int money;string info;
};class RequestHandler {
public:virtual void DoHandle(Request* req) = 0;void SetHandler(RequestHandler* handler) {m_handler = handler;}RequestHandler* m_handler = nullptr;
};class Father :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 20) {cout << "Father Handler,give money = " << req->money << endl;}else if (m_handler) {req->money += 1000;m_handler->DoHandle(req);}}
};class Mother :public RequestHandler {
public:virtual void DoHandle(Request* req) {if (req->money <= 5000) {cout << "Mother Handler,give money = " << req->money << endl;}else if (m_handler) {m_handler->DoHandle(req);}}
};int main() {Request* r = new Request(500, "補課費");Father* f = new Father();Mother* m = new Mother();f->SetHandler(m);f->DoHandle(r);return 0;
}

命令模式

將一個請求封裝為一個對象，從而使得可以用不同的請求對客戶進行參數化；對請求排隊或記錄請求日志，以及支持可撤銷操作。

class Light {
public:void TurnOn() {cout << "light TurnOn" << endl;}void TurnOff() {cout << "light TurnOff" << endl;}
};class Command {
public:virtual void exe() = 0;
};class OpenCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOn();}Light* m_light;
};class CloseCommand :public Command {
public:void setLight(Light* light) {m_light = light;}virtual void exe() {m_light->TurnOff();}Light* m_light;
};int main() {Light* light = new Light;OpenCommand* open = new OpenCommand;CloseCommand* close = new CloseCommand;open->setLight(light);close->setLight(light);open->exe();close->exe();return 0;
}

解釋器模式

給定一個語言，定義它的文法的一種表示，并定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。

迭代器模式

提供一種順序訪問一個聚合對象中的各個元素，且不需要暴露該對象的內部表示。

中介者模式

用一個中介對象來封裝一系列的對象交互。中介者使各對象不需要顯式地相互引用，從而使其耦合松散，而且可以獨立的改變它們之間的交互。

class User;
class middleman {
public:virtual void sendMessage(string &msg, User* sender) = 0;virtual void addUser(User* user) = 0;
};class User {
public:User(string name, middleman* middleman):m_name(name),m_middleman(middleman){middleman->addUser(this);}void sendMessage(string &msg) {cout << m_name << ":Say " << msg << endl;m_middleman->sendMessage(msg,this);}void recvMessage(string& msg) {cout << m_name << ":Recv " << msg << endl;}string m_name;middleman* m_middleman;
};class ChatRoom :public middleman {vector<User*> m_all;
public:virtual void sendMessage(string &msg,User * sender) {for (auto user : m_all) {if (user == sender)continue;user->recvMessage(msg);}}virtual void addUser(User* user) {m_all.push_back(user);}
};int main() {ChatRoom* room = new ChatRoom();User* user1 = new User("小明", room);User* user2 = new User("小花", room);User* user3 = new User("康康", room);string msg = "How are you";user3->sendMessage(msg);return 0;
}

備忘錄模式

在不破壞封裝性的前提下捕獲一個對象的內部狀態，并在對象之外保存這個狀態。這樣以后就可以將對象恢復原先保存的狀態。

觀察者模式

定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都得到通知并自動更新。
和中介者模式區別 1對多 和 多對多 樹和圖？

//觀察者
class Observer {
public:virtual void update(int state) = 0;
};class ActObserver:public Observer {
public:ActObserver(string name, int state) :m_name(name), m_state(state) {}virtual void update(int state) {m_state = state;cout << m_name << ":update state = " << m_state << endl;}
private:string m_name;int m_state;
};//主題
class Subject {
public:virtual void addObserver(Observer *observer) = 0;virtual void removeObserver(Observer* observer) = 0;virtual void notify() = 0;
};class ActSubject {
public:virtual void addObserver(Observer* observer) {m_all.insert(observer);}virtual void removeObserver(Observer* observer) {m_all.erase(observer);}virtual void notify() {for (auto ob : m_all) {ob->update(m_state);}}
public:void setState(int state) { m_state = state;notify();}
private:set<Observer*> m_all;int m_state;
};int main() {ActObserver* aob = new ActObserver("小美", 0);ActObserver* aob2 = new ActObserver("小帥", 0);ActSubject* sub = new ActSubject();sub->addObserver(aob);sub->addObserver(aob2);sub->setState(2);sub->removeObserver(aob);sub->setState(1);return 0;
}

狀態模式

允許一個對象在其內部狀態改變時改變它的行為。對象看起來似乎修改了它的類。
把一堆if else 放到一個一個單獨的類中處理

class State;
class Context {
public:virtual void SetState(State* state) = 0;
};class State {
public:virtual void handle(Context* context) = 0;Context *m_context = nullptr;
};class StateA :public State {
public:virtual void handle(Context* context) {cout << "StateA" << endl;//本來 if else 一坨 把每個狀態拆在一個單獨的類中處理 context->SetState(this);}
};class StateB :public State {
public:virtual void handle(Context* context) {cout << "StateB" << endl;context->SetState(this);}
};class ContextA :public Context {
public:ContextA() {m_state = new StateA();}virtual void SetState(State* state) {m_state = state;}void ChangeState(State* state) {state->handle(this);}State* m_state;
};int main() {StateA* A = new StateA();StateB* B = new StateB();ContextA* C = new ContextA();C->ChangeState(A);C->ChangeState(B);C->ChangeState(A);return 0;
}

策略模式

定義一系列的算法，把它們一個個封裝起來，并且使它們可以相互替換。此模式使得算法可以獨立于使用它們的客戶而變化。

class MathOperation {
public:virtual int DoOperation(int a, int b) = 0;
};
class Add :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a^2 + breturn a * a + b;}
};class Sub :public MathOperation {
public:virtual int DoOperation(int a, int b) {//a - b^2return a - b * b;}
};class Calc {
public:void SetOperation(MathOperation* op) { m_op = op; }int DoIt(int a, int b) {return m_op->DoOperation(a, b);}
private:MathOperation* m_op;
};int main() {Add* add = new Add();Sub* sub = new Sub();Calc* calc = new Calc();calc->SetOperation(add);cout << "DoIt = " << calc->DoIt(1,2) << endl;calc->SetOperation(sub);cout << "DoIt = " << calc->DoIt(3, 4) << endl;return  0;
}

模版方法模式

定義一個操作中的算法骨架，而將一些步驟延遲到子類中。

class Hero {
public:virtual int getHurt() {//傷害計算算法return getPhysicsHurt() + getMagicHurt();}
public:virtual int getPhysicsHurt() = 0;//物理傷害virtual int getMagicHurt() = 0;//魔法傷害virtual string getName() = 0;};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");cout << bb->getName() << " Hart = " << bb->getHurt() << endl;cout << js->getName() << " Hart = " << js->getHurt() << endl;return 0;
}

訪問者模式

表示一個作用于某對象結構中的元素的操作。它允許在不改變各元素的類的前提下定義作用于這些元素的新操作。
英雄帶裝備

class Hero {
public:virtual int getPhysicsHurt() = 0;//物理傷害virtual int getMagicHurt() = 0;//魔法傷害virtual string getName() = 0;
};
//爆爆
class BaoBao:public Hero {
public:BaoBao(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 50;}virtual int getMagicHurt() {return 100;}virtual string getName() {return m_name;}string m_name;
};//杰斯 
class JieSi :public Hero {
public:JieSi(string name) :m_name(name) {}virtual int getPhysicsHurt() {return 200;}virtual int getMagicHurt() {return 20;}virtual string getName() {return m_name;}string m_name;
};class Equipment {
public:virtual int getHurt(Hero* hero) = 0;
};
//帽子
class Maozi :public Equipment {
public:Maozi() {m_name = "帽子";dPhysicsRate = 1.1;dMagicRate = 2.0;}virtual int getHurt(Hero* hero) {int ans = hero->getPhysicsHurt()* dPhysicsRate + hero->getMagicHurt() * dMagicRate;cout << m_name << " " << hero->getName() << ":" << ans << endl;return ans;}
private:double dPhysicsRate;double dMagicRate;string m_name;
};int main() {BaoBao* bb = new BaoBao("爆爆");JieSi* js = new JieSi("杰斯");Maozi* mz = new Maozi();mz->getHurt(bb);mz->getHurt(js);return 0;
}

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/pingmian/72456.shtml
繁體地址，請注明出處：http://hk.pswp.cn/pingmian/72456.shtml
英文地址，請注明出處：http://en.pswp.cn/pingmian/72456.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

2.5 python接口編程

2.5 python接口編程

在現代軟件開發的復雜生態系統中&#xff0c;不同系統、模塊之間的交互協作至關重要。接口編程作為一種關鍵機制&#xff0c;定義了組件之間的通信規范與交互方式。Python 憑借其卓越的靈活性、豐富的庫資源以及簡潔易讀的語法&#xff0c;在接口編程領域占據了重要地位&#x…
閱讀更多...
mesh開發解析

mesh開發解析

開源的Mesh網絡協議棧及相關項目&#xff1a; 1.B.A.T.M.A.N.(Better Approach to Mobile Ad-hoc Networking)? 簡介&#xff1a;B.A.T.M.A.N.是一種用于多跳自組織網絡的路由協議&#xff0c;適用于無線Mesh網絡。它通過優化數據傳輸路徑&#xff0c;確保網絡的高可靠性和動…
閱讀更多...
PyTorch PINN實戰：用深度學習求解微分方程

PyTorch PINN實戰：用深度學習求解微分方程

在人工智能與計算數學的交匯點&#xff0c;物理信息神經網絡&#xff08;Physics-Informed Neural Networks&#xff0c;PINN&#xff09;正引領著一場求解微分方程的革命。傳統上&#xff0c;微分方程是描述自然現象和工程問題中各種關系的重要工具&#xff0c;但其求解往往依…
閱讀更多...
【WiFi 7核心技術及未來挑戰】

【WiFi 7核心技術及未來挑戰】

作為剛剛開始從事這一領域的人&#xff0c;淺淺學習了一下WiFi 7&#xff08;IEEE 802.11be&#xff09;。Wi-Fi 7發展迅速&#xff0c;提供前所未有的速度、更低的延遲和更高的可靠性。但從頻譜政策到能效挑戰&#xff0c;再到成本&#xff0c;仍有許多問題亟待解決。 Wi-Fi 7…
閱讀更多...
Oracle Linux Server 7.9安裝fail2ban

Oracle Linux Server 7.9安裝fail2ban

yum search oracle-epel-release yum install oracle-epel-release-el7 search fail2ban yum install fail2ban nano /etc/fail2ban/jail.d/00-firewalld.conf # defalut這里是設定全局設置&#xff0c;如果下面的監控沒有設置就以全局設置的值設置。 [DEFAULT] # 用于指定哪…
閱讀更多...
目標在哪里？——尋找人生的意義與方向

目標在哪里？——尋找人生的意義與方向

在職場中&#xff0c;許多人都會經歷這樣的困惑&#xff1a;工作看似順利&#xff0c;卻逐漸失去了成就感和成長感。一位在500強企業工作的學員就遇到了這樣的問題。她曾考慮過轉型做培訓&#xff0c;但苦于找不到明確的切入點&#xff0c;對未來的目標感到迷茫。她不禁問自己&…
閱讀更多...
C++類與對象——拷貝構造與運算符重載

C++類與對象——拷貝構造與運算符重載

拷貝構造函數和賦值運算符重載就是C類默認六個函數之二。 拷貝構造函數&#xff1a; 如果?個構造函數的第?個參數是自身類類型的引用&#xff0c;且任何額外的參數都有默認值&#xff0c;則此構造函數 也叫做拷貝構造函數&#xff0c;也就是說拷貝構造是?個特殊的構造函數…
閱讀更多...
破碎的誓言

破碎的誓言

破碎的誓言 在秋風的呢喃中&#xff0c;落葉輕嘆&#xff0c; 昔日的誓言&#xff0c;如煙消散。 你的眼眸&#xff0c;曾是我星辰的指引&#xff0c; 如今&#xff0c;卻成了最深的迷惘。 欺騙的利刃&#xff0c;刺穿了信任的堡壘&#xff0c; 我的心&#xff0c;如裂開…
閱讀更多...
AD畫板學習

AD畫板學習

AD畫板 01 課程簡介及學習目標 &#xff08;1&#xff09;能熟練的新建項目文件、原理圖文件、PCB文件且修改文件名&#xff0c;并知道文件保存的位置&#xff1b; &#xff08;2&#xff09;會設置原理圖編輯器的工作環境&#xff0c;會自底向上繪制層次原理圖&#xff1b; …
閱讀更多...
Linux：進程程序替換

Linux：進程程序替換

目錄 前言 一 進程程序替換的概念 二 進程程序替換的原理 三 為什么需要進行進程程序替換 四 如何進行進程程序替換 1. 進程替換函數 ? execl()函數 ?execv()函數 ?execlp()函數 ?execle()函數 ?execve()* 前言 一般情況下&#xff0c;對應的語言寫的程序只…
閱讀更多...
基于變分推理與 Best?of?N 策略的元 Prompt 自動生成與優化框架

基于變分推理與 Best?of?N 策略的元 Prompt 自動生成與優化框架

摘要 本文提出了一種融合變分推理與 Best?of?N 策略的元 Prompt 自動生成與優化框架&#xff0c;通過高度參數化的模板、隨機擾動采樣及多指標評分機制&#xff0c;實現從初始提示生成到最終輸出的動態優化。同時&#xff0c;針對實際應用中對自適應參數調整、深層語義理解、…
閱讀更多...
Umi-OCR 全家桶

Umi-OCR 全家桶

介紹&#xff1a; 下載 訪問官網地址 https://github.com/hiroi-sora/umi-ocrhttps://github.com/hiroi-sora/umi-ocr 點擊下載&#xff08;.exe 文件 安裝即可&#xff09; 桌面使用 安裝完畢后去安裝路徑下點擊 Umi-OCR.exe &#xff08;默認不會生成桌面的快捷方式&…
閱讀更多...
2023南京理工大學計算機復試上機真題

2023南京理工大學計算機復試上機真題

2023南京理工大學計算機復試上機真題 2023南京理工大學計算機復試機試真題 歷年南京理工大學計算機復試上機真題 在線評測&#xff1a;傳送門&#xff1a;pgcode.cn 括號匹配二 題目描述 苗苗今天剛剛學會使用括號&#xff0c;不過他分不清小括號&#xff0c;中括號&#…
閱讀更多...
Conda 常規用法指南

Conda 常規用法指南

Conda 常規用法指南 1. Conda 簡介 Conda 是一個開源的包管理和環境管理系統&#xff0c;主要用于 Python 和其他編程語言的開發環境。它能夠方便地安裝、更新和管理依賴項&#xff0c;使得不同項目可以使用不同的 Python 版本和庫。 2. Conda 環境管理 2.1 創建新的環境 conda…
閱讀更多...
非零初始條件系統的傳遞函數分析

非零初始條件系統的傳遞函數分析

非零初始條件系統的傳遞函數分析 在傳遞函數的定義中&#xff0c;通常假設系統滿足零初始條件。然而在實際應用中&#xff0c;很多系統需要處理非零初始狀態。為了探討這一問題&#xff0c;我們以一個一階微分方程為例進行分析。 一、一階系統的分析 考慮以下一階微分方程&a…
閱讀更多...
centos7安裝時采用的默認分區（比如：/dev/sda3的對應掛載點是/），如何對系統擴容？

centos7安裝時采用的默認分區（比如：/dev/sda3的對應掛載點是/），如何對系統擴容？

?非LVM分區擴容方案? 若 /dev/sda3 是?非LVM分區?且存儲重要數據&#xff0c;可通過 ?直接擴展分區容量? ?調整文件系統? 實現擴容&#xff0c;無需重建LVM或格式化分區?。以下是具體步驟&#xff1a; ?1. 擴展物理磁盤&#xff08;虛擬機場景&#xff09;? ?關…
閱讀更多...
Axios簡單說明，快速上手

Axios簡單說明，快速上手

Ajax&#xff1a;異步的JavaScript和XML 作用&#xff1a; 數據交換異步交互 Axios&#xff1a;就是對原生Ajax進行封裝&#xff0c;簡化書寫&#xff0c;快速開發 使用邏輯&#xff1a; 首先要安裝Axios&#xff0c;可以通過npm在項目中安裝&#xff1a; 打開命令行工具…
閱讀更多...
模型評估——acc、P、R、F值、交叉驗證、K折交叉驗證

模型評估——acc、P、R、F值、交叉驗證、K折交叉驗證

模型評估&#xff1a;對預測函數地預測精度的評估。 多重回歸&#xff1a;涉及三個及其以上的變量的回歸問題。 評估模型的方法&#xff1a; 交叉驗證&#xff1a;將數據集分成測試集和訓練集&#xff0c;可以采用3&#xff1a;7或者2&#xff1a;8的比例方式進行劃分&#xff…
閱讀更多...
【Godot】Window類

【Godot】Window類

&#xff08;參考自deepseek回答&#xff09; 在 Godot 引擎中&#xff0c;Window 是一個用于管理應用程序窗口的類。它是 Godot 4.0 引入的新特性&#xff0c;取代了舊版本中的 OS 類對窗口的管理功能。Window 提供了對窗口大小、位置、標題、模式等屬性的控制&#xff0c;使開…
閱讀更多...
JVM 2015/3/15

JVM 2015/3/15

定義&#xff1a;Java Virtual Machine -java程序的運行環境&#xff08;java二進制字節碼的運行環境&#xff09; 好處&#xff1a; 一次編寫&#xff0c;到處運行 自動內存管理&#xff0c;垃圾回收 數組下標越界檢測 多態 比較&#xff1a;jvm/jre/jdk 常見的JVM&…
閱讀更多...
最新文章

Copyright @ 2022~2023