Java ส่งคืนคำหลัก

อย่างที่เราทราบกันดีว่าภาษา Java เป็นภาษาโปรแกรมเชิงวัตถุ กล่าวอีกนัยหนึ่ง แนวคิดพื้นฐาน เช่น รากฐานของรากฐาน คือทุกสิ่งเป็นวัตถุ มีการอธิบายวัตถุโดยใช้คลาส ในทางกลับกันคลาสจะกำหนดสถานะและพฤติกรรม เช่น บัญชีธนาคารอาจมีสถานะเป็นจำนวนเงินในบัญชี และมีพฤติกรรมเพิ่มและลดยอดเงินในบัญชี ใน Java พฤติกรรมจะถูกนำไปใช้ผ่านเมธอด การเรียนรู้วิธีการกำหนดวิธีการเริ่มต้นของการศึกษา Java ของคุณ ตัวอย่างเช่น ในบทช่วยสอนอย่างเป็นทางการของ Oracle ภายใต้หัวข้อ " การกำหนดวิธีการ " มีสองสิ่งสำคัญที่ควรทราบที่นี่:

• แต่ละวิธีมีลายเซ็น ลายเซ็นประกอบด้วยชื่อของวิธีการและพารามิเตอร์อินพุต
• ต้องระบุประเภทการส่งคืนสำหรับเมธอด คุณประกาศประเภทผลตอบแทนของเมธอดในการประกาศเมธอด

ประเภทการส่งคืนไม่ได้เป็นส่วนหนึ่งของลายเซ็นเมธอด นี่เป็นผลสืบเนื่องมาจากข้อเท็จจริงที่ว่า Java เป็นภาษาที่มีการพิมพ์สูง และคอมไพเลอร์ต้องการทราบว่ามีการใช้ประเภทใดและตำแหน่งใดล่วงหน้าและมากที่สุดเท่าที่จะเป็นไปได้ อีกครั้งเพื่อช่วยเราจากความผิดพลาด โดยพื้นฐานแล้ว ทั้งหมดนี้เป็นไปเพื่อเหตุที่ดี และสำหรับฉันแล้วดูเหมือนว่าสิ่งนี้จะปลูกฝังวัฒนธรรมการจัดการข้อมูลให้กับเราอีกครั้ง ดังนั้นจึงระบุชนิดของค่าส่งคืนสำหรับเมธอด และ คำหลัก returnใน Java ใช้เพื่อส่งคืนจริง

return ทำอะไรใน Java

คีย์เวิร์ดreturnคือคำสั่งโฟลว์ควบคุม ดังที่อธิบายไว้ในบทช่วยสอนของ Oracle ที่นี่ คุณยังสามารถอ่านเกี่ยวกับวิธีการคืนค่าในส่วน " การคืนค่าจากเมธอด " ของบทช่วยสอนอย่างเป็นทางการ คอมไพลเลอร์จะติดตามอย่างรอบคอบว่าสามารถรับประกันได้หรือไม่ว่าค่าส่งคืนของเมธอดตรงกับประเภทการส่งคืนที่ระบุของเมธอด ลองใช้ Online IDE ของ Tutorialspointเพื่อพิจารณาตัวอย่าง ลองดูตัวอย่างเบื้องต้น:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

อย่างที่เราเห็น วิธีการ หลักถูกดำเนินการที่นี่ ซึ่งเป็นจุดเริ่มต้นของโปรแกรม บรรทัดของโค้ดดำเนินการจากบนลงล่าง วิธีการ หลักของเราไม่สามารถคืนค่าได้ หากเราพยายามคืนค่าที่นั่น เราจะได้รับข้อผิดพลาด: "Error: Main method must return a value of type void" . ดังนั้นเมธอดจะส่งออกไปยังหน้าจอ ตอนนี้ขอย้ายสตริงตัวอักษรเป็นวิธีการแยกต่างหากสำหรับการสร้างข้อความ:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println(getHelloMessage());
    }
    
    public static String getHelloMessage() {
        return "Hello World";
    }
    
}

อย่างที่เราเห็น เราใช้ คีย์เวิร์ด returnเพื่อระบุค่าที่ส่งคืน ซึ่งเราส่งต่อไปยังเมธอดprintln การประกาศของ เมธอด getHelloMessageระบุว่าเมธอดจะส่งคืนค่าString ซึ่งช่วยให้คอมไพเลอร์ตรวจสอบว่าการดำเนินการของเมธอดนั้นสอดคล้องกับวิธีการประกาศหรือไม่ โดยปกติแล้ว ประเภทการส่งคืนที่ระบุในการประกาศเมธอดอาจกว้างกว่าประเภทของค่าที่ส่งคืนจริงในโค้ด กล่าวคือ สิ่งสำคัญคือการแปลงประเภทสามารถทำได้ มิฉะนั้น เราจะได้รับข้อผิดพลาดในขณะคอมไพล์: "Error: incompatible types" . อย่างไรก็ตาม คุณอาจมีคำถามว่าทำไมจึงกลับมาถือว่าเป็นคำสั่งกระแสการควบคุม? เนื่องจากสามารถขัดขวางการไหลจากบนลงล่างปกติของโปรแกรมได้ ตัวอย่าง:

public class HelloWorld {

    public static void main(String[] args) {
        if (args.length == 0) {
            return;
        }
        for (String arg : args) {
            System.out.println(arg);
        }
    }
    
}

ดังที่คุณเห็นจากตัวอย่าง เราจะขัดจังหวะ เมธอด หลักในโปรแกรม Java หากเรียกโดยไม่มีอาร์กิวเมนต์ สิ่งสำคัญคือต้องจำไว้ว่าหากคุณมีรหัสหลัง คำสั่ง returnจะไม่สามารถเข้าถึงได้ คอมไพเลอร์อัจฉริยะของเราจะสังเกตเห็นและป้องกันไม่ให้คุณเรียกใช้โปรแกรมดังกล่าว ตัวอย่างเช่น รหัสนี้ไม่ได้คอมไพล์:

public static void main(String[] args) {
        System.out.println("1");
        return;
// we use output method after return statement, which is incorrect 
        System.out.println("2");
 }

มีแฮ็คสกปรกหนึ่งอันที่จะหลีกเลี่ยงสิ่งนี้ ตัวอย่างเช่น เพื่อวัตถุประสงค์ในการดีบัก หรือเพื่อเหตุผลอื่นบางประการ โค้ดด้านบนสามารถแก้ไขได้โดยการห่อ คำสั่ง returnใน บล็อก if :

if (2==2) {
    return;
}

ส่งคืนคำสั่งระหว่างการจัดการข้อผิดพลาด

มีอย่างอื่นที่ยุ่งยากมาก — เราสามารถใช้returnร่วมกับการจัดการข้อผิดพลาดได้ ฉันต้องการบอกทันทีว่าการใช้ คำสั่ง returnในcatch block เป็นรูปแบบที่แย่มาก ดังนั้นคุณควรหลีกเลี่ยง แต่เราต้องการตัวอย่างใช่ไหม นี่คือ:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Value: " + getIntValue());
    }
    
    public static int getIntValue() {
        int value = 1;
        try {
            System.out.println("Something terrible happens");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("Cached value: " + value);
            return value;
        } finally {
            value++;
            System.out.println("New value: " + value);
        }
    }
    
}

เมื่อมองแวบแรกดูเหมือนว่าควรส่งคืน 2 เนื่องจากสุดท้ายจะถูกดำเนินการเสมอ แต่ไม่ ค่าที่ส่งคืนจะเป็น 1 และการเปลี่ยนแปลงตัวแปรใน บล็อก สุดท้ายจะถูกละเว้น นอกจากนี้ สมมติว่าค่า นั้น มีวัตถุอยู่ และเราบอกว่าค่า = nullในบล็อกสุดท้าย จากนั้นวัตถุนั้นจะถูกส่งกลับในcatch block ซึ่งไม่ใช่ค่าว่าง แต่ คำสั่ง returnจะทำงานได้อย่างถูกต้องในบล็อกสุดท้าย เห็นได้ชัดว่า เพื่อนร่วมงานของคุณจะไม่ขอบคุณสำหรับเซอร์ไพรส์เล็กๆ น้อยๆ ที่เกี่ยวข้องกับการตอบกลับ

void.คลาส

และในที่สุดก็. มีโครงสร้างแปลก ๆ ที่คุณสามารถเขียนได้: void.class อืม. ทำไมและหมายความว่าอย่างไร มีเฟรมเวิร์กและเคสที่ซับซ้อนมากมายที่เกี่ยวข้องกับJava Reflection APIซึ่งสิ่งนี้มีประโยชน์มาก ตัวอย่างเช่น คุณสามารถตรวจสอบว่าเมธอดส่งคืนประเภทใด:

import java.lang.reflect.Method;

public class HelloWorld {

    public void getVoidValue() {
    }

    public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == void.class);
        }
    }
}

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

public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }

คุณสามารถอ่านการสนทนาที่น่าสนใจเกี่ยวกับความแตกต่างระหว่างทั้งสองได้ใน Stack Overflow: อะไรคือความแตกต่างระหว่าง java.lang.Void และ void?