การแนะนำ
ดังที่เราทราบ Java เป็นภาษาโปรแกรมเชิงวัตถุ นั่นก็คือแนวคิดพื้นฐานเพราะว่า ที่จะบอกว่าพื้นฐานของพื้นฐานคือทุกสิ่งเป็นวัตถุ วัตถุถูกอธิบายโดยใช้คลาส
![คำสั่งส่งคืนใน Java - 1]()
ชั้นเรียนก็มีสถานะและพฤติกรรมเช่นกัน เช่น บัญชีธนาคารอาจมีสถานะเป็นจำนวนเงินในบัญชีและมีพฤติกรรมเพิ่มและลดยอดคงเหลือ พฤติกรรมใน Java ถูกนำไปใช้โดยใช้วิธีการ วิธีการอธิบายวิธีการต่างๆ ถูกนำมาใช้ตั้งแต่เริ่มต้นเส้นทางการเรียนรู้ Java ของคุณ ตัวอย่างเช่น ในบทช่วยสอนอย่างเป็นทางการจาก Oracle: “
การกำหนดวิธีการ ” มีสองประเด็นสำคัญที่นี่:
- แต่ละวิธีมีลายเซ็น ลายเซ็นประกอบด้วยชื่อวิธีการและพารามิเตอร์อินพุต
- วิธีการจะต้องระบุประเภทการส่งคืน
- ประเภทการส่งคืนไม่ได้เป็นส่วนหนึ่งของลายเซ็นวิธีการ
นี่เป็นผลสืบเนื่องจากความจริงที่ว่า Java เป็นภาษาที่พิมพ์อย่างรุนแรงและคอมไพเลอร์ต้องการทำความเข้าใจล่วงหน้าว่าจะใช้ประเภทใดให้มากที่สุดเท่าที่จะเป็นไปได้ อีกครั้งเพื่อปกป้องเราจากความผิดพลาด โดยทั่วไปแล้วทุกอย่างมีไว้เพื่อผลดี นี่เป็นการปลูกฝังวัฒนธรรมการจัดการข้อมูลให้กับเราอีกครั้งสำหรับฉัน ดังนั้นสำหรับวิธีการจะมีการระบุประเภทค่าไว้
return
และหากต้องการส่งกลับค่าเดียวกันนี้จากวิธีการต่างๆ จะ ใช้คีย์เวิร์ด
คำสั่งส่งคืนคีย์เวิร์ดใน Java
คีย์เวิร์ดของคำสั่ง
return
อ้างอิงถึง "คำสั่ง control flow" ตามที่กล่าวไว้ในบทช่วยสอนของ oracle "
Control Flow Statements " คุณยังสามารถอ่านเกี่ยวกับวิธีการส่งคืนค่าได้ในบทช่วยสอนอย่างเป็นทางการ: “
การส่งคืนค่าจากวิธีการ ” คอมไพลเลอร์จะตรวจสอบอย่างระมัดระวังอย่างสุดความสามารถ ว่าค่าที่ส่งคืนจากเมธอดตรงกับประเภทค่าส่งคืนที่ระบุโดยเมธอด
ลองใช้ Online IDEจาก Tutorialspoint เป็นตัวอย่าง ลองดูตัวอย่างดั้งเดิม:
public class HelloWorld {
public static void main(String []args) {
System.out.println("Hello World");
}
}
ดังที่เราเห็น มีการดำเนินการเมธอดที่นี่
main
ซึ่งเป็นจุดเริ่มต้นของโปรแกรม บรรทัดของโค้ดถูกดำเนินการจากบนลงล่าง วิธีการ ของเรา
main
ไม่สามารถคืนค่าได้ ไม่เช่นนั้นเราจะได้รับข้อผิดพลาด: "
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
" อย่างไรก็ตาม คำถามอาจเกิดขึ้นทันที: เหตุใด
return
จึงนำไปใช้กับตัวดำเนินการควบคุมการไหลของโปรแกรม? แต่เนื่องจากสามารถรบกวนโฟลว์ปกติของโปรแกรมจากบนลงล่างได้ ตัวอย่างเช่น:
public class HelloWorld {
public static void main(String []args){
if (args.length == 0) {
return;
}
for (String arg : args) {
System.out.println(arg);
}
}
}
ดังที่เห็นได้จากตัวอย่าง เราจะขัดจังหวะการทำงานของเมธอด
main
หากโปรแกรม java ของเราถูกเรียกโดยไม่มีพารามิเตอร์ สิ่งสำคัญคือต้องจำไว้ว่าหากคุณ
return
มีรหัสแล้ว รหัสนั้นจะไม่สามารถเข้าถึงได้ และคอมไพเลอร์อัจฉริยะของเราจะสังเกตเห็นสิ่งนี้และจะไม่อนุญาตให้คุณเรียกใช้โปรแกรมดังกล่าว ตัวอย่างเช่น โค้ดนี้จะไม่คอมไพล์:
public static void main(String []args) {
System.out.println("1");
return;
System.out.println("2");
}
มีแฮ็คสกปรกที่จะแก้ไขปัญหานี้ ตัวอย่างเช่น เพื่อวัตถุประสงค์ในการแก้ไขจุดบกพร่องหรือเพื่อเหตุผลอื่น โค้ดด้านบนสามารถแก้ไขได้โดยการล้อมไว้
return
ใน
if
บล็อก:
if (2==2) {
return;
}
คำสั่ง Return ในการจัดการข้อผิดพลาด
มีสถานการณ์หนึ่งที่ยุ่งยากมาก - เราสามารถใช้
return
ร่วมกับการจัดการข้อผิดพลาดได้ ฉันอยากจะบอกทันทีว่าการใช้มัน
return
ใน
catch
บล็อกเป็นรูปแบบที่แย่มากดังนั้นคุณควรหลีกเลี่ยง แต่เราต้องการตัวอย่างใช่ไหม? เขาอยู่ที่นี่:
public class HelloWorld {
public static void main(String []args) {
System.out.println("Value is: " + getIntValue());
}
public static int getIntValue() {
int value = 1;
try {
System.out.println("Something terrible happens");
throw new Exception();
} catch (Exception e) {
System.out.println("Catched value: " + value);
return value;
} finally {
value++;
System.out.println("New value: " + value);
}
}
}
เมื่อมองแวบแรก ดูเหมือนว่า 2 ควรจะส่งคืน เนื่องจาก
finally
มีการดำเนินการอยู่เสมอ แต่ไม่ ค่าจะเป็น 1 และการเปลี่ยนแปลงของตัวแปรใน
finally
จะถูกละเว้น ยิ่งกว่านั้น หากมัน
value
มีวัตถุและเรา
finally
บอก
value = null
ว่า มัน
catch
จะยังคงส่งคืนการอ้างอิงไปยังวัตถุ
null
ไม่ใช่ แต่จากบล็อกนั้น
finally
ผู้ปฏิบัติงาน
return
ก็จะทำงานได้อย่างถูกต้อง เพื่อนร่วมงานจะไม่ขอบคุณสำหรับของขวัญดังกล่าวอย่างชัดเจน
เป็นโมฆะ.คลาส
และในที่สุดก็. คุณสามารถเขียนโครงสร้างแปลกๆ เช่น
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);
}
}
}
สิ่งนี้มีประโยชน์ในกรอบการทดสอบที่จำเป็นต้องแทนที่โค้ดวิธีการจริง แต่ในการทำเช่นนี้ คุณต้องเข้าใจว่าวิธีนี้ทำงานอย่างไร (เช่น ส่งคืนประเภทใด) มีวิธีที่สองในการใช้วิธีการ
main
จากโค้ดด้านบน:
public static void main (String[] args) {
for (Method method : HelloWorld.class.getDeclaredMethods()) {
System.out.println(method.getReturnType() == Void.TYPE);
}
}
การอภิปรายที่น่าสนใจเกี่ยวกับความแตกต่างระหว่างทั้งสองสามารถอ่านได้ใน stackoverflow:
อะไรคือความแตกต่างระหว่าง java.lang.Void และ void? #เวียเชสลาฟ
GO TO FULL VERSION