วิธีการจาวา

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

วิธีการใน Java คืออะไร?

เมธอดจะกำหนดพฤติกรรมของอ็อบเจ็กต์และเป็นลำดับของคำสั่งที่อนุญาตให้คุณดำเนินการบางอย่างในโปรแกรม ในภาษาการเขียนโปรแกรมอื่น วิธีการมักเรียกว่า "ฟังก์ชัน" และถูกต้องเช่นกัน ที่จริงแล้ว วิธีการก็คือฟังก์ชันในความหมายทางคณิตศาสตร์ โดยปกติแล้วบางสิ่งจะถูกส่งไปยังอินพุตของเมธอด (ตัวแปรบางตัว) ตัวแปรเหล่านี้จะถูกประมวลผลตามลำดับคำสั่ง จากนั้นเมธอดจะสร้างผลลัพธ์ มีโอกาสที่คุณจะเจอวิธีการต่างๆ อย่างน้อยก็public static void main(String[] args) โดยทั่วไปวิธีนี้จะเริ่มการทำงานของโปรแกรม Java

จะประกาศวิธีการใน Java ได้อย่างไร?

วิธีการทั้งหมดใน Java ถูกสร้างขึ้นภายในคลาส มีการประกาศดังต่อไปนี้:

accessSpecifier ReturnType name (parameter list) {
//method body
}

ตัวอย่างเช่น:

public int addTwoNumbers (int a, int b){

//method body
return…
}

โดยที่publicเป็นตัวระบุการเข้าถึงintคือประเภทของตัวแปรที่เมธอดส่งคืนaddTwoNumbersคือชื่อของเมธอดaและbเป็นพารามิเตอร์ของเมธอด มาดูรายละเอียดกันอีกสักหน่อย ตัวระบุการเข้าถึงใช้เพื่อกำหนดประเภทการเข้าถึงของวิธีการ พวกเขาสามารถเป็นดังนี้:

• public : เข้าถึงวิธีการได้จากคลาสใดก็ได้

• private : เข้าถึงได้ภายในคลาสที่ถูกกำหนดไว้

• protected : การเข้าถึงใช้ได้เฉพาะภายในแพ็คเกจหรือคลาสย่อยอื่น ๆ ในแพ็คเกจอื่น

• default : เข้าถึงได้จากแพ็คเกจที่ประกาศไว้ ในกรณีนี้จะไม่มีการเขียนคำว่า "ค่าเริ่มต้น"

ประเภทการส่งคืน กำหนดประเภทที่วิธีนี้ส่งคืน ในตัวอย่างข้างต้นintคือประเภทการส่งคืน หากวิธีการส่งคืนสิ่งใดประเภทการส่งคืนจะเป็นโมฆะ:

public void printSomething (String myString) {}

ชื่อวิธีการคือชื่อเฉพาะของวิธีการของคุณ เราจะอธิบายกฎการตั้งชื่อ Java บางส่วนในบทความนี้ ในวิธีการข้าง ต้น ชื่อคือaddTwoNumbersและprintSomething รายการพารามิเตอร์คือรายการอาร์กิวเมนต์ (ชนิดข้อมูลและชื่อตัวแปร) ที่เมธอดใช้ ในตัวอย่างแรกด้านบน "int a, int b" คือพารามิเตอร์ ส่วนตัวอย่างที่สอง String myStringเป็นอาร์กิวเมนต์ คุณสามารถเว้นฟิลด์นี้ว่างไว้ได้หากคุณไม่ต้องการใช้พารามิเตอร์ใดๆ ในวิธีการนี้

ตัวอย่างพารามิเตอร์วิธีการ

public void printSomething (String myParameter1, int myParameter2) {}

นี่คือตัวแปรสองตัวได้แก่myParameter1และmyParameter2 เป็นพารามิเตอร์ของวิธีการ คือชุดคำสั่งที่อยู่ในวงเล็บปีกกาที่เมธอดจะดำเนินการ หากประเภทการส่งคืนของวิธีการไม่เป็นโมฆะ คำสำคัญ การส่งคืนจะต้องมีอยู่ในเนื้อหาของวิธีการ returnตามด้วยอาร์กิวเมนต์ที่วิธีนี้ส่งคืน ดังนั้น ในการสร้างวิธีการ คุณจะต้องระบุชื่อพร้อมกับวงเล็บเหลี่ยม และในวงเล็บ หากจำเป็น ตัวแปรที่วิธีการนั้นจะดำเนินการ ก่อนที่ชื่อวิธีการจะเป็นตัวระบุการเข้าถึงและเป็นประเภทของตัวแปรที่วิธีการส่งคืน หรือถือเป็นโมฆะหากวิธีการส่งคืนสิ่งใดๆ ในวงเล็บปีกกา เราจะเขียนวิธีการจริง ซึ่งเป็นลำดับคำสั่งที่มักใช้กับอาร์กิวเมนต์ของวิธีการนั้น นี่คือตัวอย่างของวิธีการค้นหาตัวเลขที่ใหญ่ที่สุดในอาร์เรย์แล้วส่งคืน

public int findBiggest(int[] numbers) {
   int max;
   max = numbers[0];
   for (int i = 1; i < numbers.length; i++) {
       if (max < numbers[i]) {
           max = numbers[i];
       }
   }
   return max;
}

จะตั้งชื่อวิธีการได้อย่างไร?

ไม่มีกฎเกณฑ์ที่เข้มงวดสำหรับวิธีการตั้งชื่อ แต่มีแนวทางที่คุณควรปฏิบัติตามหากคุณวางแผนที่จะพัฒนาอย่างมืออาชีพใน Java ชื่อวิธีการมักจะเป็นคำกริยา เขียนด้วยตัวพิมพ์เล็ก ขึ้นต้นด้วยตัวพิมพ์เล็ก แต่ใช้ตัวพิมพ์ใหญ่สำหรับแต่ละคำที่ตามมา (camelCase) นี่คือตัวอย่างบางส่วน:

int addTwoNumbers (int a, int b)
void run()

วิธีการเรียกเมธอด

หากต้องการเรียกใช้เมธอด ก็เพียงพอที่จะเขียนชื่อและตั้งค่าตัวแปรที่เกี่ยวข้องหากอยู่ในการประกาศ ลองเรียก เมธอด findBiggestใน เมธอด หลัก :

public static void main(String[] args) {
  int[] array = new int[] {5, 7, -2, 6, 7, 1};
  int max = findBiggest(array);
   System.out.println("the biggest number in array is: " + max);
  }

ผลลัพธ์ของโปรแกรมนี้คือ:

วิธีการประเภทต่างๆ ใน ​​Java

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

วิธีการที่กำหนดไว้ล่วงหน้า

วิธีการไลบรารีที่กำหนดไว้ล่วงหน้าหรือมาตรฐานมีอยู่ใน Java แน่นอนว่าโปรแกรมเมอร์ทุกคนสามารถใช้มันหรือแม้แต่แก้ไขมันในเครื่องสำหรับโปรแกรมของพวกเขาได้ ไลบรารีคลาส Java ตั้งอยู่ในไฟล์เก็บถาวร Java (เช่น *jar) พร้อมด้วย Java virtual machine (JVM) และสภาพแวดล้อมรันไทม์ Java ตัวอย่างเช่น วิธีการของ คลาส Mathเช่นmin() , max()หรือabs( ) หรือวิธีการจัดการสตริงเช่นconcat( ) มาสร้างคลาสด้วย เมธอด หลักและเรียกใช้เมธอดไลบรารีมาตรฐานสองสามวิธี

import static java.lang.Math.max;

public class Test {

    public static void main(String[] args) {
       int a = 5;
       int b = 7;
       int max = max(a,b);
       System.out.println(max);
       String str1 = "I am ";
       String str2 = "here ";
       String str3 = str1.concat(str2);
       System.out.println(str3);


   }

}

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

int max = Math.max(a,b);

วิธีการที่ผู้ใช้กำหนด

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

import java.util.Scanner;

public class Test {

   public void repeater() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

การสร้างวิธีการแบบคงที่ใน Java

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

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;


public class Numbers {


   public static int findMax(int left, int right) {
       return (left < right) ? right : left;

   }


   public static boolean isNegative(int number) {
       return number < 0;
   }

   public static long power(long number, int deg) {

       if (deg == 0) {
           number = 1;
           return number;
       } else {
           number = power(number, deg - 1) * number;
           return number;
       }
   }

   public static long abs(long number) {
       return number > 0 ? number : -number;
     }


    public static void main(String[] args) {

       int a = 5;
       int b = 7;
       long c = -7;
       long abs = abs(c);
       System.out.println(abs);
       System.out.println(findMax(a,b));

   }

}

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

การใช้วิธีการอินสแตนซ์ในโค้ด Java

วิธีการอินสแตนซ์หรือวิธีปกติสามารถเรียกได้บนอินสแตนซ์ของคลาสที่มีการกำหนดวิธีการไว้

public class Cat implements Voice{
   String name;
   String breed;
   int year;


   public void talk() {
       System.out.println("meow meow");
   }
}

หากต้องการเรียกใช้ เมธอด talk()คุณต้องสร้างอินสแตนซ์ของ คลาส Cat :

public class Demo {
   public static void main(String[] args) {
       Cat cat = new Cat ();
       cat.talk();

   }
}

ผลลัพธ์ของโปรแกรมนี้อยู่ที่นี่:

วิธีการเชิงนามธรรมใน Java

วิธีการเชิงนามธรรมใน Java เป็นวิธีการที่ไม่มีการใช้งาน นั่นคือไม่มีโค้ดเมื่อมีการประกาศ สามารถประกาศได้เฉพาะในคลาสนามธรรมและนำไปใช้ในคลาสสืบทอดที่ไม่ใช่นามธรรมเท่านั้น มาสร้างคลาสนามธรรมด้วยเมธอดนามธรรมmyMethodAdd()กัน

abstract class DemoAbs {
   abstract void myMethodAdd();
}

ตอน นี้ เรามาสร้าง คลาส ย่อยของคลาสนามธรรมนี้DemoAbs ที่นี่เราจำเป็นต้องใช้เมธอด myMethodAdd()

public class myClass extends DemoAbs {

   void myMethodAdd() {
       System.out.println("hello");
   }

   public static void main(String[] args) {
       DemoAbs demoAbs = new myClass();
       demoAbs.myMethodAdd();
   }
}

การจัดสรรหน่วยความจำสำหรับการเรียกเมธอด

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

บทสรุป

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