พารามิเตอร์เมธอดใน Java

"สวัสดี Amigo! ฉันหวังว่าคุณจะสนุกกับการแก้ปัญหาโดยใช้วิธีการของคุณเอง และคุณรู้ว่าการสร้างวิธีการนั้นสะดวกเพียงใด ตอนนี้เรามาพูดถึงหัวข้อที่น่าสนใจที่สุดกันดีกว่า"

"คุณทำให้ฉันสนใจ ดิเอโก... หัวข้อใหม่?"

"ทุกหัวข้อเป็นเรื่องใหม่สำหรับคุณ หุ่นยนต์ตัวน้อยของฉัน! และหัวข้อนี้ก็ไม่มีข้อยกเว้น แม้ว่าจะเป็นอีกครั้งเกี่ยวกับวิธีการ คุณอาจสังเกตเห็นจากวิธีการเช่นนั้นว่าเราสามารถส่งข้อโต้แย้งไปยังวิธีการได้ เมื่อเราอยู่ในวิธี System.out.println()การ เราเรียกมันว่าพารามิเตอร์"

"พารามิเตอร์คือสิ่งที่เราเขียนไว้ในวงเล็บใช่หรือไม่"

"ใช่เลย และอันที่จริง พารามิเตอร์ช่วยเพิ่มประโยชน์ที่เราได้รับจากการสร้างและการใช้วิธีการอย่างมาก"

"ฉันเข้าใจสิ่งที่คุณพูดเกี่ยวกับการใช้มัน และกลายเป็นว่าฉันได้ทำไปแล้ว เราจะประกาศเมธอดด้วยพารามิเตอร์ได้อย่างไร"

"จริง ๆ แล้วค่อนข้างง่าย:

public static void name(parameters)
{
  method body
}

" nameชื่อเฉพาะของเมธอดอยู่ที่ไหนและmethod bodyแทนคำสั่งที่ประกอบเป็นเมธอด และparametersเป็นตัวยึดตำแหน่งสำหรับพารามิเตอร์เมธอด โดยคั่นด้วยเครื่องหมายจุลภาค"

"อืม... ฉันคิดว่าฉันเข้าใจ... หรือไม่ก็อาจจะไม่..."

"ให้ฉันให้รายละเอียดเพิ่มเติมเกี่ยวกับเทมเพลตนี้ เพื่อให้คุณมั่นใจว่าคุณเข้าใจว่าคุณเข้าใจ:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

นี่คือตัวอย่างบางส่วน:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

"อา... ตอนนี้มันชัดเจนแล้ว และถ้าเราไม่ต้องการให้เมธอดมีพารามิเตอร์ เราก็แค่เว้นวงเล็บว่างไว้"

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

"ตัวอย่างเช่น ลองเขียนเมธอดที่แสดงบรรทัดข้อความตามจำนวนครั้งที่กำหนด มีความคิดเกี่ยวกับวิธีการทำเช่นนี้หรือไม่"

"อืม... ดูเหมือนว่าฉันจะรู้วิธีเขียนโค้ดเพื่อแสดงสตริงบนหน้าจอมาหลายครั้งแล้ว..."

"คุณระบุสตริงที่จะแสดงได้อย่างไร และคุณระบุจำนวนบรรทัดที่แสดงได้อย่างไร คุณเดาได้ไหม"

"สิ่งต่าง ๆ เริ่มชัดเจนขึ้น ... อาจด้วยความช่วยเหลือของพารามิเตอร์วิธีการ"

"แน่นอน พารามิเตอร์สตริงสำหรับบรรทัดข้อความ และพารามิเตอร์ตัวเลขสำหรับจำนวนบรรทัดที่แสดง โค้ดที่ทำสิ่งนี้จะมีลักษณะดังนี้:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"ทุกครั้งที่เมธอดถูกเรียกใช้ พารามิเตอร์ของเมธอดจะถูกกำหนดค่าที่ส่งผ่าน และจากนั้นเราจะเริ่มดำเนินการคำสั่งภายในเมธอด

ข้อโต้แย้ง

"ฉันต้องการให้คุณให้ความสนใจเป็นพิเศษกับเมธอดการโทรที่มีพารามิเตอร์ ค่าที่ส่งผ่านไปยังเมธอดมักจะเรียกว่าอาร์กิวเมนต์เมื่อค่าเหล่านั้นถูกส่งผ่านไปยังเมธอด

ลองดูตัวอย่างของเราอีกครั้ง:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"เมื่อprintLinesเมธอดถูกเรียกเป็นครั้งแรก พารามิเตอร์ถูกกำหนดให้เป็นค่าต่อไปนี้:

String text = "Hi", int count = 10.

"เมื่อprintLinesเมธอดถูกเรียกเป็นครั้งที่สอง พารามิเตอร์ของเมธอดจะถูกกำหนดค่าต่างๆ กัน:

String text = "Bye", int count = 20.

"พารามิเตอร์ไม่มากและไม่น้อยไปกว่าตัวแปรที่กำหนดค่าบางอย่างเมื่อเรียกใช้เมธอด ค่า"Hi", "Bye", 10, และ20เรียกตัวเองว่าอาร์กิวเมนต์"

"ฉันจะพยายามจดจำความแตกต่างและไม่สับสนกับแนวคิดเหล่านี้"

ชื่อตัวแปรที่ขัดแย้งกันเมื่อเรียกใช้เมธอด

"เมื่อคุณเรียกใช้เมธอด คุณสามารถใช้ตัวแปรเป็นอาร์กิวเมนต์ได้

"ก็มีเหตุผล!"

"มันสมเหตุสมผล แต่อาจทำให้เกิดปัญหาได้ กลับไปที่ตัวอย่างของเราอีกครั้ง แต่คราวนี้เราจะย้ายอาร์กิวเมนต์ไปยังตัวแปรที่แยกกัน:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     String n = 10;
     printLines(str, n);
   }
}

"อืม... ฉันไม่เห็นความยุ่งยาก เรามีstrตัวแปร ค่าของมันถูกกำหนดให้กับtextพารามิเตอร์เมื่อเมธอดถูกเรียก เรามีnตัวแปร ค่าของมันถูกกำหนดให้กับcountพารามิเตอร์เมื่อเมธอดถูกเรียก" "จนถึงตอนนี้ทุกอย่างชัดเจน"

"ดี ดี ตอนนี้เรามาเปลี่ยนชื่อตัวแปรของเราในเมธอดmain:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     String count = 10;
     printLines(text, count);
   }
}

“จงใส่ใจสองสิ่ง

อันดับแรก:เรามีตัวแปรที่มีชื่อเดียวกันในเมธอดต่างๆ สิ่งเหล่านี้เป็น ตัวแปร ที่แตกต่างกัน (เราจงใจพรรณนาโดยใช้สีที่ต่างกัน) ทุกอย่างทำงานเหมือนกับในตัวอย่างก่อนหน้านี้ โดยที่ตัวแปรในเมธอดmainถูกตั้งชื่อstrและn

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

"หลังจากที่เราเปลี่ยนชื่อตัวแปรในเมธอดหลักแล้ว ก็ไม่มีอะไรเปลี่ยนแปลง ก่อนหน้านี้เป็นตัวแปรที่แตกต่างกันในเมธอดต่างๆและมันก็ยังคงอยู่ ไม่มีการเชื่อมต่อที่มหัศจรรย์ระหว่างtextตัวแปรทั้งสอง"

"ตอนนี้ฉันรู้."

ผ่านการอ้างถึงเมธอด

"ฉันหวังว่าคุณจะเข้าใจทุกสิ่งที่ฉันบอกคุณเกี่ยวกับการส่งผ่านข้อโต้แย้งไปยังวิธีการ ฉันพูดอย่างนั้น เพราะตอนนี้เราจะเจาะลึกลงไปในหัวข้อนี้อีกเล็กน้อย ฟังให้ดี"

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

"เมื่อนักพัฒนากำหนดตัวแปรอาร์เรย์อื่นให้กับตัวแปรอาร์เรย์ จะเกิดอะไรขึ้น"

"พวกเขาชี้ไปที่ที่อยู่เดียวกันหรือไม่"

"ถูกต้อง ตัวแปรทั้งสองเริ่มอ้างถึงพื้นที่เดียวกันในหน่วยความจำ:

"แล้วจะเกิดอะไรขึ้นถ้าหนึ่งในตัวแปรเหล่านี้เป็นพารามิเตอร์เมธอด?

class Solution
{
   public static void sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }

   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"สิ่งเดียวกันทุกประการเกิดขึ้น: dataพารามิเตอร์จะมีการอ้างอิงไปยังพื้นที่หน่วยความจำเดียวกันกับmonthsตัวแปร เมื่อเรียกใช้เมธอด การกำหนดอย่างง่ายจะเกิดขึ้น:data = months

"และเนื่องจากตัวแปรทั้งสองอ้างถึงพื้นที่หน่วยความจำเดียวกันที่จัดเก็บจำนวนเต็ม ดังนั้นเมธอดsumจึงไม่เพียงแต่อ่านค่าจากอาร์เรย์เท่านั้น แต่ยังเปลี่ยนแปลงค่าเหล่านั้นได้ด้วย!"

"ฉันเดาว่าฉันเข้าใจแล้ว แต่ฉันต้องการตัวอย่างมากกว่านี้!"

"ตัวอย่างเช่น เราสามารถเขียนเมธอดของเราเองที่เติมอาร์เรย์สองมิติด้วยค่าเดียวกัน มันอาจจะมีลักษณะดังนี้:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

วิธีการที่มีชื่อเดียวกัน

"ตอนนี้ให้กลับไปที่ชื่อเมธอดอีกครั้ง"

"ฉันนึกไม่ออกว่าจะพูดอะไรได้อีกเกี่ยวกับชื่อ!"

"มาตรฐานภาษา Java กำหนดให้ทุกเมธอดในคลาสเดียวกันมีชื่อไม่ซ้ำกัน

"ดังนั้นจึงเป็นไปไม่ได้ที่จะประกาศเมธอดที่มีชื่อเหมือนกันสองเมธอดในคลาสเดียวกัน"

"ตอนนี้ — ระวังให้ดี! เมธอดในคลาสสามารถมีชื่อเหมือนกันได้! แต่ในกรณีนี้ มันต้องมีพารามิเตอร์ต่างกัน กล่าวอีกนัยหนึ่ง เมธอดจะถูกเปรียบเทียบเพื่อความเหมือน ไม่เพียงแต่ชื่อเท่านั้นที่ถูกนำมาพิจารณา แต่ยังรวมถึง ประเภทของพารามิเตอร์ ! โปรดทราบว่าฉันพูดเฉพาะ types. ชื่อของพารามิเตอร์จะไม่นำมาพิจารณาตัวอย่าง:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

"ฉันงงไปหมดแล้ว! ทำไมเราต้องการทั้งหมดนี้ ทำไมบางเมธอดจึงถือว่าเหมือนกันในขณะที่เมธอดอื่นต่างกันและทำไมชื่อพารามิเตอร์จึงไม่นำมาพิจารณาเมื่อกำหนดความเป็นเอกลักษณ์ของเมธอด ทำไมความเป็นเอกลักษณ์จึงจำเป็นที่ ทั้งหมด?"

"สิ่งสำคัญคือเมื่อคอมไพเลอร์คอมไพล์โปรแกรม จะต้องรู้แน่ชัดว่าคุณต้องการเรียกใช้เมธอดใดในตำแหน่งใดก็ตาม

"ตัวอย่างเช่น ถ้าคุณเขียนคอมไพเลอร์จะฉลาดและสรุปได้ง่ายๆ ว่าคุณตั้งใจจะเรียกเมธอดที่นี่ด้วยพารามิเตอร์ แต่ถ้าคุณเขียนคอมไพเลอร์จะเห็นการเรียกเมธอดพร้อมพารามิเตอร์ มันไม่มีความคิด โปรแกรมเมอร์ตั้งชื่ออะไรให้กับพารามิเตอร์เมื่อประกาศเมธอด"System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

อาห์ ดูเหมือนว่าจะเริ่มผ่านพ้นไปได้!

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

"และฉันเดาว่านั่นเป็นสาเหตุที่ไม่นำมาพิจารณาเมื่อกำหนดความเป็นเอกลักษณ์ของวิธีการ"

"ใช่ ถูกต้องทั้งหมด ชื่อของเมธอดและประเภทของพารามิเตอร์เรียกว่าลายเซ็นเมธอดตัวอย่างเช่นsum (int, int)"

"ดังนั้นแต่ละคลาสต้องมีเมธอดที่มีลายเซ็นเฉพาะมากกว่าเมธอดที่มีชื่อไม่ซ้ำกัน"

"ทำได้ดีมาก Amigo! คุณสรุปบทเรียนนี้ได้อย่างสมบูรณ์แบบ หากยังมีอะไรไม่ชัดเจน ไม่ต้องตกใจ หัวข้อนี้จะชัดเจนหลังจากผ่านไปสองสามงาน"