面向對象-高級篇

来源:https://www.cnblogs.com/Mr-shne/archive/2022/10/05/16698784.html
-Advertisement-
Play Games

類變數： 什麼是類變數？ 一個可以被一個類所有對象共用的變數 類變數關鍵字？ static 類變數語法？ 訪問修飾符 static 數據類型 變數名; [推薦使用] static 訪問修飾符 數據類型 變數名; 入門案例： count被child1和child2共用，只要是Child類的對象都可以共 ...


類變數：

  • 什麼是類變數？ 一個可以被一個類所有對象共用的變數
  • 類變數關鍵字？ static
  • 類變數語法？ 訪問修飾符 static 數據類型 變數名; [推薦使用]
  •                        static 訪問修飾符 數據類型 變數名;
  • 入門案例：
    • count被child1和child2共用，只要是Child類的對象都可以共用該變數　　
  • public class Test {
    public static void main(String[] args) {
        Child child1 = new Child("jack");
        child1.join();
        Child.count++;
        Child child2 = new Child("king");
        child2.join();
        Child.count++;
    }
}
class Child{
    String name;
    public static int count = 0;
    public Child(String name) {
        this.name = name;
    }
     public void join(){
         System.out.println(name);
     }
}

  • 類變數的記憶體發佈：

  • 類變數細節：

    • 類變數也叫靜態變數
    • 類變數可以通過 - 類名.類變數名 或 對象名.類變數，來訪問
    • 類變數是在類載入時初始化，就算沒有創建對象，只要類載入，就可以訪問類變數 - 重要
    • 類變數的生命周期是隨著類載入開始，類消亡而銷毀
    • public class Test {
    public static void main(String[] args) {
      //類變數，可以通過類名.類變數名稱，或對象名.類變數來訪問
            System.out.println(Child.count);
          }
}
class Child{
    static int count = 0;
}

 類方法：

  • 什麼是類方法？和類變數一樣通過關鍵字static來實現共用
  • 類方法的語法？訪問修飾符 static 數據返回類型 方法名(); - 推薦使用
  • 　　　              static 訪問修飾符 數據返回類型 方法名();
  • 類方法的使用場景？一般做為工具類來使用或者通用的方法(如：列印數組Arrays)，來提高開發效率，通過類名去調用
  • 案例：
  • public class Test {
    public static void main(String[] args) {
        Child jack = new Child("jack");
        Child.payFee(1000);
        Child kind = new Child("kind");
        Child.payFee(2000);
        Child.showFee();//3000
    }
}
class Child{
    private String name;
    //累加學費
    public static double fee = 0;

    public Child(String name) {
        this.name = name;
    }
    //靜態方法
    public static void payFee(double fee){
        Child.fee += fee;
    }
    //靜態方法
    public static void showFee(){
        System.out.println(fee);
    }
}

  • 類方法細節：

    • 類方法和普通方法都是隨著類的載入而載入，將結構存儲在方法區
    • 類方法中不能使用this和super
    • 類方法中只能訪問類變數或類方法　　
    • 普通成員方法，即可以訪問非靜態成員，也可以訪問靜態成員
    • class Child{
    String name;
    //類方法中不能使用this和super
    public static void payFee(double fee){
        System.out.println(this.name); //錯誤
        System.out.println(super.clone());//錯誤
        //類方法中只能訪問類變數或類方法
        showFee();//錯誤
        System.out.println(name);//錯誤
    }
    public void showFee(){
        //普通成員方法，即可以訪問非靜態成員，也可以訪問靜態成員
        System.out.println(name);//正確
        payFee(11.1);//正確
    }
}

main方法的理解：

  • main方法本虛擬機調用
  • java虛擬機需要調用類的main方法，使用main方法訪問許可權為public
  • java虛擬機在執行main方法時不必創建對象，所以是static
  • main方法的字元串類型數組參數，是在執行程式時傳遞

  • 細節：

    • main方法中，可以直接調用main方法所在類的的靜態方法和靜態屬性
    • 不能直接調用非靜態成員，必須創建一個實例底對象後才能調用
    • public class Test {
    private String name = "king";
    private static int age = 18;
    public static void show(){
        System.out.println("我可以被main調用");
    }
    public void show2(){
        System.out.println("我不是靜態方法");
    }

    public static void main(String[] args) {
        show();//直接調用
        System.out.println(age); //直接調用
        Test test = new Test();
        test.show2(); //創建對象調用
        System.out.println(test.name);//創建對象調用

    }
}
    • 如果在idea給main方法傳參數

 

代碼塊： 

  • 什麼是代碼塊？可以把它看成一個方法，可以在代碼塊中寫邏輯語句，但它沒有返回體，沒有方法名，就在一個花括弧中
  • 基本語法？[ 修飾符 ]{ 代碼 }; - 分號可寫可不寫　
    • 修飾符：只能是static或者不寫(有static的叫靜態代碼塊，沒有的叫普通代碼塊)
  • 案例：
  • class A{
    //靜態代碼塊，隨著類的載入而載入，只執行一次
    static{
        System.out.println("我是代碼塊A"); //2
    };
    //普通代碼塊，隨著對象實例的創建而載入，創建一個對象，執行一次
    {
        System.out.println("我是代碼塊B"); //3
    };
}

  • 細節(多看記住)：

    • 靜態代碼塊隨著類的載入而執行，只會執行一次
    • 普通代碼塊在創建對象時而執行，創建一個對象執行一次
    • 類的載入情況：
      1. 創建對象實例(new)
      2. 創建子類對象實例，父類也會被載入(沒父哪來的子)
      3. 使用類的靜態成員
    • public class Test {
    public static void main(String[] args) {
//        System.out.println(A.name); //輸出結果：1.把鍵盤敲爛 2.king
//        A a = new A();//輸出結果 1.把鍵盤敲爛 2.king 3.普普通通
        B b = new B();//輸出結果：1.把鍵盤敲爛 2.B代碼塊 3.普普通通
    }
}
class A{
    public static String name = "king";
    //靜態代碼塊隨著類的載入而執行，只會執行一次
    static{
        System.out.println("把鍵盤敲爛");
    };

    {
        System.out.println("普普通通");
    };
}
//創建子類對象實例，父類也會被載入
class B extends A{
    static{
        System.out.println("B代碼塊");
    }
}
    • 創建對象時，類中的調用順序：
      1. 先調用靜態代碼塊和靜態屬性的初始化
        1. 如果有多個靜態代碼塊和靜態屬性變數初始化，則按照定義順序執行，因為它們優先順序一樣
      2. 在調用普通代碼塊和普通屬性的初始化
        1. 如果有多個普通代碼塊和普通屬性初始化，則按照定義順序執行，因為它們優先順序一樣、
      3. 最後調用構造器方法
    • public class Test {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    public static String name = "show()"; //1
    public static int a = show(); //1
    public int b = show2(); //3

    public A(int b) {
        System.out.println("可憐的構造器被最後調用"); //5
    }

    static{
        System.out.println("把鍵盤敲爛"); //2
    };

    {
        System.out.println("普普通通"); //4
    };

    public static int show(){
        System.out.println("我是show");
        return 0;
    }
    public int show2(){
        System.out.println("我是show2");
        return 0;
    }
}
    • 構造器中 在預設隱藏了super( )和調用普通代碼塊 - 這是父子類都沒有靜態代碼塊或靜態屬性的執行流程
      • 理解：有繼承關係，就先執行完父類的才執行到自己的　　
    • public class Test {
    public static void main(String[] args) {
        B b = new B();
    }
}
class A{
    {
        System.out.println("A代碼塊");//1
    }
    public A() {
        //super()
        //調用本類代碼塊
        System.out.println("A無參構造");//2
    }
}
class B extends A{   
    {
        System.out.println("B代碼塊");//3
    }
    public B() {
        //super()
        //調用本類代碼塊
        System.out.println("B無參構造");//4
    }
}

    • 繼承關係：父類和子類都有靜態代碼和靜態屬性，普通代碼塊和普通屬性和構造器，類的執行流程是？：

      1. 執行父類的靜態代碼塊和靜態屬性(優先順序一樣，按順序執行)

      2. 執行子類的靜態代碼塊和靜態屬性(優先順序一樣，按順序執行)

      3. 執行父類的普通代碼塊和普通屬性(優先順序一樣，按順序執行)

      4. 執行父類的構造器方法

      5. 執行子類的普通代碼塊和普通屬性(優先順序一樣，按順序執行)

      6. 執行子類的構造器方法

    • public class Test {
    public static void main(String[] args) {
        new B02();//對象
    }
}
class A02 { //父類
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一個靜態代碼塊..");//(2)
    }
    {
        System.out.println("A02的第一個普通代碼塊..");//(5) 
    }
    public int n3 = getVal02();//普通屬性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1) 
        return 10;
    }
    public int getVal02() {
        System.out.println("getVal02");//(6) 
        return 10;
    }
    public A02() {//構造器
        //隱藏
        //super()
        //普通代碼和普通屬性的初始化......
        System.out.println("A02的構造器");//(7) 
    }
}
class B02 extends A02 { 
    private static int n3 = getVal03();
    static {
        System.out.println("B02的一個靜態代碼塊..");//(4) 
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一個普通代碼塊..");//(9)
    }
    public static int getVal03() {
        System.out.println("getVal03");//(3) 
        return 10;
    }
    public int getVal04() {
        System.out.println("getVal04");//(8) 
        return 10;
    }
    public B02() {//構造器
        //隱藏了
        //super()
        //普通代碼塊和普通屬性的初始化...
        System.out.println("B02的構造器");//(10)
        // TODO Auto-generated constructor stub
    }
}

單例設計模式：

  • 什麼是單例設計模式？    單個實例的意思，就是採取某些辦法讓類的實例對象只有一個(餓漢式-懶漢式，就是經典的單例模式)
    • 什麼是設計模式？ 在大量的實踐中總結出的代碼結構，編程風格，已經解決問題的思考方式

  • 餓漢式：

    • 什麼是餓漢式？ 類載入的時，就已經創建對象實例 - 十分著急
    • 餓漢式實現步驟：
      • 所有化構造器
      • 類的內部創建對象
      • 向外部暴露一個靜態的公共方法
    • public class Test {
    public static void main(String[] args) {
        King show = King.show();
        System.out.println(show);//com.Variable.King@1540e19d
        //類載入只載入一次
        King show2 = King.show();
        System.out.println(show);//com.Variable.King@1540e19d
    }
}
class King{
    private String name;
    private static King king = new King("jack");

    private King(String name) {
        System.out.println("構造器被調用");
        this.name = name;
    }

    public static King show(){
        return king;
    }
}
  • 懶漢式：
    • 什麼是懶漢式？ 需要到創建對象實例，才會創建 - 不著急
    • 懶漢是實現步驟，和餓漢是一樣，都是細節不一樣
    • public class Test {
    public static void main(String[] args) {
        Idler show = Idler.show();
        System.out.println(show);//com.Variable.Idler@1540e19d
        //類載入只載入一次
        Idler show2 = Idler.show();
        System.out.println(show);//com.Variable.Idler@1540e19d
    }
}
class Idler{
    private String name;
    private static Idler idler;

    private Idler(String name) {
        this.name = name;
    }

    public static Idler show(){
        if (idler == null){
            idler = new Idler("jack");
        }
        return idler;
    }
}

  • 餓漢式和懶漢式對比：

    • 兩種模式，都是為了對象的一個實例，只是創建時機不同
    • 餓漢式不存線上程安全問題，懶漢式存線上程安全問題
    • 餓漢式存在資源浪費問題，如果沒有使用到它但它創建對象實例了，就浪費了，懶漢式是使用時才創建，不存在該問題　　

final關鍵字：

    • 什麼是final關鍵字？ 表示最終的意思，可以用來修飾類、屬性、方法和局部變數
    • 使用場景？ - 總結：不希望本類被子類繼承
      • 不希望本類被子類繼承
      • 當類的屬性不希望被修改時
      • 當局部變數不希望本修改時
      • 當類的方法不需希望本子類覆蓋/重寫時
    • final class AA{
}
//當類不希望被繼承時，可以使用final修飾
class BB extends AA{}

class CC{

    private final String Name = "jack";
    public final void show(){
        //當類的某個屬性不希望被修改時，可以用final修飾
        Name = "king";

    }
    public void show2(){
        //當局部變數不希望被修改時，可以使用final修飾符
        final int i = 10;
    }
}

class DD extends CC{
    //當父類的方法不想被子類覆蓋/重寫
    @Override
    public void show() {
        super.show();
    }
}

  • 細節：

    • final修飾的屬性又叫常量，一般用什XX_XX_XX來命名
    • final修飾屬性時，必須賦值，標簽以後不能修改，賦值可以在下麵的其中一個：
      • 直接屬性賦值 如:public final int i = 10;
      • 構造器賦值
      • 代碼塊賦值　
    • final修飾屬性時，如果是靜態屬性，賦值可以在下麵其中一個：
      • 直接賦值
      • 靜態代碼塊
    • final不能被繼承，但可以本實例化
    • 類不是final類，但是含有final方法，則該方法雖然不能被覆蓋/重寫,但可以繼承
    • final不能修飾構造器
    • final和static搭配使用，效率更高，因為不會導致類的載入(底層編譯器做了優化)
    • 是final類了，就沒有必要將類中方法修飾為final方法(因為類不會本繼承，方法也不會被覆蓋/重寫)
    • 包裝類(Integer,Double,Float,Boolean等但是final)，String也是final類　
    • public class Test {
    public static void main(String[] args) {
        //final類不能繼承但能實例化對象
        CC cc = new CC();
        //不是final類，但是是方法是final方法，不可以本覆蓋/重寫,但可以本繼承
        EE ee = new EE();
        ee.show(); //被繼承的表示
        //用了final和static，不會導致類載入
        System.out.println(GG.i);
    }
}
class GG{
    public static final int i = 10;
    static {
        System.out.println("用了final和static，不會導致類載入");
    }
}

class FF{
    //final不能修改構造器方法
    public final FF() {
    }
}

final class CC{}

class DD{
    public final void show(){
        System.out.println("敲壞鍵盤");
    }
}

class EE extends DD{

}
//普通屬性賦值時
class AA{
    //1.直接都有時賦值
    public final double TAX_RATE;
    //2.構造器賦值
    public AA(){
        TAX_RATE = 99.99;
    }
    //3.代碼塊賦值
    {
        TAX_RATE = 66.66;
    }
}

//靜態屬性賦值時
class BB{
    //1.直接都有時賦值
    public static final double TAX_RATE = 88.88;
    //2.靜態代碼塊賦值
    static{
        TAX_RATE = 99.99;
    }
}

 抽象類：

  • 什麼是抽象類？當父類的某些方法，需要聲明，但不確定方法用來做什麼的時候，就可以用抽象，那麼方法就叫抽象方法，類就是抽象類、
    • 例：就是我的父類有一個方法，不知道具體用來做什麼，但是要聲明這個方法，然後用子類去基礎並實現該方法　　
  • 語法？方法：訪問修飾符 abstract 返回類型 方法保名(); - - 沒有方法體   類：abstract 類名{}; 
  • 抽象類的用途？抽象類的作用更多在於設計，設計者設計號後，讓子類繼承並實現。在框架和設計模式使用比較多
  • abstract class Employee{ //抽象類
    //抽象方法    
    public abstract void work();
}
class Manager extends Employee{
    //實現抽象方法
    @Override
    public void work() {
        System.out.println("經理/普通員工"+super.name+"工作中");
    }
}

  • 細節：

    • 抽象類不能本實例化(類載入可以)
    • 抽象類庫可以不包含abstract方法，就是抽象類可以沒有抽象方法
    • 類中又了抽象方法，該類就必須聲明為抽象類
    • abstract只能修飾類和方法，不能修飾屬性和其它
    • 抽象類可以又任意成員(抽象類還是類)　　　　　　　　　　　　　　　
    • 抽象方法不能有主體
    • 一個類繼承了抽象類就必須實現抽象方法，否則就把自己也聲明為抽象方法就不用實現了
    • 抽象類不能使用，static、find、private來修飾，這些關鍵字和重寫想違背
  • 重新類最佳實際 - 模板設計
    • 什麼是模板設計？把公共的區域提取出來封裝到一起
    • public class Test {
    public static void main(String[] args) {
        BB bb = new BB(); //繼承理所應當的calculateTime方法也繼承
        bb.calculateTime(); 

        CC cc = new CC();
        cc.calculateTime();
    }
}
abstract class AA{
    public abstract void obj();
    public void calculateTime(){
        long start = System.currentTimeMillis();
        obj(); //但調用到該方法時，動態綁定機制就上場了，會去看子類有沒有，有就調用
        long end = System.currentTimeMillis();
        System.out.println("總共耗時:"+(end-start));
    }

}
class BB extends AA{
    public void obj(){
        long k = 0;
        for (int i = 1; i <= 900000; i++) {
            k+=i;
        }
    }
}
class CC extends AA{
    public void obj(){
        long k = 0;
        for (int i = 1; i <= 900000; i++) {
            k+=i;
        }
    }
} 

介面：

  • 什麼是介面？1.介面是java單繼承的一種補充，2.介面規則了實現方法，實現介面的類必須實現方法
    • 例：1.小猴子只會爬樹-這是繼承老猴子的，小猴子學游泳是學魚的-這就是實現介面，單繼承補充
  • 語法：interface 介面名{....} -- 定義介面 ，class 類名 implements 介面名{....} -- 實現介面
  • 用途：定義規範例：我寫一個介面規則資料庫只能用統一的介面名實現，那麼不管連接什麼資料庫的方法名都得到了統一等等

  • 案例演示：

    • public interface Usb {
    int i = 10; //介面可以有屬性
    void show(); //抽象方法
}
class King implements Usb{
    int a = 20; //定義自己的屬性
    @Override
    public void show() { //實現介面中的抽象方法
        System.out.println(Usb.i); //獲取屬性
    }
    public void show2(){
        System.out.println("定義自己的方法");
    }
}

  • jdk7.0和jdk8.0介面的改變：

    • jdk7.0以前介面在是不能有預設方法和靜態方法
    • jdk8.0以後介面在是可以有預設方法和靜態方法
      • 預設方法需要加上default關鍵字
    • public interface Usb {
    void show();
    default public void show3(){
        System.out.println("jdk8以後可以寫普通屬性");
    }
    public static void show4(){
        System.out.println("jdk8以後可以寫靜態方法");
    }
}

  • 細節：

    • 介面不能實例化
    • 介面的寫的抽象方法是不用寫abstract關鍵字的
    • 介面中所有的方法是public方法，介面在抽象方法，可以不用abstract修飾
    • 普通類實現介面，必須將該介面的所有方法都實現
    • 抽象類實現介面，不用實現介面方法 - 因為介面的里的方法就是抽象方法
    • 一個類可以同時實現多個介面
    • 介面中的屬性只能是final的
    • //介面的修飾符只能是public和預設的，和了類的修飾符一樣
public interface Usb {
    //介面中的屬性只能是find
    int i = 10; //等價於 int final static i = 10；
    //不用abstract來修飾方法為抽象方法
    void connect();
    //介面中的方法都是public方法
    //private void interrupt();
    default void interrupt(){
        //介面的訪問通過介面名.屬性名
        System.out.println(Usb.i);
    }
}
//介面不能繼承其它類，但是可以繼承多個別的介面
interface Usb3 extends Usb{}
//一個類同時實現多個介面
class A_ implements Usb,Usb3{
    int a = 10;
    //一個普通類實現介面必須把介面方法都實現了
    //當然抽象類不用
    @Override
    public void connect() {
        System.out.println("連接Usb——A");
    }
    @Override
    public void interrupt() {
        System.out.println("連接Usb——A");
    }
}

  • 實現介面VS繼承類：

    • 問題？介面是讓實現它的類去實現它的抽象方法，繼承是讓它的子類去繼承它的屬性方法(遵守訪問修飾符)，感覺上是差不多，那實際是什麼樣
    • 繼承的價值：解決代碼的復用性和可維護性
    • 介面的價值：設計 - 設計好合作規範(方法)讓其它類去實現這些方法，比較靈活
    • 繼承需要滿足is-a的關係 - 就是小狗的繼承類必須是動物，是有保存聯繫的
    • 介面只需要滿足like-a的關係 - 就是小狗類但是我也可以去實現某個介面，如該介面中有游泳的方法，小狗就實現了游泳

  • 介面的多態：

    • 介面的多態和類的多態是一樣的父類可以接收所有子類，介面就是可以接收實現它的類
    •
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Python 實現Tracert追蹤TTL值
    Tracert 命令跟蹤路由原理是IP路由每經過一個路由節點TTL值會減一，假設TTL值=0時數據包還沒有到達目標主機，那麼該路由則會回覆給目標主機一個數據包不可達，由此我們就可以獲取到目標主機的IP地址，如下我們通過scapy構造一個路由追蹤工具並實現一次追蹤。 ...
  • Spring Cloud Consul 入門指引
    Spring @Transactional註解isolation屬性 @Transactional註解通過isolation屬性設置事務隔離級別。如下： @Transactional(isolation=Isolation.DEFAULT) public void method(){} isolat ...
  • Spring事務（三）-事務失效場景
    有時候，我們明明在類或者方法上添加了@Transactional註解，卻發現方法並沒有按事務處理。其實，以下場景會導致事務失效。 1、事務方法所在的類沒有載入到Spring IOC容器中。 @Transactional是Spring的註解，未被Spring管理的類中的方法不受@Transaction ...
  • Spring事務（二）-事務傳播行為
    Spring事務（二）-事務傳播行為 在Spring里，一個事務方法被另外一個事務方法調用時，兩個方法的事務應該如何進行，說白話一點，就是說當出現異常需要回滾時，各個方法的數據操作是否要全部回滾，事務傳播行為就是決定了這樣的一個處理結果。A事務方法（外部方法）調用了B事務方法（內部方法，又叫被調用方 ...
  • 深入理解AQS--jdk層面管程實現【管程詳解的補充】
    java.util.concurrent包中的大多數同步器實現都是圍繞著共同的基礎行為，比如等待隊列、條件隊列、獨占獲取、共用獲取等，而這些行為的抽象就是基於AbstractQueuedSynchronizer（簡稱AQS）實現的，AQS是一個抽象同步框架，可以用來實現一個依賴狀態的同步器 ...
  • ysoserial CommonsCollections1
    Lambda 表達式（lambda expression）是一個匿名函數，Lambda表達式基於數學中的λ演算得名，直接對應於其中的lambda抽象（lambda abstraction），即沒有函數名的函數。Lambda表達式可以表示閉包（註意和數學傳統意義上的不同）。 ...
  • ping命令的多種玩法，以前竟然只用它來測試網速！
    2022-10-05 得到cookie信息的實例聯繫： 在子應用中的“views.py”文件： from django.http import HttpResponse def get_cookie(request): cookies = request.COOKIES username = coo ...
  • 為什麼用Redis做排行榜？
    echarts是百度推出的一款開源的基於`JavaScript`的可視化圖表庫，該開發庫目前發展非常不錯，且支持各類圖形的繪製可定製程度高，Echarts繪圖庫同樣可以與`Flask`結合，前臺使用`echart`繪圖庫進行圖形的生成與展示，後臺則是Flask通過`render_template`方... ...
一周排行
    -Advertisement-
    Play Games
  • .net 6 C#中System.IO.Path類的用法
    1. 說明 /* Performs operations on System.String instances that contain file or directory path information. These operations are performed in a cross-pla ...
  • 使用WebApi+Vue3從0到1搭建《許可權管理系統》:二、搭建JWT系統鑒權
    視頻地址：【WebApi+Vue3從0到1搭建《許可權管理系統》系列視頻：搭建JWT系統鑒權-嗶哩嗶哩】 https://b23.tv/R6cOcDO qq群:801913255 一、在appsettings.json中設置鑒權屬性 /*jwt鑒權*/ "JwtSetting": { "Issuer" ...
  • 實戰指南：使用 xUnit 和 ASP.NET Core 進行集成測試【完整教程】
    引言 集成測試可在包含應用支持基礎結構（如資料庫、文件系統和網路）的級別上確保應用組件功能正常。 ASP.NET Core 通過將單元測試框架與測試 Web 主機和記憶體中測試伺服器結合使用來支持集成測試。 簡介 集成測試與單元測試相比，能夠在更廣泛的級別上評估應用的組件，確認多個組件一起工作以生成預 ...
  • .NET Emit 入門教程：第六部分：IL 指令：9：詳解 ILGenerator 指令方法：運算操作指令（指令篇結束）
    在.NET Emit編程中，我們探討了運算操作指令的重要性和應用。這些指令包括各種數學運算、位操作和比較操作，能夠在動態生成的代碼中實現對數據的處理和操作。通過這些指令，開發人員可以靈活地進行算術運算、邏輯運算和比較操作，從而實現各種複雜的演算法和邏輯......本篇之後，將進入第七部分：實戰項目 ...
  • WPF多表頭表格實現
    前言 多表頭表格是一個常見的業務需求，然而WPF中卻沒有預設實現這個功能，得益於WPF強大的控制項模板設計，我們可以通過修改控制項模板的方式自己實現它。 一、需求分析 下圖為一個典型的統計表格，統計1-12月的數據。 此時我們有一個需求，需要將月份按季度劃分，以便能夠直觀地看到季度統計數據，以下為該需求 ...
  • gRPC入門學習之旅（七）
    如何將 ASP.NET Core MVC 項目的視圖分離到另一個項目 在當下這個年代 SPA 已是主流，人們早已忘記了 MVC 以及 Razor 的故事。但是在某些場景下 SSR 還是有意想不到效果。比如某些靜態頁面，比如追求首屏載入速度的時候。最近在項目中回歸傳統效果還是不錯。 有的時候我們希望將 ...
  • System.AggregateException: 發生一個或多個錯誤.....
    System.AggregateException: 發生一個或多個錯誤。 > Microsoft.WebTools.Shared.Exceptions.WebToolsException: 生成失敗。檢查輸出視窗瞭解更多詳細信息。 內部異常堆棧跟蹤的結尾 > (內部異常 #0) Microsoft ...
  • 精通中間件測試：Asp.Net Core實戰指南，提升應用穩定性和可靠性
    引言 在上一章節我們實戰了在Asp.Net Core中的項目實戰，這一章節講解一下如何測試Asp.Net Core的中間件。 TestServer 還記得我們在集成測試中提供的TestServer嗎？ TestServer 是由 Microsoft.AspNetCore.TestHost 包提供的。 ...
  • Case表達式
    在發現結果為真的WHEN子句時,CASE表達式的真假值判斷會終止,剩餘的WHEN子句會被忽略: CASE WHEN col_1 IN ('a', 'b') THEN '第一' WHEN col_1 IN ('a') THEN '第二' ELSE '其他' END 註意: 統一各分支返回的數據類型. ...
  • 揭秘：C#語法中“_ =” 是什麼？
    在C#編程世界中，語法的精妙之處往往體現在那些看似微小卻極具影響力的符號與結構之中。其中，“_ =” 這一組合突然出現還真不知道什麼意思。本文將深入剖析“_ =” 的含義、工作原理及其在實際編程中的廣泛應用，揭示其作為C#語法奇兵的重要角色。 一、下劃線 _：神秘的棄元符號 下劃線 _ 在C#中並非 ...
所有分類