วิธีการใน Java

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

public String constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  System.out.println(resultSentence);
  return resultSentence;
}

ไม่มีอะไรซับซ้อนที่นี่: วิธีการ Java ที่มีหน้าที่สร้างสตริงคำทักทายด้วยชื่อที่เราส่งต่อไป เช่น - Hello world! My name is Bobby มาทำความเข้าใจการสร้างวิธีการอย่างถูกต้องโดยดูที่คำหลักแต่ละคำในการประกาศวิธีการ (จากซ้ายไปขวา) คำหลักแรกของเราคือpublicและหมายถึงตัวแก้ไขการเข้าถึง:

ตัวดัดแปลงการเข้าถึง

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

• สาธารณะ : สาธารณะ เมธอดหรือฟิลด์ที่มีตัวแก้ไขนี้เป็นแบบสาธารณะ คลาสอื่นๆ (หรือมากกว่านั้นคือเมธอดและฟิลด์) มองเห็นได้จากแพ็คเกจปัจจุบันและจากแพ็คเกจภายนอก นี่คือระดับการเข้าถึงที่กว้างที่สุดที่ทราบ

• protected : วิธีการหรือตัวแปรที่มีตัวปรับแต่งนี้สามารถเข้าถึงได้จากทุกที่ในคลาสหรือแพ็คเกจปัจจุบัน หรือในคลาสที่สืบทอดสิ่งนี้ เช่นเดียวกับวิธีการหรือฟิลด์ แม้ว่าจะอยู่ในแพ็คเกจอื่นก็ตาม

  
  protected String constructHelloSentence(String name) {...}

• ตัวแก้ไขเริ่มต้น หากฟิลด์คลาสหรือเมธอดไม่มีตัวแก้ไข ระบบจะใช้ตัวแก้ไขเริ่มต้น ในกรณีนี้ ฟิลด์หรือเมธอดจะปรากฏแก่ทุกคลาสในแพ็คเกจปัจจุบัน (เช่นprotectedแต่จะไม่สามารถมองเห็นได้เมื่อสืบทอด)

  
  String constructHelloSentence(String name) {...}

• private : ตรงกันข้ามกับpublic modifier เมธอดหรือตัวแปรที่มีโมดิฟายเออร์ดังกล่าวมีเฉพาะในคลาสที่ประกาศไว้เท่านั้น

  
  private String constructHelloSentence(String name) {...}

ต่อไปเรามีStringลายเซ็นวิธีการ (บรรทัดแรกของวิธีที่อธิบายคุณสมบัติ)

ส่งคืนค่า

ค่าที่ส่งคืนคือข้อมูล (ผลลัพธ์บางส่วนของการดำเนินการเมธอด) ที่เข้ามาแทนที่หลังจากการโทร ทุกวิธีมีค่าส่งคืน หรือไม่?

วิธีการส่งคืนค่า

ค่านี้สามารถเป็นข้อมูลประเภทใดก็ได้: ตัวแปรประเภทธรรมดาหรือประเภทอ้างอิง ในตัวอย่างนี้ เราระบุว่าเมธอดต้องส่งคืนอ็อบเจ็กต์ประเภทStringซึ่งตามที่เราจำได้คือคลาสที่อธิบายสตริง จุดที่สองที่นี่คือคำreturnว่า มันมีความสัมพันธ์โดยตรงกับค่าที่ส่งคืน: ค่าหลังจากนั้นจะถูกส่งกลับไปยังตำแหน่งที่มีการเรียกเมธอด และจากนั้นเมธอดจะreturnปิด เอง คำนี้มักจะปรากฏในบรรทัดสุดท้ายของเมธอด (ยกเว้นเมธอดที่มีสาขาต่างๆ เช่นif, else...) หากคุณเขียนโค้ดในบรรทัดถัดไปหลังจากreturn:

private String constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  return resultSentence;
  System.out.println(resultSentence);
}

แล้วเราจะได้รับคำสาปจากคอมไพเลอร์ซึ่งไม่ค่อยดีนัก (คอมไพเลอร์จะไม่แนะนำเรื่องไร้สาระ) คุณต้องจำไว้ว่าประเภทข้อมูลหลังจากนั้นсจะต้องตรงกับประเภทข้อมูลที่ประกาศไว้ในลายเซ็นเมธอด returnอ่านเพิ่มเติมเกี่ยวกับที่ นี่

เป็นโมฆะ

มันใช้สำหรับอะไรvoidใน Java? ไม่ใช่ทุกวิธีจะมีค่าส่งคืน บางอันก็ไม่มีอะไรเลยหรือไม่ต้องคืนอะไรเลย แล้วต้องทำอย่างไร? จากนั้นในลายเซ็นวิธีการที่เราเขียนvoid. วิธีการของเราจะเป็นอย่างไรหากไม่มีค่าส่งคืน?

protected void constructHelloSentence(String name) {
  String resultSentence = "Hello world! My name is " + name;
  System.out.println(resultSentence);
}

คุณอาจสังเกตเห็นว่าพร้อมกับค่าที่ส่งคืนคำว่าreturnSo it is หายไปเพราะวิธีการของเราไม่ควรส่งคืนสิ่งใด อย่างไรก็ตาม สามารถวางไว้ที่นี่ได้ แต่ไม่มีความหมายใดๆ เพียงreturn; ในบรรทัดสุดท้าย โดยทั่วไปแล้วสิ่งนี้จะไม่มีประโยชน์ ดังนั้นvoidจึงเป็นทางเลือกในวิธีการที่มี อย่างไรก็ตาม สามารถใช้มีประโยชน์ในvoidวิธีการ เช่น กิ่งหรือลูป ซึ่งคุณต้องการออกจากวิธีการทันที ถัดไปในการประกาศวิธีการที่เราconstructHelloSentenceมี

ชื่อวิธีการ

constructHelloSentence - ชื่อของวิธีการ ซึ่งเป็นคุณลักษณะเฉพาะที่เราสามารถแยกแยะวิธีการอย่างใดอย่างหนึ่งได้ และตามลำดับให้เรียกวิธีใดวิธีหนึ่ง ชื่อเมธอดต้องขึ้นต้นด้วยตัวอักษรตัวเล็ก แต่ใช้ตัวพิมพ์แบบอูฐด้วย (CamelCase, ตัวพิมพ์แบบอูฐ): เช่น แต่ละคำถัดไปในชื่ออยู่ติดกับคำก่อนหน้าและเขียนด้วยตัวพิมพ์ใหญ่ ชื่อวิธีการควรอธิบายวิธีการ (ความคิดเห็นที่ดีที่สุดคือการตั้งชื่อที่เหมาะสม) เมื่อต้องการทำเช่นนี้ ให้ใช้คำกริยาหรือการผสมกับคำกริยา: getCat, delete, createCarและอื่นๆ ภายในคลาสเดียว ชื่อเมธอดจะต้องไม่ซ้ำกัน (ไม่นับการโอเวอร์โหลดเมธอด ซึ่งเราจะพูดถึงในภายหลัง) ลองดูวิธีที่เรากำลังวิเคราะห์เพิ่มเติมและดู ( String name)

พารามิเตอร์วิธีการ

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

public void constructHelloSentence(String...name) {
 ...
}

ความน่าดึงดูดของแต่ละองค์ประกอบจะเป็นเช่นนี้name[0] มันเตือนคุณถึงสิ่งใดหรือไม่? ถูกต้องแล้วอาร์เรย์! จะไม่มีอะไรเปลี่ยนแปลงถ้าเราเขียน:

protected void constructHelloSentence(String[] name) {
 ...
}

การเข้าถึงองค์ประกอบต่างๆ ก็จะอยู่ในรูปแบบนี้เช่นกันname[1] และอีกอย่างหนึ่ง อาร์กิวเมนต์ของวิธีการอาจเป็นที่สิ้นสุด :

public String constructHelloSentence(final String name) {
  ...
}

ซึ่งหมายความว่าการอ้างอิงชื่อถูกผูกไว้กับวัตถุเฉพาะStringและไม่สามารถเขียนทับได้ finalคุณสามารถอ่านเกี่ยวกับการทำงานกับตัวแปรอ้างอิงและการโต้ตอบกับคำสงวนได้ ในเนื้อหา " ประเภทข้อมูลอ้างอิงใน Java "

วิธีการโทร

ดังนั้นเราจึงได้แยกแยะการสร้างวิธีการต่างๆ แล้ว ตอนนี้เรามาพูดถึงการใช้มันกันดีกว่า จะเรียกเมธอดใน Java ได้อย่างไร? ทุกวิธีใน Java อยู่ในคลาส เพื่อทำความเข้าใจว่าวิธีการโทรใน Java ทำงานอย่างไร เรามาเรียนกันในชั้นเรียน:

public class StringConstructor {
  public String constructHelloSentence(String name) {
     String resultSentence = "Hello world! My name is " + name;
     System.out.println(resultSentence);
     return resultSentence;
  }
}

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

class Application{
  public static void main(String[] args) {
     StringConstructor stringConstructor = new StringConstructor();
     stringConstructor.constructHelloSentence("Den");
  }
}

ในอาร์กิวเมนต์ของวิธีการของเรา เราได้ส่งสตริง (ชื่อ) ที่เราต้องการเห็นในสตริงผลลัพธ์ที่แสดงบนหน้าจอ:

Hello world! My name is Den

นอกจากนี้ยังควรระลึกไว้ด้วยว่าวิธีการต่างๆ สามารถนำมาใช้ซ้ำได้หลายครั้งตามที่เราต้องการ - ไม่มีข้อจำกัด

นี้

คุณมักจะเห็นคำหลักในโค้ดthisเช่นเดียวกับใน setters:

public void setValue(Long value) {
   this.value = value;
}

และมันหมายความว่าอะไร? thisใน Java นี่คือการอ้างอิงถึงอ็อบเจ็กต์ปัจจุบันของคลาสนี้ ตัวอย่างเช่น ถ้าเราสร้างวัตถุ:

StringConstructor stringConstructor = new StringConstructor();

จากนั้นthisภายในวัตถุstringConstructorก็จะมีลิงก์ไปยังวัตถุเดียวกัน thisใช้เพื่ออ้างถึงตัวแปรอ็อบเจ็กต์ (เช่นเดียวกับใน setter ด้านบน) และเพื่อเรียกเมธอดบางอย่าง เราสามารถเขียนชั้นเรียนของเราใหม่ได้เล็กน้อย:

public class StringConstructor {
 
  public String constructHelloSentence(String name) {
     String resultSentence = this.getSentence()  + name;
     System.out.println(resultSentence);
     return resultSentence;
  }
 
  private String getSentence() {
     return "Hello world! My name is ";
  }
}

เราthisเรียกเมธอดของอ็อบเจ็กต์นี้เพื่อรับสตริงที่ต้องการ แต่ตามกฎแล้ว สิ่งนี้แทบจะไม่ได้ใช้กับเมธอดเลย เนื่องจากถึงแม้จะไม่มีมันก็มีการอ้างอิงถึงเมธอดของอ็อบเจ็กต์ที่กำหนด โดยส่วนใหญ่จะใช้สำหรับตัวแปรอ็อบเจ็กต์

วิธีการโอเวอร์โหลด

สมมติว่าเราต้องการวิธีการที่ดำเนินการตามตรรกะเดียวกัน แต่ในHello world! worldเราต้องการแทรกคำของเราเอง (สตริง) แทน แต่เรามีวิธีการอยู่constructHelloSentenceแล้ว แล้วเราจำเป็นต้องคิดชื่อใหม่สำหรับวิธีการที่มีฟังก์ชันการทำงานเหมือนกันหรือไม่? ไม่ว่าจะเป็นอย่างไร: ในขณะนี้ วิธีการโอเวอร์โหลดมาช่วยเราแล้ว การโอเวอร์โหลดเมธอดคือการใช้ชื่อเมธอดเดียวกันมากกว่าหนึ่งครั้งเมื่อประกาศในคลาส จากมุมมองของไวยากรณ์ของภาษา ไม่สามารถมีชื่อที่เหมือนกันสองชื่อในบางพื้นที่ท้องถิ่นได้ แต่ก็เป็นไปได้ที่จะประกาศวิธีการที่มีชื่อเดียวกันแต่มีข้อโต้แย้งต่างกัน กล่าวอีกนัยหนึ่ง คลาสมีการโอเวอร์โหลดเมื่อมีเมธอดตั้งแต่สองเมธอดที่มีชื่อเหมือนกันแต่ข้อมูลอินพุตต่างกัน:

public class Constructor {
 
  public String constructHelloSentence(String name) {
     String resultSentence = "Hello world! My name is " + name;
     System.out.println(resultSentence);
     return resultSentence;
  }
 
  protected String constructHelloSentence(String firstName, String secondName) {
     String resultSentence = "Hello " + firstName + "! My name is " + secondName;
     System.out.println(resultSentence);
     return resultSentence;
  }
}

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