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

1. ผ่านการโต้แย้ง

และตอนนี้ความสนุกก็เริ่มขึ้น คุณอาจทราบอยู่แล้วจากวิธีการเช่นนั้น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("Hello", 10);
     printLines("Bye", 20);
   }
}

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

2. ข้อโต้แย้ง

ฉันต้องการดึงดูดความสนใจของคุณอีกเล็กน้อยเพื่อเรียกเมธอดด้วยพารามิเตอร์

ค่าที่ส่งผ่านไปยังเมธอดมักจะเรียกว่าอาร์กิวเมนต์เมื่อส่งผ่านไปยังเมธอด

ลองดูตัวอย่างอื่น:

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("Hello", 10);
     printLines("Bye", 20);
   }
}

เมื่อprintLines เรียกใช้เมธอดเป็นครั้งแรก พารามิเตอร์จะถูกกำหนดค่าต่อไปนี้
String text = "Hi", int count = 10:

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

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

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

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

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";
     int 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";
     int count = 10;
     printLines(text, count);
   }
}

ให้ความสนใจกับสองสิ่ง

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

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

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

4. ผ่านการอ้างอิงถึงวิธีการ

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

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

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

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

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

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

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

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

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);
   }
}

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

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

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

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

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()String

แต่ถ้าคุณเขียนคอมไพเลอร์จะเห็นการเรียกใช้เมธอดพร้อมพารามิเตอร์System.out.println(1.0)println()double

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

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

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