主頁 > 後端開發 > java設計模式之七大原則

java設計模式之七大原則

2022-09-25 06:16:49 後端開發

java設計模式

 以下內容為本人的學習筆記，如需要轉載，請宣告原文鏈接   https://www.cnblogs.com/lyh1024/p/16724932.html

 

設計模式

1.設計模式的目的

撰寫軟體程序中，程式員面臨著來自耦合性，內聚性和可維護性，可擴展性，重用性，靈活性等多方面的挑戰，設計模式是為了讓程式（軟體）具有更好的

  1. 代碼重用性（即：相同功能的代碼，不用多次撰寫）

  2. 可讀性（即：編程規范性，便于其他程式員的閱讀和理解）

  3. 可擴展性（即：當需要增加新的功能時，非常的方便，也稱為可維護性）

  4. 可靠性（即：當我們增加新的功能后，對原來的功能沒有影響）

  5. 使程式呈現高內聚，低耦合的特性

 

2.設計模式七大原則

設計模式原則，其實就是程式員在編程時，應當遵守的原則，也是各種設計模式的基礎（即：設計模式為什么這樣設計的依據）

設計模式常用的七大原則有：

  1. 單一職責原則

  2. 介面隔離原則

  3. 依賴倒轉原則

  4. 里式替換原則

  5. 開閉原則

  6. 迪米特法則

  7. 合成復用原則

 

3.單一職責原則

對類來說，即一個類只負責一項職責，如類A負責兩個不同職責：職責1，職責2，當職責1需求變更而改變A時，可能造成職責2執行錯誤，所以需要將類A細分為兩個類，A1類，A2類，

代碼：
public class Single {
    public static void main(String[] args) {
        //小明在看紙質書，小紅在看電子書
        paperRead r1 = new paperRead();
        r1.read("小明");
?
        eRead r2 = new eRead();
        r2.read("小紅");
    }
?
?
}
?
//1.遵守單一職責原則
//2.將類分解，同時修改客戶端
?
class paperRead{
?
    public void read(String name){
        System.out.println(name+"在看紙質書...");
    }
?
}
class eRead{
?
    public void read(String name){
        System.out.println(name+"在看電子書...");
    }
?
}
?
public class Single {
    public static void main(String[] args) {
        //小明在看紙質書，小紅在看電子書
        ReadType r = new ReadType();
        r.paperRead("小明");
        r.eRead("小紅");
    }
?
}
//1.這種方法只是增加方法
//2.這里雖然沒有在類這個級別上遵守單一職責原則，但是在方法級別上，仍舊是遵守單一職責原則，對于方法少的可以這樣做
class ReadType{
?
    public void paperRead(String name){
        System.out.println(name+"在看紙質書...");
    }
    
    public void eRead(String name) {
        System.out.println(name + "在看電子書...");
    }
}
3.2 單一職責原則注意事項

  1. 降低類的復雜度，一個類只負責一個職責；

  2. 提高類的可讀性，可維護性；

  3. 降低變更引起的風險；

  4. 通常情況下，我們應當遵守單一職責原則，只有邏輯足夠簡單，才可以在代碼級違反單一職責原則；只有方法數量足夠少，才可以在方法級別保持單一職責原則，

 

4.介面隔離原則

客戶端不應該依賴它不需要的介面，即一個類對另一個類的依賴應該建立在最小的介面上

示例：

  • 類A通過介面Interface1依賴類B，類C通過介面Interface1依賴類D,如果介面Interface1對于類A和類C來說不是最小介面，那么類B和類D必須去實作他們不需要的方法，

  • 按介面隔離原則應當這樣處理：

    將介面Interface1拆分為獨立的幾個介面，類A和類C分別與他們需要的介面建立依賴關系，也就是采用介面隔離原則，

    代碼：

package com.atguigu.principle.segregation.improve;
?
public class Segregation1 {
?
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 使用一把
        A a = new A();
        a.depend1(new B()); // A類通過介面去依賴B類
        a.depend2(new B());
        a.depend3(new B());
?
        C c = new C();
?
        c.depend1(new D()); // C類通過介面去依賴(使用)D類
        c.depend4(new D());
        c.depend5(new D());
?
    }
?
}
?
// 介面1
interface Interface1 {
    void operation1();
?
}
?
// 介面2
interface Interface2 {
    void operation2();
?
    void operation3();
}
?
// 介面3
interface Interface3 {
    void operation4();
?
    void operation5();
}
?
class B implements Interface1, Interface2 {
    public void operation1() {
        System.out.println("B 實作了 operation1");
    }
?
    public void operation2() {
        System.out.println("B 實現了 operation2");
    }
?
    public void operation3() {
        System.out.println("B 實作了 operation3");
    }
?
}
?
class D implements Interface1, Interface3 {
    public void operation1() {
        System.out.println("D 實作了 operation1");
    }
?
    public void operation4() {
        System.out.println("D 實作了 operation4");
    }
?
    public void operation5() {
        System.out.println("D 實作了 operation5");
    }
}
?
class A { // A 類通過介面Interface1,Interface2 依賴(使用) B類，但是只會用到1,2,3方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
?
    public void depend2(Interface2 i) {
        i.operation2();
    }
?
    public void depend3(Interface2 i) {
        i.operation3();
    }
}
?
class C { // C 類通過介面Interface1,Interface3 依賴(使用) D類，但是只會用到1,4,5方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
?
    public void depend4(Interface3 i) {
        i.operation4();
    }
?
    public void depend5(Interface3 i) {
        i.operation5();
    }
}

 

5.依賴倒轉原則

依賴倒轉原則是指：

  1. 高層模塊不應該依賴底層模塊，二者都應該依賴其抽象；

  2. 抽象不應該依賴細節，細節應該依賴抽象；

  3. 依賴倒轉的中心思想是面向介面編程；

  4. 依賴倒轉原則是基于這樣的設計理念：相對于細節的多變性，抽象的東西要穩定的多，以抽象為基礎搭建的架構比以細節為基礎的架構要穩定的多，在java中，抽象指的是介面或抽象類，細節就是具體的實作類；

  5. 使用介面或抽象類的目的是制定好規范，而不涉及任何具體的操作，把展現細節的任務交給他們的實作類去完成

     

    簡單來說，類的方法引數原來是呼叫特定類的型別，現在倒轉過來，使用介面的型別；就是類的引數為介面型別的變數，

依賴關系傳遞的三種方式：

  • 介面傳遞

  • 構造方法傳遞

  • setter方法傳遞

    代碼：

public class DependencyPass {
?
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ChangHong changHong = new ChangHong();
//      OpenAndClose openAndClose = new OpenAndClose();
//      openAndClose.open(changHong);
        
        //通過構造器進行依賴傳遞
//      OpenAndClose openAndClose = new OpenAndClose(changHong);
//      openAndClose.open();
        //通過setter方法進行依賴傳遞
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(changHong);
        openAndClose.open();
?
    }
?
}
?
// 方式1： 通過介面傳遞實作依賴
// 開關的介面
// interface IOpenAndClose {
// public void open(ITV tv); //抽象方法,接收介面
// }
//
// interface ITV { //ITV介面
// public void play();
// }
// 
// class ChangHong implements ITV {
//
//  @Override
//  public void play() {
//      // TODO Auto-generated method stub
//      System.out.println("長虹電視機，打開");
//  }
//   
// }
//// 實作介面
// class OpenAndClose implements IOpenAndClose{
// public void open(ITV tv){
// tv.play();
// }
// }
?
// 方式2: 通過構造方法依賴傳遞
// interface IOpenAndClose {
// public void open(); //抽象方法
// }
// interface ITV { //ITV介面
// public void play();
// }
// class OpenAndClose implements IOpenAndClose{
// public ITV tv; //成員
// public OpenAndClose(ITV tv){ //構造器
// this.tv = tv;
// }
// public void open(){
// this.tv.play();
// }
// }
?
?
// 方式3 , 通過setter方法傳遞
interface IOpenAndClose {
    public void open(); // 抽象方法
?
    public void setTv(ITV tv);
}
?
interface ITV { // ITV介面
    public void play();
}
?
class OpenAndClose implements IOpenAndClose {
    private ITV tv;
?
    public void setTv(ITV tv) {
        this.tv = tv;
    }
?
    public void open() {
        this.tv.play();
    }
}
?
class ChangHong implements ITV {
?
    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("長虹電視機，打開");
    }
     
}

依賴倒轉原則注意事項：

  • 底層模塊盡量都要有抽象類或介面，或者兩者都有，程式穩定性更好；

  • 變數的宣告型別盡量是抽象類或介面，這樣我們的變數參考和實際物件建，就存在一個緩沖層，利于程式擴展和變化；

  • 繼承時遵循里式替換原則，

 

6.里式替換原則

  • 繼承包含這樣一層含義：父類中凡是已經實作好的方法，實際上是設定規范和契約，雖然它不強制要求所有的子類必須遵循這些契約，但是如果子類對這些已經實作的方法任意修改，就會對整個繼承體系造成破壞，

  • 繼承在給程式設計帶來便利的同時，也帶來弊端，比如使用繼承會給程式帶來侵入性，程式的可移植性降低，增加物件間的耦合性，如果一個類被其他的類所繼承，則當這個類需要修改時，必須考慮到所有的子類，并且父類修改后，所有涉及到子類的功能都有可能產生故障，

這時候，我們就要用到里式替換原則：

  1. 里式替換原則在1988年，有麻省理工學院的一位性里的女士提出的；

  2. 如果對每個型別為T1的物件o1，都有型別為T2的物件o2，使得以T1定義的所有程式P在所有的物件o1都代換成o2時，程式P的行為沒有發生變化，那么型別T2是型別T1的子型別，換句話說，所有參考基類的地方必須能透明地使用其子類的物件；

  3. 在使用繼承時，遵循里式替換原則，在子類中盡量不要重寫父類的方法；

  4. 里式替換原則告訴我們，繼承實際上讓兩個類耦合性增強了，在適當的情況下，可以通過聚合，組合，依賴來解決問題，

 

通用做法：原來的父類和子類都繼承一個更通俗的基類，原有的繼承關系去掉，采用依賴，聚合，組合等關系代替，

代碼：

public class Liskov {
?
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
?
        System.out.println("-----------------------");
        B b = new B();
        //因為B類不再繼承A類，因此呼叫者，不會再func1是求減法
        //呼叫完成的功能就會很明確
        System.out.println("11+3=" + b.func1(11, 3));//這里本意是求出11+3
        System.out.println("1+8=" + b.func1(1, 8));// 1+8
        System.out.println("11+3+9=" + b.func2(11, 3));
        
        
        //使用組合仍然可以使用到A類相關方法
        System.out.println("11-3=" + b.func3(11, 3));// 這里本意是求出11-3
        
?
    }
?
}
?
//創建一個更加基礎的基類
class Base {
    //把更加基礎的方法和成員寫到Base類
}
?
// A類
class A extends Base {
    // 回傳兩個數的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
?
// B類繼承了A
// 增加了一個新功能：完成兩個數相加,然后和9求和
class B extends Base {
    //如果B需要使用A類的方法,使用組合關系
    private A a = new A();
    
    //這里，重寫了A類的方法, 可能是無意識
    public int func1(int a, int b) {
        return a + b;
    }
?
    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
    
    //我們仍然想使用A的方法
    public int func3(int a, int b) {
        return this.a.func1(a, b);
    }
}
?

 

7.開閉原則

  1. 開閉原則是編程中最基礎，最重要的設計原則；

  2. 一個軟體物體，如類，模塊和函式應該對擴展開放（對提供方），對修改關閉（對使用方），用抽象構建框架，用實作擴展細節；

  3. 當軟體需要變化時，盡量通過擴展軟體物體的行為來實作變化，而不是通過修改已有的代碼來實作變化；

  4. 編程中遵循其他原則，以及使用設計模式的目的就是遵循開閉原則，

示例：

public class Ocp {
?
    public static void main(String[] args) {
        //使用看看存在的問題
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
?
}
?
//這是一個用于繪圖的類 [使用方]
class GraphicEditor {
    //接收Shape物件，然后根據type，來繪制不同的圖形
    public void drawShape(Shape s) {
        if (s.m_type == 1)
            drawRectangle(s);
        else if (s.m_type == 2)
            drawCircle(s);
        else if (s.m_type == 3)
            drawTriangle(s);
    }
?
    //繪制矩形
    public void drawRectangle(Shape r) {
        System.out.println(" 繪制矩形 ");
    }
?
    //繪制圓形
    public void drawCircle(Shape r) {
        System.out.println(" 繪制圓形 ");
    }
    
    //繪制三角形
    public void drawTriangle(Shape r) {
        System.out.println(" 繪制三角形 ");
    }
}
?
//Shape類，基類
class Shape {
    int m_type;
}
?
class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
}
?
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
}
?
//新增畫三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }
}
?

上述方式的優缺點

  1. 優點是比較好理解，簡單操作；

  2. 缺點是違反了設計模式的ocp原則，即對外擴展，對修改關閉，即當我們給類增加新功能的時候，盡量不修改代碼，或者盡可能少修改代碼；

  3. 比如我們這是要心增加一個圖形種類三角形，我們需要做如下修改，修改的地方較多

把創建Shape類做出抽象類，并提供一個抽象的draw方法，讓子類去實作即可，這樣我們有新的圖形種類時，只需要讓新的圖形來繼承Shape，并實作draw方法即可，使用方的代碼就不需要修改，滿足了開閉原則：

public class Ocp {
?
    public static void main(String[] args) {
        //使用看看存在的問題
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
?
}
?
//這是一個用于繪圖的類 [使用方]
class GraphicEditor {
    //接收Shape物件，呼叫draw方法
    public void drawShape(Shape s) {
        s.draw();
    }
?
    
}
?
//Shape類，基類
abstract class Shape {
    int m_type;
    
    public abstract void draw();//抽象方法
}
?
class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
?
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println(" 繪制矩形 ");
    }
}
?
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println(" 繪制圓形 ");
    }
}
?
//新增畫三角形
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println(" 繪制三角形 ");
    }
}
?
//新增一個圖形
class OtherGraphic extends Shape {
    OtherGraphic() {
        super.m_type = 4;
    }
?
    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println(" 繪制其它圖形 ");
    }
}
?

 

8.迪米特法則

  1. 一個物件應該對其他物件保持最少的了解；

  2. 類與類關系越密切，耦合度越大；

  3. 迪米特法則又叫最少知道原則，即一個類對自己依賴的類知道的越少越好，也就是說，對于被依賴的類不管有多么復雜，都盡量將邏輯封裝在類的內部，對外處理提供的public方法，不對外泄露任何資訊；

  4. 迪米特法則還有個更簡單的定義：只與直接的朋友通信；

  5. 直接的朋友：每個物件都會與其他物件有耦合關系，只要兩個物件之間有耦合關系，我們就說這兩個物件之間是朋友關系，耦合的方式很多，依賴，關聯，組合，聚合等，其中，我們稱出現成員變數，方法引數，方法回傳值中的類為直接的朋友，而出現在區域變數中的類不是直接的朋友，也就是說，陌生的類最好不要以區域變數的形式出現在類的內部，

示例：

有一個學校，下屬有各個學院和總部，現要求學校總部員工ID和學院員工的id：

import java.util.ArrayList;
import java.util.List;
?
//客戶端
public class Demeter1 {
?
    public static void main(String[] args) {
        System.out.println("~~~使用迪米特法則的改進~~~");
        //創建了一個 SchoolManager 物件
        SchoolManager schoolManager = new SchoolManager();
        //輸出學院的員工id 和  學校總部的員工資訊
        schoolManager.printAllEmployee(new CollegeManager());
?
    }
?
}
?
?
//學校總部員工類
class Employee {
    private String id;
?
    public void setId(String id) {
        this.id = id;
    }
?
    public String getId() {
        return id;
    }
}
?
?
//學院的員工類
class CollegeEmployee {
    private String id;
?
    public void setId(String id) {
        this.id = id;
    }
?
    public String getId() {
        return id;
    }
}
?
?
//管理學院員工的管理類
class CollegeManager {
    //回傳學院的所有員工
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) { //這里我們增加了10個員工到 list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("學院員工id= " + i);
            list.add(emp);
        }
        return list;
    }
    
    //輸出學院員工的資訊
    public void printEmployee() {
        //獲取到學院員工
        List<CollegeEmployee> list1 = getAllEmployee();
        System.out.println("------------學院員工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
    }
}
?
//學校管理類
?
//分析 SchoolManager 類的直接朋友類有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一個陌生類，這樣違背了 迪米特法則 
class SchoolManager {
    //回傳學校總部的員工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        
        for (int i = 0; i < 5; i++) { //這里我們增加了5個員工到 list
            Employee emp = new Employee();
            emp.setId("學校總部員工id= " + i);
            list.add(emp);
        }
        return list;
    }
?
    //該方法完成輸出學校總部和學院員工資訊(id)
    void printAllEmployee(CollegeManager sub) {
        
        //分析問題
        //1. 將輸出學院的員工方法，封裝到CollegeManager
        sub.printEmployee();
    
        //獲取到學校總部員工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------學校總部員工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}
?

迪米特法則注意事項：

  • 迪米特法則的核心是降低類之間的耦合；

  • 但是注意：由于每個類都減少了不必要的依賴，因此迪米特法則只是要求類間（物件間）耦合關系，并不是要求完全沒有依賴關系，

 

9.合成復用原則

盡量使用合成/聚合的方式，而不是使用繼承

聚合：

 

組合：

 

10.設計原則核心思想

  1. 找出應用中可能需要變化之處，把他們獨立出來，不要和那些不需要變化的代碼混在一起；

  2. 針對介面編程，而不是針對實作編程；

  3. 為了互動物件之間的松耦合設計而努力，

 

參考資料：

  • 視頻資料：https://www.bilibili.com/video/BV1G4411c7N4?p=1&vd_source=437f14fa7b3a06c1e6f15003137675e6

 

2022-09-24  09:09:56

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

標籤：Java

上一篇：go語言實作的定時任務管理系統 gocron 2.0

下一篇：Java基礎（識別符號，資料型別，資料轉換，變數）

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂