java基礎------函數與數組

来源:https://www.cnblogs.com/birdshdbn/archive/2018/10/06/9746441.html
-Advertisement-
Play Games

函數（方法） 定義：如果一個功能的代碼要被覆用起來，那麼這時候可以把這裡的功能代碼封裝起來，在java中把功能代碼封裝起來的是以函數的形式體現的。 函數的格式： 修飾符　返回值類型　函數名（形式參數.....）{ 需要被封裝的功能代碼； return 結果； } 例如： public static ...


函數（方法）

　　　　　　定義：如果一個功能的代碼要被覆用起來，那麼這時候可以把這裡的功能代碼封裝起來，在java中把功能代碼封裝起來的是以函數的形式體現的。

　　　　　　函數的格式：

　　　　　　　　　　修飾符　返回值類型　函數名（形式參數.....）{

　　　　　　　　　　　　　　需要被封裝的功能代碼；

　　　　　　　　　　　　　　return 結果；

　　　　　　　　　　　　　　　　}

　　　　　　例如：

　　　　　　　　　　public static int add（）{

　　　　　　　　　　　　　　int a=2；

　　　　　　　　　　　　　　int b=3；

　　　　　　　　　　　　　　return a+b；

　　　　　　　　　　　　　　}

　　　　　　分析函數：

　　　　　　　　　　修飾符：public static

　　　　　　　　　　返回值類型：int  返回值類型就是指函數運行完畢後，返回結果的數據類型。

　　　　　　　　　　　　　　　　註意： 某些函數是沒有結果返回給調用者的,那麼這時候返回值類型是void。

　　　　　　　　　　函數名：add

　　　　　　　　　　　　　　函數名的作用：如果需要調用該函數就需要使用的函數名。 函數名只要符合標識符的命名規則即可。 

　　　　　　　　　　　　　　函數名的命名規範： 首單詞全部小寫，其他單詞的首字母大寫，其他小寫。

　　　　　　　　　　形式參數： 如果一個函數在運行的時候，存在的數據是要調用者確定的，那麼這時候就應該定義形式參數。

　　　　　　　　　　return：把一個結果返回給調用者。

　　　　　　函數的作用：提高功能代碼的復用性

　　　　　　函數的特點：

　　　　　　　　　　1. 函數的作用就是把一個功能代碼給封裝起來，已達到提高功能代碼的復用性。

　　　　　　　　　　2.函數定義好之後是需要被調用才會執行的。其中main函數是由jvm調用的，不需要我們手動調用。

　　　　　　　　　　3.如果一個函數沒有返回值返回給調用者，那麼返回值類型必須是使用void表示。　

　　　　　　如何定義一個函數：
　　　　　　　　　　1. 返回值類型。
　　　　　　　　　　2. 是否存在未知的參數(是否存在要由調用者確定的參數)。---->形式參數

class Demo1
{
    public static void main(String[] args) 
    {
        //int max = getMax(14,5); //調用了需求1的函數，括弧內填寫的是實際參數，實際參數由調用者確定
        //System.out.println("最大值："+ max);//輸出需求1的結果 結果為14

        getMax(3,7);//調用了需求2的函數
    }    

/*
    //需求1： 定義一個函數比較兩個int類型的數據大小，把最大值返回給調用者。
    public static int  getMax(int a, int b){  // 形式參數
        int max = 0; //定義一個變數用於保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        return max;//把結果返回給調用者
    }
*/

    //需求2：定義一個函數比較兩個int類型的數據大小，不需要把最大值返回給調用者,直接列印即可。
    public static void getMax(int a, int b){
        int max = 0; //定義一個變數用於保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println("最大值："+ max);
    }

}
View Code 
class Demo2 
{
    public static void main(String[] args) {
        //String result = getGrade(91);//調用了需求1的函數，並把結果賦值給result
        //System.out.println(result);//輸出的結果為：A等級

        print(7);//調用了需求2的函數
    }

//需求1： 定義一個函數判斷一個分數的等級，把分數的等級返回給調用者。
    public static String getGrade(int score){
        String grade = "";    //定義一個變數存儲等級
        if(score>=90&&score<=100){
            grade = "A等級";
        }else if(score>=80&&score<=89){
            grade = "B等級";
        }else if(score>=70&&score<=79){
            grade = "C等級";
        }else if(score>=60&&score<=69){
            grade = "D等級";
        }else if(score>=0&&score<=59){
            grade = "E等級";
        }else{
            grade = "補考等級";
        }
        return grade;//把等級返回給調用者
    }

    //需求2： 定義一個函數列印一個乘法表，不需要返回任何數據。 
    public static void  print(int row){
        for(int i = 1 ; i<= row ; i++){
            for (int j = 1 ;j<=i  ;j++ ){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            //換行
            System.out.println();
        }
    }

}
View Code

　　　　　　註意： 如果一個函數的返回值類型是具體的數據類型，那麼該函數必須要保證在任意情況下都保證有返回值。（除了返回值類型是void以外）

class Demo3{
    public static void main(String[] args) 
    {
        String result = getGrade(10);//調用函數
        System.out.println("對應的等級是："+ result );
    }
    public static String getGrade(int score){//未知的參數定義在形參中，由函數的調用者確定。
        if(score>=90&&score<=100){
            return "A等級";
        }else if(score>=80&&score<=89){
            return "B等級";
        }else if(score>=70&&score<=79){
            return "C等級";
        }else if(score>=60&&score<=69){
            return "D等級";
        }else if(score>=0&&score<=59){
            return "E等級";
        }else{
            //如果一個函數的返回值類型是具體的數據類型，那麼該函數就必須要保證在任意情況下都保證有返回值。（除了返回值類型是void以外）
            return "補考等級";
        }
    }
}
View Code

　　　　　　return 關鍵字的作用：

　　　　　　　　　　1. 返回數據給函數的調用者。

　　　　　　　　　　2. 函數一旦執行到了return關鍵字，那麼該函數馬上結束。 (能結束一個函數)

　　　　　　註意：如果一個函數的返回值類型是void，那麼也可以出現return關鍵字，但是return關鍵字的後面不能有數據。

　　　　　　break關鍵字與return關鍵字的區別：

　　　　　　　　　　1.break關鍵字是結束一個迴圈。

　　　　　　　　　　2. return關鍵字是結束一個函數。

　　　　　　函數的重載：在一個類中出現兩個或者兩個以上的同名函數，這個稱作為函數的重載。

　　　　　　函數重載的要求：

　　　　　　　　　　1. 函數名一致。

　　　　　　　　　　2. 形參列表不一致。（形式參數的個數或者是對應的數據類型不一致）

　　　　　　　　　　3. 與函數的返回值類型是無關的。

　　　　　　函數重載的作用： 同一個函數名可以出現不同的函數，以應對不同個數或者不同數據類型的參數。

class Demo4 {
    public static void main(String[] args) {
        add1(1,2);//調用了含有兩個參數的函數
        add(1,2.0);//調用了含有三個參數的函數
    }

        // 一下兩個函數都是以函數重載在做加法運算。
    public static double add(int a, int b){
        System.out.println("兩個參數的總和: "+ (a+b));
        return 3.14;
    }

    public static void add(int a , int b , int c){
        System.out.println("三個參數的總和: "+ (a+b+c));
    }

}
View Code

數組

　　　　　　定義：數組是存儲同一種數據類型數據的集合容器。

　　　　　　數組的定義格式：

　　　　　　　　　　數據類型[]  變數名 = new 數據類型[長度];

　　　　　　分析數組:

　　　　　　　　　　左邊： int[] arr    聲明瞭一個int類型的的數組變數，變數名為arr。

　　　　　　　　　　　　　　int : 表示該數組容器只能存儲int類型的數據。

　　　　　　　　　　　　　　[] ： 這是一個數組類型。

　　　　　　　　　　　　　　arr ： 變數名。

　　　　　　　　　　右邊：new int[50]　創建了一個長度為50的int類型數組對象。

　　　　　　　　　　　　　　new ： 創建數組對象的關鍵字。

　　　　　　　　　　　　　　int：表示該數組對象只能存儲int類型數據。

　　　　　　　　　　　　　　[]： 表示是數組類型。

　　　　　　　　　　　　　　50 : 該數組最多能存儲50個數據。數組的容量。

　　　　　　數組的好處： 對分配到數組對象中的每一個數據都能夠分配到一個索引值（編號、角標、下標）,索引值的範圍是從0開始，最大是： 長度-1。

　　　　　　局部變數： 如果一個變數是在一個函數（方法）的內部聲明的，那麼該變數就是一個局部變數。

　　　　　　成員變數： 成員變數就是定義在方法之外，類之內的.

class Demo5 {
    public static void main(String[] args) 
    {
        //定義一個數組
        int[] arr = new int[4];
        arr[0] = 10;
        arr[1] = 30;
        arr[2] = 50;
        arr[3] = 90; 
        
        //System.out.println("數組的容量："+ arr.length);    //數組裡有一個length 的屬性，可以查看數組的容量。
        //System.out.println("arr[2] = "+ arr[2]);//查看索引值為2的數組的值    結果為：50
        
        //查看數組中的所有數據。
        for(int index = 0 ; index<arr.length ; index++){
            System.out.println(arr[index]);
        }
    }
}
View Code

　　　　　　數組的記憶體分析圖：

　　　　　　數組中常見的問題：

　　　　　　　　　　1. NullPointerException 空指針異常

　　　　　　　　　　原因： 引用類型變數沒有指向任何對象，而訪問了對象的屬性或者是調用了對象的方法。

　　　　　　　　　　2. ArrayIndexOutOfBoundsException 索引值越界。

　　　　　　　　　　原因：訪問了不存在的索引值。

　　　　　　數組的初始方式：

　　　　　　　　　　動態初始化：數據類型[] 變數名 = new 數據類型[長度]；

　　　　　　　　　　靜態初始化：數據類型[] 變數名 = {元素1，元素2.....}；

　　　　　　如果程式一開始你就已經確定了數據，那麼這時候建議使用靜態初始化。如果一開始數據還不太明確，這時候就建議使用動態初始化。

class Demo6{
    public static void main(String[] args) 
    {    
            /*
        //動態初始化
        int[] arr = new int[10];
        Scanner scanner = new Scanner(System.in);//創建掃描器對象
        for(int i  = 0 ; i< arr.length ; i++){
            arr[i] = scanner.nextInt();//調用掃描器的nextInt()掃描數據，並把數據賦值於數組中
        }
        */

        //靜態初始化
        int[] arr = {10,20,30,40,50};
                //查看數組的所有數據
        for(int index = 0 ; index<arr.length ; index++){
             System.out.print(arr[index]+",");
        }


    
    }
}
View Code 
/*
    需求： 定義一個函數接收一個int類型的數組對象，找出數組對象中的最大元素並返回給調用者。
*/
class Demo7 {
    public static void main(String[] args) 
    {
        int[] arr = {-12,-14,-5,-26,-4};//靜態初始化
        int max = getMax(arr);
        System.out.println("最大值："+ max); //結果為：-4
    }

    public static int  getMax(int[] arr){
        int max = arr[0]; //用於記錄最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果發現有元素比max大，那麼max變數就記錄該元素。
                max = arr[i];
            }
        }
        return max;//把max的值返回給調用者
    }
}
View Code

　　　　　　數組常見的操作：

　　　　　　　　　　選擇排序(直接排序)：使用一個元素與其他的元素挨個比較一次，符合條件交換位置。

　　　　　　　　　　需求： 定義一個函數接收一個int類型的數組對象, 把數組中的最大值放在數組中的第一位。

class Demo8{
    public static void main(String[] args) 
    {
        int[] arr = {12,5,17,8,9};  //對於有5個元素的數組，只需要找出4個最大值就可以排序了。
        selectSort(arr);
    }

    public static void selectSort(int[] arr){
        
        //對以下註釋的代碼進行優化
        for(int j = 0; j<arr.length-1; j++){  //  控制的是輪數。
            for(int i = j+1 ; i<arr.length ; i++){ //控制的是每次找出的最大值
                if(arr[i]>arr[j]){
                    //交換位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        

/*
                //把老大放在第一個位置
                for(int i=1;i<arr.length;i++）{
                       if(arr[i]>arr[0]){
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;
            }
                 }
                
        //把老二放在第二個位置
        for(int i = 2  ; i< arr.length ; i++){
            if(arr[i]>arr[1]){
                int temp = arr[i];
                arr[i] = arr[1];
                arr[1] = temp;
            }
        }
        

        //把老三放在第三個位置
        for(int i = 3  ; i< arr.length ; i++){
            if(arr[i]>arr[2]){
                int temp = arr[i];
                arr[i] = arr[2];
                arr[2] = temp;
            }
        }

        //把老四放在第四個位置
        for(int i = 4  ; i< arr.length ; i++){
            if(arr[i]>arr[3]){
                int temp = arr[i];
                arr[i] = arr[3];
                arr[3] = temp;
            }
        }

*/

        //遍曆數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }
    }
}
View Code

　　　　　　　　　　冒泡排序：冒泡排序的思想就是使用相鄰的兩個元素挨個比較一次，符合條件交換位置。

　　　　　　　　　　需求： 定義一個函數接收一個int類型的數組對象, 把數組中的最大值放在數組中的最後一位。

class Demo9 {
    public static void main(String[] args) 
    {
        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
         bubbleSort(arr);
    }


    public static void bubbleSort(int[] arr){
        //對以下註釋的代碼進行優化
        for(int j = 0 ; j<arr.length-1 ; j++){ //控制輪數
            for(int i = 0 ; i<arr.length-1-j  ; i++){  //控制找出一個最大值  
                //相鄰的元素比較
                if(arr[i]>arr[i+1]){
                    int temp  = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

/*
                // 把最大值放在最後一個位置
            for(int i = 0 ;  i <arr.length-1-0 ; i++){
                if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老二放在倒數第二個位置上。
        for(int i = 0 ;  i <arr.length-1-1 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老三放在倒數第三個位置上。
        for(int i = 0 ;  i <arr.length-1-2 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老四放在倒數第四個位置上。
        for(int i = 0 ;  i <arr.length-1-3 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

*/

        //遍曆數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length; i++){
            System.out.print(arr[i]+",");
        }
    }
}
View Code

　　　　　　　　　　二分查找法：定義三個變數分別記錄要查找元素的範圍最大索引值、中間索引值、最小索引值，每次都是使用中間索引值的元素與目標元素比較一次，如果不是我們所需要的元素，那麼縮小查找的範圍。

　　　　　　　　　　註意：使用二分查找法的前提必須是有序的數組。

　　　　　　　　　　需求：定義一個函數接收一個數組對象和一個要查找的目標元素，函數要返回該目標元素在數組中的索引值，如果目標元素不存在數組中，那麼返回-1表示。

class Demo10 {
    public static void main(String[] args) 
    {
        int[] arr = {12,16,19,23,54};
        //int index = searchEle(arr,23);//調用searchEle（），但是效率低
        int index = halfSearch(arr,116);
        System.out.println("元素所在的索引值是："+ index);
    }
    
        
    public static int halfSearch(int[] arr, int target){
        //定義三個變數分別記錄最大、最小、中間的查找範圍索引值
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while(true){
            if(target>arr[mid]){
                min = mid+1;
            }else if(target<arr[mid]){
                max = mid -1;
            }else{
                //找到了元素
                return mid;
            }

            //沒有找到的情況
            if (max<min){
                return -1;
            }

            //重新計算中間索引值
            mid = (min+max)/2;
        }
    
    }
/*
    public static int searchEle(int[] arr, int target){
        for(int i = 0 ; i<arr.length ; i++){
            if(arr[i]==target){
                return i;
            }
        }
        return -1;
    }
*/
}
View Code 
/*
需求： 定義 一個函數接收一個char類型的數組對象,然後翻轉數組中的元素。    
例如：char[] arr = {'a','b','c','d','e'};翻轉元素後的結果為e、d、c、b、a
*/
class Demo11{
    public static void main(String[] args){
        char[] arr = {'a','b','c','d','e'};
        reverse(arr);
    }

    public static void reverse(char[] arr){
        for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
            char temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }

        //遍曆數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }
}
View Code

 　　　　　　二維數組：二維數組就是數組中的數組。

　　　　　　二維數組的定義格式：數據類型[][] 變數名 = new 數據類型[長度1][長度2]；

　　　　　　二維數組的初始化方式：

　　　　　　　　　　動態初始化：數據類型[][] 變數名 = new 數據類型[長度1][長度2]；

　　　　　　　　　　靜態初始化：數據類型[][]  變數名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}；

　　　　　　二維數組的記憶體分析圖：

　　　　　　數組的特點：

　　　　　　　　　　1. 數組只能存儲同一種數據類型的數據。

　　　　　　　　　　2. 數組是會給存儲到數組中的元素分配一個索引值的，索引值從0開始，最大的索引值是length-1；

　　　　　　　　　　3. 數組一旦初始化，長度固定。

　　　　　　　　　　4. 數組中的元素與元素之間的記憶體地址是連續的。

class Demo12{
    public static void main(String[] args) 
    {    
        //定義了一個二維數組
        int[][] arr = new int[3][4];
        arr[1][1] = 100;
        /*
        System.out.println("二維數組的長度："+ arr.length);  //長度為3
        System.out.println("二維數組的長度："+ arr[1].length); //長度為4
        */
        System.out.println("數組的元素："+ arr[1][1]);結果為100
        
    }
}
View Code

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 淺淡 RxJS WebSocket
    ```const open$ = new Subject(); const ws = webSocket({ url: 'wss://echo.websocket.org', openObserver: open$ }); // 訂閱打開事件 open$.subscribe(() => {});``... ...
  • web基礎筆記
    web基礎筆記 1.首行縮進：text-indent 單位有兩種：em 字元 、 px 像素 2.字母間距或文字間距：letter-spacing 單詞間距：word-spacing 3.margin 兩個問題： （1） 當大盒子里放小盒子，給小盒子加margin-top時，小盒子會帶著大盒子一起向 ...
  • 精讀《12 個評估 JS 庫你需要關心的事》
    1 引言 作者給出了從 12 個角度全面分析 JS 庫的可用性，分別是： 特性。 穩定性。 性能。 包生態。 社區。 學習曲線。 文檔。 工具。 發展歷史。 團隊。 相容性。 趨勢。 下麵總結一下作者的觀點。 2 概述 & 精讀 特性 當你調研一個 JS 庫，功能當然是最重要的，就好比 Re ...
  • 野生前端的數據結構基礎練習（3）——鏈表
    網上的相關教程非常多，基礎知識自行搜索即可。 習題主要選自Orelly出版的《數據結構與演算法javascript描述》一書。 參考代碼可見: "https://github.com/dashnowords/blogs/tree/master/Structure/List" 鏈表的基本知識 特點： 鏈 ...
  • react-native 在新版Xcode（10+）中運行出現的問題： node_modules/react-native/third-party/glog-0.3.4 , C compiler cannot create executables
    報錯： github 問題地址 https://github.com/facebook/react-native/issues/19774 如果是因為下載了新的插件或者遷移項目導致構建出現這種問題在項目根目錄下運行： 1 cd ./node_modules/react-native/third-pa ...
  • 面向切麵編程(AOP)
    結合設計模式,通過代碼理解面向切麵編程，有代碼的很好理解的，5分鐘可以看三遍 通過,結構型設計模式，裝飾器模式來實現AOP，代碼如下 通過,結構型設計模式，代理模式來實現AOP，代碼如下 通過Unity實現AOP,配置太複雜就不貼了。。。就一個實現類的代碼,可以用於添加方法的日誌,異常處理,不用修改 ...
  • 設計模式分類(轉)23種設計模式分3大類
    有效內容不超過100字，總共200字，非常建議閱讀！！！ 設計模式被稱之為程式開發、系統設計、代碼優化必備之良品，老少咸宜！那究竟什麼是設計模式呢？其實設計模式就是在面向對象語言開發過程中， 遇到的種種場景和問題，提出的解決方案和思路，沉澱下來就是設計模式了！其實設計模式也就是套路，解決問題的套路。 ...
  • JSTL核心標簽庫
    1.<c:set/>給域對象賦值 2.<c:out/>獲取域對象的數據 3.<c:if/>單條件判斷 test:條件表達式。返貨true的時候，就會執行if標簽體的內容，否則不執行。 4.<c:choose/>+<c:when/>+<c:otherwise/>多條件判斷 5.<c:forEach/> ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類