คำสั่งแบ่งใน Java

สวัสดีเพื่อนร่วมงานและผู้สนใจทุกท่าน วันนี้เราจะมาดูคุณสมบัติของภาษาการเขียนโปรแกรม Java ในฐานะตัวดำเนินการแบ่ง นี่เป็นบทความแรกในหัวข้อตัวดำเนินการเปลี่ยนผ่าน ดังนั้นหากคุณชอบฉันยินดีที่จะเขียนเพิ่มเติม ฉันต้องการทราบทันทีว่าบทความนี้มีไว้สำหรับนักพัฒนามือใหม่เป็นหลัก และนักเรียนขั้นสูงอาจไม่พบสิ่งใหม่สำหรับตัวเองที่นี่ งั้นไปกัน. ใน Java มีสองวิธีในการเปลี่ยนลำดับการดำเนินการคำสั่งโปรแกรม: คำสั่ง Jump และกลไกการจัดการข้อยกเว้น Jump Operator ใน Java มี 3 ตัว คือ Break, Continue และ Return วันนี้ฉันขอเชิญคุณมาดูผู้ดำเนินการให้ละเอียดยิ่งbreakขึ้น การจัดการข้อยกเว้นเป็นหัวข้อกว้างๆ ซึ่งอยู่นอกเหนือขอบเขตของบทความนี้ มีสามวิธีในการใช้คำสั่งแบ่งใน java วิธีแรกและเป็นที่นิยมมากที่สุดคือใช้breakเพื่อออกจากลูปก่อนเวลา เช่น:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

ตัวอย่างนี้จะแสดง:

1
2
cycle was finished

ซึ่งหมายความว่าเมื่อตัวนับลูปiเท่ากับพารามิเตอร์ที่ส่งผ่านnumberนั่นคือหมายเลข 3 การประมวลผลลูปจะสิ้นสุดลงก่อนกำหนด หากโปรแกรมมีหลายลูปที่ซ้อนกัน ให้แยกเอาต์พุตจากลูปในสุดเท่านั้น ตัวอย่างเช่น:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

ตัวอย่างนี้สร้างผลลัพธ์:

012
012
012
012
012
cycles was finished

ดังที่เห็นได้จากตัวอย่าง วงในจะถูกขัดจังหวะแต่ละครั้งที่หมายเลข 3 (พารามิเตอร์number) และวงนอกจะถูกดำเนินการ 5 ครั้งตามที่ตั้งใจไว้ ใน Java คุณสามารถใช้คำสั่งแบ่งมากกว่าหนึ่งคำสั่งภายในลูปได้ แต่ไม่แนะนำ เนื่องจากความสามารถในการอ่านและโครงสร้างของโค้ดลดลงอย่างมาก การใช้งานที่สองbreakคือใช้เพื่อขัดจังหวะการดำเนินการของคำสั่งในสาขาswitchเช่น:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

การรันตัวอย่างนี้จะสร้างผลลัพธ์:

4
after switch

คำสั่งแบ่งส่งผ่านการควบคุมไปยังโค้ดที่ตามหลังบล็อกswitchทั้งหมด หากคุณไม่ได้ระบุbreakในswitchตัวอย่างนี้:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

ผลลัพธ์จะไม่เป็นไปตามที่คาดไว้:

4
4
after switch

สิ่งนี้เกิดขึ้นเพราะหลังจากที่บล็อกถูกดำเนินการcase 2โปรแกรมยังคงดำเนิน การบล็อก เคส ที่ตามมาทั้งหมดต่อไป ซึ่งให้ผลลัพธ์ที่สอดคล้องกันแก่เรา บางครั้งคุณลักษณะของตัวดำเนินการนี้switch อาจเป็นประโยชน์ต่อเรา เช่น:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

โปรแกรมนี้เปรียบเทียบตัวเลขที่กำหนดกับหมายเลข 5 และให้ผลลัพธ์ต่อไปนี้:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

เมื่อเรียกใช้เมธอดเป็นครั้งแรก ตัวดำเนินการswitchจะถ่ายโอนการควบคุมไปยังตัวดำเนินการจากcase 2นั้นจึงถ่ายโอนไปยังตัวดำเนินการbreakใน case 5การโทรครั้งที่สองคล้ายกับการโทรครั้งแรก แต่เริ่มต้นด้วยcase 7c การเรียกครั้งที่สามไม่พบค่าที่เหมาะสมในทุกกรณี ดังนั้นตัวดำเนินการจึงถูกดำเนินdefaultการ วิธีที่สามคือการใช้ตัวดำเนินการbreakแทนgotoตัวดำเนินการ C ในการดำเนินการนี้เราจะใช้รูปแบบพิเศษของตัวดำเนินการbreakที่เรียกbreakพร้อมกับป้ายกำกับ แบบฟอร์มนี้ดูเหมือนbreak метка;ป้ายกำกับ ซึ่งโดยปกติจะเป็นชื่อที่เหมาะสมจากเนมสเปซ Java ที่อยู่หน้าบล็อกของโค้ด นอกจากนี้ หลังจากใช้บล็อกโค้ดนี้breakกับป้ายกำกับแล้ว รหัสจะยังคงถูกดำเนินการจากตำแหน่งหลังบล็อกที่มีป้ายกำกับที่เกี่ยวข้อง เช่น:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

ตัวอย่างนี้จะสร้างผลลัพธ์ต่อไปนี้:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

หลังจากการเรียกเมธอดแรก ตัวดำเนินการbreakจะถ่ายโอนการควบคุมไปยังจุดสิ้นสุดของบล็อกsecondBlockออกจากsecondBlockและthirdBlockขณะเดียวกันก็ดำเนินการกับตัวดำเนินการอื่นprintln()ที่ส่วนfirstBlockท้าย หลังจากการโทรครั้งที่ 2 เส้นทั้งหมดจะแสดงบนหน้าจอ ฉลากยังสามารถใช้เพื่อระบุรอบการทำงานได้อีกด้วย ควรจำไว้ว่าคุณสามารถไปที่ป้ายกำกับได้จากภายในบล็อกของโค้ดที่ระบุโดยป้ายกำกับเท่านั้น ตัวอย่างเช่น โค้ดดังกล่าวจะไม่คอมไพล์:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

หมายเหตุเกี่ยวกับความสะอาดของโค้ดและคำสั่งbreak: มีคำแนะนำที่เป็นที่ยอมรับโดยทั่วไปในการใช้คำสั่งbreakอย่างระมัดระวัง เนื่องจากการใช้breakงานทำให้การวนซ้ำเข้าใจยากขึ้น และบังคับให้โปรแกรมเมอร์มองเข้าไปในลูปเพื่อทำความเข้าใจความแตกต่างของการทำงานของมัน มีกฎการศึกษาสำนึกที่break คุณสามารถใช้ได้อย่างมั่นใจมากขึ้นในลูปที่สั้นกว่า และด้วยความระมัดระวังมากขึ้นในลูปที่ยาวและซ้อนกันลึก เนื่องจากสิ่งนี้จะเพิ่มโอกาสที่จะเกิดข้อผิดพลาด และทำให้การอ่านและการทำความเข้าใจโค้ดของคุณโดยโปรแกรมเมอร์คนอื่นซับซ้อนขึ้น ดังที่ผมเขียนไว้ข้างต้น การใช้ . จำนวนมากbreakที่กระจัดกระจายไปทั่วโค้ดบ่งชี้ว่าโปรแกรมเมอร์ไม่เข้าใจอย่างถ่องแท้ว่าทำไมเขาถึงเขียนโค้ดในแบบที่เขาทำ การพิจารณาปรับโครงสร้างลูปดังกล่าวใหม่อาจคุ้มค่าโดยแบ่งออกเป็นลูปเล็กๆ หลายๆ ลูป พยายามใช้ความระมัดระวังเมื่อใช้break ป้ายกำกับแทนgotoเนื่องจากจะทำให้โครงสร้างโค้ดซับซ้อน นั่นคือทั้งหมดที่ฉันอยากจะบอกคุณในวันนี้เกี่ยวกับโอเปอเรเตอร์breakใน java ฉันยินดีที่จะวิจารณ์อย่างสร้างสรรค์และฉันก็พร้อมที่จะเขียนบทความต่อเกี่ยวกับตัวดำเนินการcontinueและreturnหากคุณสนใจ