OOP前三次作業總結BLOG

来源:https://www.cnblogs.com/bfanlaosiji/archive/2023/03/26/17244303.html
-Advertisement-
Play Games

代理模式（Proxy Pattern）是一種結構型設計模式，結構型模式描述如何將類或對象按某種佈局組成更大的結構。它允許你提供一個代理對象來控制對另一個對象的訪問。代理對象擁有與實際對象相同的介面，因此它可以被用來代替實際對象。 ...


 

OOP 1-3次作業總結

22201303-範宇

前言

  第一次BLOG，對第一階段的學習總結。

　　前三次題目集總體上更偏向於JAVA語法上的訓練，第二次與第三次題目集中的後兩道需要一點邏輯思維。題量我個人認為適中，整體難度我認為恰到好處，就是那種需要一定時間思考，但又不至於難到完成不了。

設計與分析

  • 題目集一：7-7 有重覆的數據

　　題目集一：7-7 有重覆的數據，讀入數據，檢查是否有重覆的數據。如果有，輸出“YES”這三個字母；如果沒有，則輸出“NO”。你的程式首先會讀到一個正整數n,n∈[1,100000]，然後是n個整數。

如果這些整數中存在重覆的，就輸出：

YES
 

否則，就輸出：

NO
import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
	    int n=input.nextInt();
        int [] num=new int[n];
            for(int i=0;i<n;i++){
                num[i]=input.nextInt();
            }
        Arrays.sort(num);
        int i;
        for(i=0;i<n-1;i++){
            if(num[i]==num[i+1]){
                 System.out.println("YES");
                 break;
            }
        }
        i++;
        if(i==n)
            System.out.println("NO");
//         int i;
//         loop:
//         for(i=0;i<n;i++){
//             for(int j=n-1;j>i;j--){
//                 if(num[i]==num[j]){
//                     System.out.println("YES");
//                     break loop;
//                 }
//             }
//         }
//             if(i==n)
//                 System.out.println("NO");

        
    }
}

 

這道題的整體思路就是先排序，再遍曆數組，判斷前一個元素與後一個元素是否相等，如果是，則重覆，如果全部遍歷完（也就是i==n時），則說明沒有重覆。這道題的重點在於當n為最大值時，這一測試點非常容易超時，之前用了雙重for迴圈和ArrayList兩種方法，都沒有通過最大n這個測試點，在多次嘗試下，最後發現了這個先排序的方法；後面還遇到了相似的題目，使用Set也是可行的；

  • 題目集二：7-8 判斷三角形類型

題目集二：7-8 判斷三角形類型，輸入三角形三條邊，判斷該三角形為什麼類型的三角形。

（1）如果輸入數據非法，則輸出“Wrong Format”；
（2）如果輸入數據合法，但三條邊不能構成三角形，則輸出“Not a triangle”；
（3）如果輸入數據合法且能夠成等邊三角形，則輸出“Equilateral triangle”；
（3）如果輸入數據合法且能夠成等腰直角三角形，則輸出“Isosceles right-angled triangle”；
（5）如果輸入數據合法且能夠成等腰三角形，則輸出“Isosceles triangle”；
（6）如果輸入數據合法且能夠成直角三角形，則輸出“Right-angled triangle”；
（7）如果輸入數據合法且能夠成一般三角形，則輸出“General triangle”。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        double a=input.nextDouble();
        double b=input.nextDouble();
        double c=input.nextDouble();
        if(a<1||a>200||b<1||b>200||c<1||c>200)
            System.out.print("Wrong Format");
        else{
            double t;
            if(a<b){
                t=a;
                a=b;
                b=t;
            }
            if(a<c){
                t=a;
                a=c;
                c=t;
            }
            if(b<c){
                t=b;
                b=c;
                c=t;
            }
            if((b+c)<=a)
                System.out.print("Not a triangle");
            else if(a==b&&b==c)
                System.out.print("Equilateral triangle");
            else if(b==c&&(2*b*b-a*a)*(2*b*b-a*a)<0.00001*0.00001)
                System.out.print("Isosceles right-angled triangle");
            else if((b==c)||(b==a))
                System.out.print("Isosceles triangle");
            else if(b*b+c*c==a*a)
                System.out.print("Right-angled triangle");
            else
                System.out.print("General triangle");
        }
    }
}

這道題我先將三邊按大小排序，再利用三角形構成的條件（即，兩邊之和大於第三邊）來判斷三角形是否可以構成，最後通過三邊關係判斷三角形的種類，其中用到了勾股定理（這裡就可能涉及到無理數，而無理數在電腦中的運算是存在誤差的，所以這種情況下判斷條件需要把誤差範圍考慮進去）。

  • 題目集二：7-9 求下一天

題目集二：7-9 求下一天，輸入年月日的值（均為整型數），輸出該日期的下一天。

  1. 當輸入數據非法及輸入日期不存在時，輸出“Wrong Format”；
  2. 當輸入日期合法，輸出下一天，格式如下：Next date is:年-月-日
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int year=input.nextInt();
        int month=input.nextInt();
        int day=input.nextInt();
        Main in=new Main();
        if(year<1820||year>2020||month<1||month>12||day<1||day>31)
            System.out.print("Wrong Format");
        else{
            if(checkInputValidity(year,month,day)){
                in.nextDate(year,month,day);
            }
            else
                System.out.print("Wrong Format");
        }
    }
    public static boolean isLeapYear(int year){
        if(year%4==0&&year%100!=0||year%400==0)
            return true;
        else
            return false;
    }
    public static boolean checkInputValidity(int year,int month,int day){
        if(isLeapYear(year)){
            if(month==2&&day>29)
                return false;
        }
        else{
            if(month==2&&day>28)
                return false;
        }
        if(month==4||month==6||month==9||month==11){
                if(day>30)
                    return false;
            }
        return true;
    }
    public static void nextDate(int year,int month,int day){
        day++;
                if(month==4||month==6||month==9||month==11){
                    if(day>30){
                        month++;
                        day=1;
                        
                    }
                }
                if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
                    if(day>31){
                        month++;
                        day=1;
                        if(month>12){
                            year++;
                            month=1;
                        }
                    }
                }
                if(month==2){
                    if(isLeapYear(year)){
                        if(day>29){
                            month++;
                            day=1;
                            
                        }
                    }
                    else{
                        if(day>28){
                            month++;
                            day=1;
                            
                        }
                    }
                    
                }
        System.out.print("Next date is:"+year+"-"+month+"-"+day);
    }
}

這道題需要先根據題目給出的條件判斷輸入日期是否合法，然後再求下一天的日期，這裡需要考慮到這一天是否達到這一月的最後一天，以及這一月共有多少天，如果是二月份還需要是否是閏年，如果是閏年則二月份有29天；否則有28天，考慮完了月份還需要考慮年份，要考慮這一天是否是這一年的最後一天，如果是，則下一天日期變為一月一日，年份加一；

當時寫這道題的時候對JAVA語法方面的內容還不是很熟悉，現在看來完全可以用數組(int[] mon_maxnum={0,31,28,31,30,31,30,31,31,30,31,30,31})來取代冗長的if里的條件；

  • 題目集三：7-3 定義日期類

題目集三：7-3 定義日期類，要求我們定義一個類Date(Date類結構如下圖所示)

  1. 當輸入數據非法及輸入日期不存在時，輸出“Date Format is Wrong”；
  2. 當輸入日期合法，輸出下一天，格式如下：Next day is:年-月-日；
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int year = input.nextInt();
        int month = input.nextInt();
        int day = input.nextInt();
        Date date1 = new Date(year,month,day);
        if(date1.checkInputValidity()){
            date1.getNextDate();
            System.out.println("Next day is:"+date1.getYear()+"-"+date1.getMonth()+"-"+date1.getDay());
        }
        else
            System.out.println("Date Format is Wrong");
            
    }
}

class Date{
    private int year;
    private int month;
    private int day;
    private int[] mon_maxnum={0,31,28,31,30,31,30,31,31,30,31,30,31};
    
    Date(){
    }
    
    Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    
    public int getYear(){
        return year;
    }
    
    public void setyear(int year){
        this.year=year;
    }
    
    public int getMonth(){
        return month;
    }
    
    public void setMonth(int month){
        this.month=month;
    }
    
    public int getDay(){
        return day;
    }
    
    public void getDay(int day){
        this.day=day;
    }
    
    public boolean isLeapYear(int year){
        if(year%4==0&&year%100!=0||year%400==0)
            return true;
        else
            return false;
    }
    
    public boolean checkInputValidity(){
        if(isLeapYear(this.year)){
            mon_maxnum[2]=29;
        }
        else{
            mon_maxnum[2]=28;
        }
        if(this.year>=1900&&this.year<=2000&&month>=1&&month<=12&&day>=1&&day<=mon_maxnum[month])
            return true;
        else
            return false;
    }
    
    public void getNextDate(){
        this.day++;
        if(this.day>mon_maxnum[this.month]){
            this.month++;
            this.day=1;
        }
        if(this.month>12){
            this.month=1;
            this.year++;
        }
    }
}

這道題我是一遍過的，畢竟計算量不大，僅僅只是下一天，需要考慮到這一天是否是這個月的最後一天，如果是，則下一天為下個月的第一天，還需要考慮到這個月是否是12月，如果是既12月又是最後一天，則下一天為下一年的1月1日。然後就是細節上的考慮，這裡主要體現在對閏年的判斷，對這道題來講，因為只求下一天，所以只需考慮是否有2月29日。

  • 　　題目集三：7-4 日期類設計，要求參考7-3設計一個DateUtil，該類有三個私有屬性year、month、day（均為整型數），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31]，設計類圖如下： 

　　功能實現：

  1. 求下n天
  2. 求前n天
  3. 求兩個日期相差的天數
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int year = 0;
        int month = 0;
        int day = 0;

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() + 
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }        
    }
}

class DateUtil{
    private int year;
    private int month;
    private int day;
    private int[] mon_maxnum={0,31,28,31,30,31,30,31,31,30,31,30,31};
    
    DateUtil(){
    }
    
    DateUtil(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    
    public int getYear(){
        return year;
    }
    
    public void setyear(int year){
        this.year=year;
    }
    
    public int getMonth(){
        return month;
    }
    
    public void setMonth(int month){
        this.month=month;
    }
    
    public int getDay(){
        return day;
    }
    
    public void getDay(int day){
        this.day=day;
    }
    
    public boolean isLeapYear(int year){
        if(year%4==0&&year%100!=0||year%400==0)
            return true;
        else
            return false;
    }
    
    public boolean checkInputValidity(){
        if(isLeapYear(this.year)){
            mon_maxnum[2]=29;
        }
        else{
            mon_maxnum[2]=28;
        }
        if(this.year>=1820&&this.year<=2020&&month>=1&&month<=12&&day>=1&&day<=mon_maxnum[month])
            return true;
        else
            return false;
    }
    
    public DateUtil getNextNDays(int n){
        //this.day=this.day+n;
        while(n>mon_maxnum[this.month]){
            if(isLeapYear(this.year)){
                mon_maxnum[2]=29;
            }
            else{
                mon_maxnum[2]=28;
            }
            n=n-mon_maxnum[this.month];
            this.month++;
            if(this.month>12){
                this.month=this.month-12;
                this.year++;
            }
            
        }
        this.day=this.day+n;
        if(this.day>mon_maxnum[this.month]){
            this.day=this.day-mon_maxnum[this.month];
            this.month++;
            if(this.month>12){
                this.month=this.month-12;
                this.year++;
            }
        }
        return new DateUtil(year,month,day);
    }
    
    public DateUtil getPreviousNDays(int n){
        this.day=this.day-n;
        while(this.day<=0){
            if(isLeapYear(this.year)){
                mon_maxnum[2]=29;
            }
            else{
                mon_maxnum[2]=28;
            }
            this.month--;
            if(this.month==0){
                this.year--;
                this.month=this.month+12;
            }
            this.day=mon_maxnum[this.month]+this.day;
        }
       return new DateUtil(year,month,day);
    }
    
    public boolean compareDates(DateUtil date){
        if(this.year>date.getYear())
            return true;
        else if(this.year==date.getYear()){
            if(this.month>date.getMonth())
                return true;
            else if(this.month==date.getMonth()){
                if(this.day>date.getDay())
                    return true;
                else if(this.day==date.getDay()){
                    return true;
                }else
                    return false;
            }else
                return false;
        }else
            return false;
    }
    
    public boolean equalTwoDates(DateUtil date){
        if(this.year==date.getYear()&&this.month==date.getMonth()&&this.day==date.getDay())
            return true;
        else
            return false;
    }
    
    public int getDaysofDates(DateUtil date){
        int n=0;
        n=n+mon_maxnum[this.month]-this.day;
        for(int i=1;this.month+i<13;i++){
            n=n+mon_maxnum[this.month+i];
        }
            while(this.year!=date.getYear()){
                if(this.year<date.getYear())
                    this.year++;
                else
                    this.year--;
                if(this.year==date.getYear())
                    break;
                if(isLeapYear(this.year))
                    n=n+366;
                else
                    n=n+365;
            }
        
             for(int i=1;i<date.getMonth();i++){
                n=n+mon_maxnum[i];
            }
            n=n+date.getDay();
        return n;
    }
    
    public String showDate(){
        String date="";
        date=year+"-"+month+"-"+day;
        return date;
    }
}

 

 這一題相當於是上一題的進階版，在上一題的基礎上改進，實現了求後n天的日期、前n天的日期和兩個日期間相距多少天。我實現getDaysofDates方法的主要思想是：使第一個日期不斷向第二個日期靠近，直至相等，同時用n不斷加上相應增加的天數，這裡重點在於日期的合法變化，要分月份和年份兩個條件討論；而實現getNextNDays、getPreviousNDays方法的主要思想是：n為天數，使n減少多少天，日期就相應增加多少天，直至n減少至0，而重點就在日期增加上，因為每個月的最大值不固定，每一年也不一定固定，所以這裡就需要細心分析，分類討論，判斷這一年是否是閏年，判斷這一月最大有多少天，進而來決定日期增加多少，n減少多少才能使日期合法增加。

踩坑心得

  1. 在題目集二：7-8 判斷三角形類型中，在判斷等腰直角三角形時，因為涉及到了無理數，所以數據運算一定存在一個誤差無法消除 if(b==c&&(2*b*b-a*a)==0)，之後規定當誤差小於一個值時即為相等 if(b==c&&(2*b*b-a*a)*(2*b*b-a*a)<0.00001*0.00001)，這才解決；
  2. 在題目集二：7-9 求下一天中，需要調取固定數值時，使用數組工具會更方便；
  3. 題目集三：7-4 日期類設計，這題中有個最大n值測試點花了很長時間才通過，這類測試點一般情況下是最容易被卡住的地方，這道題剛開始使一個正數加上n，所以導致超出了整型範圍，後面把它改在後面加，才成功；可更多情況下是一些題目需要遍曆數組或者列表（需要使用一個嵌套的雙重for迴圈），這種情況下更容易超出範圍，而且還不好解決，目前我能想到的就是如果需要排序，就使用現成的sort方法，如果要判斷重覆，可以使用Set來輔助判斷; 
    public DateUtil getNextNDays(int n){
        //this.day=this.day+n;這個是之前的錯誤
        while(n>mon_maxnum[this.month]){
            if(isLeapYear(this.year)){
                mon_maxnum[2]=29;
            }
            else{
                mon_maxnum[2]=28;
            }
            n=n-mon_maxnum[this.month];
            this.month++;
            if(this.month>12){
                this.month=this.month-12;
                this.year++;
            }
            
        }
        this.day=this.day+n;
        if(this.day>mon_maxnum[this.month]){
            this.day=this.day-mon_maxnum[this.month];
            this.month++;
            if(this.month>12){
                this.month=this.month-12;
                this.year++;
            }
        }
        return new DateUtil(year,month,day);
    }
  4. 在很多題目中，由於C語言習慣用System.out.printf()輸出，可往往這樣都通不過測試點，只能使用System.out.print()或System.out.println()，下麵是三者的一些區別：print為一般輸出，同樣不能保留精度格式轉化，也不能換行輸出; printf常用於格式轉換，但需要註意不是換行輸出，只用於精度轉換; println為換行輸出，不能用於格式化輸出；                  
  5. 基本類型轉換，有時候題目規定只能是單精度型或者只能是雙精度型的數據結果才能通過測試點float w1=(float)(w/0.45359237)；
  6. 誤差判斷時，大部分情況下要加一個平方，因為誤差不僅是一個向左或向右的區間，誤差是一個既向左又向右的區間，如while((g-m)>=0.00001)while((g-m)>=0.00001||(m-g)>=0.00001)；
  7. 在題目集一：7-7 有重覆的數據中，遇到了超時的問題，當時與其他同學討論發現，使用ArrayList類進行排序，再遍歷依舊超時，而使用Arrays類進行排序則不會超時，後面在查閱資料時發現，ArrayList是Array的複雜版本，ArrayList比Arrays的方法更多，功能更豐富，可以理解為Arrays是靜態數組，而ArrayList是動態數組，而Sort 方法是在內部數組的基礎上直接調用 Array 的對應方法，所以通常情況下：ArrayList的排序會比Arrays的排序時間要長；

     

改進建議

  1. 善用數組，在題目集二：7-9 求下一天中，使用數組來存儲12個月的最大天數，對m進行判斷時再通過數組下標來找出月份對應的天數，這會更加方便，而且易懂；
  2. 規範命名，儘可能寫出英文全稱，增加代碼可讀性；
  3. 多瞭解一些類的使用，比如String類，Arrays類，ArrayList類；
  4. 學習JAVA異常處理的相關內容，取代if判斷；

總結

  三次題目集的訓練，使我從零開始入門JAVA這門編程語言，使我對JAVA有了一個初步的瞭解，同時也對面對對象程式設計有了一個初步認識。面對對象程式設計與上學期的C語言（面向過程程式設計）不同，面向過程程式設計從邏輯上來看感覺更直接，而面向對象程式設計感覺更加抽象，更易於模塊化。面向對象程式設計里，數據和數據上的操作是分離的，也就是對象和控制對象的方法，JAVA里的模塊化主要體現在類上，類是一個抽象的模塊，它包含了一系列對象及其方法，類的設計就是對現實世界的抽象化，所以面對對象程式設計也需要強大的抽象思維能力，在面對對象程式設計中，類的設計是重中之重，為了設計類，還需要探究類之間的關係，類之間的關係通常有關聯、聚合、組合及繼承，這也體現了面對對象程式設計的三大特點：封裝性、繼承性、多態性。

  通過三次作業，能夠感覺到JAVA這門語言的強大，同時也能感覺到JAVA里的世界之大，目前我只學習到了它最基礎的語法部分以及少量的類，JAVA自帶了大量的類可以使用，這能大大方便我們解決問題。老師在上課時也帶我們接觸了一些從未聽過的東西，比如JAVA里的集合框架，這些內容需要我們自己花大量時間去探究學習。

 


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

-Advertisement-
Play Games
更多相關文章
  • MySQL與Java常用數據類型的對應關係
    一、字元串數據類型: MySQL類型名 大小 用途 對應Java類名 char 0-255 bytes 定長字元串 （姓名、性別、學號） String varchar 0-65535 bytes 變長字元串（比上面更長一點的那種） String tinytext 0-255 bytes 比較短的那種 ...
  • 支持10倍訂單增長，攜程資料庫架構升級實踐
    隨著機票訂單業務的不斷增長，當前訂單處理系統的架構已經不能滿足日益增長的業務需求，系統性能捉襟見肘，主要體現在以下方面： 資料庫CPU資源在業務高峰期經常達到50%以上，運行狀況亮起了黃燈； 磁碟存儲空間嚴重不足，需要經常清理磁碟數據騰挪可用空間； 系統擴容能力不足，如果需要提升處理能力只能更換配置... ...
  • Single-spa 源碼淺析
    引言 前一段時間, 正好在做微前端的接入和微前端管理平臺的相關事項。 而我們當前使用的微前端框架則是 qiankun, 他是這樣介紹自己的: qiankun 是一個基於 single-spa 的微前端實現庫，旨在幫助大家能更簡單、無痛的構建一個生產可用微前端架構系統。 所以本文基於 single-s ...
  • 前端設計模式——路由模式
    路由模式（Router Pattern）：將頁面的不同狀態映射到不同的URL路徑上，使得用戶可以直接通過URL來訪問頁面的不同狀態。 路由模式通常用於實現單頁面應用（SPA）的頁面導航和狀態管理。具體來說，路由模式通過解析URL路徑來確定應該顯示哪個頁面，並使用歷史記錄API來管理頁面狀態。 一般來 ...
  • JS 做一個簡單的 Parser
    本文使用簡單易懂的代碼，實現了一組可以構造解析器的函數。相信通過本文的演示，你應該對解析器的基本工作原理有了一個淺淺的瞭解。 ...
  • 前端設計模式——計算屬性模式
    計算屬性模式（Computed Property Pattern）：在JavaScript中，可以使用Object.defineProperty()方法來實現計算屬性模式，通過get和set方法來計算屬性值。 計算屬性模式用於將對象的某些屬性值與其他屬性值相關聯。該模式常用於Vue.js等框架中。 ...
  • 前端常用的終端命令
    終端主要的目的是可以讓我們在文件系統中進行四處瀏覽和打開/運行某些東西，只是在 windows 上我們之前都是用 GUI 界面進行操作的，現在是在終端中使用 shell 命令進行操作而已。 ...
  • 【軟體架構】 類和類的六種關係 Power Designer設計UML類圖
    UML(Unified Modeling Language)統一建模語言 power designer中給類的“操作”添加“輸入參數” 查看所設計類的代碼： 類和類的六種關係 1 繼承關係（泛化關係） 語義：子類和父類之間的關係 語法：extends 符號：（子類指向父類） power design ...
一周排行
    -Advertisement-
    Play Games
  • UOS 開啟 VisualStudio 遠程調試 .NET 應用之旅
    前言 在我們開發過程中基本上不可或缺的用到一些敏感機密數據，比如SQL伺服器的連接串或者是OAuth2的Secret等，這些敏感數據在代碼中是不太安全的，我們不應該在源代碼中存儲密碼和其他的敏感數據，一種推薦的方式是通過Asp.Net Core的機密管理器。 機密管理器 在 ASP.NET Core ...
  • C# - 能否讓 SortedSet.RemoveWhere 內傳入的委托非同步執行
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • 順序棧的介面程式
    順序棧的介面程式 目錄順序棧的介面程式頭文件創建順序棧入棧出棧利用棧將10進位轉16進位數驗證 頭文件 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> 創建順序棧 // 指的是順序棧中的元素的數據類型，用戶可以根據需要進行修改 ...
  • mORMot2 獲取數據集1
    前言 整理這個官方翻譯的系列，原因是網上大部分的 tomcat 版本比較舊，此版本為 v11 最新的版本。 開源項目 從零手寫實現 tomcat minicat 別稱【嗅虎】心有猛虎，輕嗅薔薇。 系列文章 web server apache tomcat11-01-官方文檔入門介紹 web serv ...
  • 萬字長文總結與剖析C語言關鍵字 -- <<C語言深度解剖>>
    C總結與剖析:關鍵字篇 -- <<C語言深度解剖>> 目錄C總結與剖析:關鍵字篇 -- <<C語言深度解剖>>程式的本質:二進位文件變數1.變數:記憶體上的某個位置開闢的空間2.變數的初始化3.為什麼要有變數4.局部變數與全局變數5.變數的大小由類型決定6.任何一個變數,記憶體賦值都是從低地址開始往高地 ...
  • 【Flink入門修煉】2-3 Flink Checkpoint 原理機制
    如果讓你來做一個有狀態流式應用的故障恢復，你會如何來做呢？ 單機和多機會遇到什麼不同的問題？ Flink Checkpoint 是做什麼用的？原理是什麼？ ...
  • C++ 多級繼承與多重繼承：代碼組織與靈活性的平衡
    C++ 多級繼承 多級繼承是一種面向對象編程（OOP）特性，允許一個類從多個基類繼承屬性和方法。它使代碼更易於組織和維護，並促進代碼重用。 多級繼承的語法 在 C++ 中，使用 : 符號來指定繼承關係。多級繼承的語法如下： class DerivedClass : public BaseClass1 ...
  • 圖文結合手把手教你創建SpringCloud項目
    前言 什麼是SpringCloud？ Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的開發便利性簡化了分散式系統的開發，比如服務註冊、服務發現、網關、路由、鏈路追蹤等。Spring Cloud 並不是重覆造輪子，而是將市面上開發得比較好的模塊集成進去，進行封裝，從 ...
  • 類模板的常見用法
    class_template 類模板和函數模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是數據類型不同。類模板用於實現類所需數據的類型參數化 template<class NameType, class AgeType> class Person { publi ...
  • system-v IPC共用記憶體通信
    目錄system v IPC簡介共用記憶體需要用到的函數介面shmget函數--獲取對象IDshmat函數--獲得映射空間shmctl函數--釋放資源共用記憶體實現思路註意 system v IPC簡介 消息隊列、共用記憶體和信號量統稱為system v IPC(進程間通信機制)，V是羅馬數字5，是UNI ...
所有分類