ความแตกต่างระหว่าง Static method และ Instance method

ฉันแค่อ่านข้อความที่ให้ไว้ในหนังสือเรียนและฉันไม่แน่ใจจริงๆว่าฉันเข้าใจสิ่งที่มันพูด โดยพื้นฐานแล้วจะบอกฉันว่าเมธอดแบบคงที่หรือคลาสเมธอดนั้นมีคีย์เวิร์ด "ตัวแก้ไข" แบบคงที่ แต่ฉันไม่รู้จริงๆว่ามันหมายถึงอะไร?

ใครช่วยอธิบายให้ฉันเข้าใจง่ายๆว่า Static หรือ Class Methods คืออะไร

นอกจากนี้ฉันขอคำอธิบายง่ายๆเกี่ยวกับวิธีการของอินสแตนซ์ได้หรือไม่

นี่คือสิ่งที่พวกเขาให้ฉันในตำราเรียน:

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

ลักษณะที่เรียกใช้เมธอดแบบคงที่ภายในนิยามของวิธีการอื่นจะแตกต่างกันไปขึ้นอยู่กับว่าทั้งสองวิธีเป็นของคลาสเดียวกัน ในตัวอย่างข้างต้นแฟกทอเรียลและเมนเป็นทั้งเมธอดของคลาส MainClass เป็นผลให้การเรียกใช้แฟกทอเรียลในคำจำกัดความของ main เพียงแค่อ้างอิงชื่อเมธอด "แฟกทอเรียล"

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

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

คุณสามารถทำได้เพื่อดำเนินการวิธีการคงที่:

MyClass.staticMethod();  // Simply refers to the class's static code

แต่ในการดำเนินการวิธีการที่ไม่คงที่คุณต้องทำสิ่งนี้:

MyClass obj = new MyClass();//Create an instance
obj.nonstaticMethod();  // Refer to the instance's class's code

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

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

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

Person.staticMethod();           //accessing static method.

สำหรับวิธีการไม่คงที่คุณต้องสร้างอินสแตนซ์ของคลาส

Person person1 = new Person();   //instantiating
person1.nonStaticMethod();       //accessing non-static method.

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

ความแตกต่างระหว่าง Static method และ Instance method

1. วิธีการอินสแตนซ์เป็นวิธีการที่ต้องสร้างวัตถุของคลาสก่อนจึงจะสามารถเรียกใช้ได้ Static method เป็นวิธีการใน Java ที่สามารถเรียกได้โดยไม่ต้องสร้าง object ของ class

2. วิธีการคงที่ถูกประกาศด้วยคำหลักแบบคงที่ วิธีอินสแตนซ์ไม่ได้ใช้คีย์เวิร์ดแบบคงที่

3. Static method หมายถึงซึ่งจะมีอยู่เป็นสำเนาเดียวสำหรับคลาส แต่วิธีการของอินสแตนซ์มีหลายสำเนาขึ้นอยู่กับจำนวนอินสแตนซ์ที่สร้างขึ้นสำหรับคลาสนั้น

4. วิธีการคงที่สามารถเรียกใช้โดยใช้การอ้างอิงคลาส วิธีการอินสแตนซ์หรือไม่คงที่ถูกเรียกใช้โดยใช้การอ้างอิงอ็อบเจ็กต์

5. วิธีการคงที่ไม่สามารถเข้าถึงวิธีการของอินสแตนซ์และตัวแปรอินสแตนซ์โดยตรง วิธีการอินสแตนซ์สามารถเข้าถึงตัวแปรคงที่และวิธีการแบบคงที่ได้โดยตรง

อ้างอิง: geeksforgeeks

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

ในวิธีการคงที่ => ไม่มีสิ่งที่เรียกว่า 'this' เช่นช่างซ่อมคนเดียวกัน (วิธีคงที่) เมื่อคุณโทรหาเขาคุณต้องระบุว่าจะเรียกช่างซ่อมคนไหน (เช่นช่างไฟฟ้า) และเขาจะมาซ่อมทีวีของคุณเท่านั้น แต่เขาไม่มีเครื่องมือในการแก้ไขสิ่งอื่น ๆ (ไม่มีพารามิเตอร์ 'this')

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

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

Myclass.get();

ในวิธีการเช่นแต่ละวัตถุจะมีพฤติกรรมที่แตกต่างกันดังนั้นพวกเขาจึงต้องเรียกใช้เมธอดโดยใช้อินสแตนซ์วัตถุ เช่น:

Myclass x = new Myclass();
x.get();

หากสถานะของเมธอดไม่ควรเปลี่ยนแปลงหรือจะไม่ใช้ตัวแปรอินสแตนซ์ใด ๆ

คุณต้องการเรียกวิธีที่ไม่มีอินสแตนซ์

หากใช้ได้เฉพาะกับอาร์กิวเมนต์ที่ให้ไว้

ฟังก์ชันยูทิลิตี้เป็นตัวอย่างที่ดีของวิธีการแบบคงที่ เช่น math.pow () ฟังก์ชันนี้จะไม่เปลี่ยนสถานะสำหรับค่าที่แตกต่างกัน ดังนั้นจึงเป็นแบบคงที่

ในระยะสั้นวิธีการคงที่และตัวแปรคงเป็นระดับคลาสโดยที่วิธีการของอินสแตนซ์และตัวแปรอินสแตนซ์เป็นระดับอินสแตนซ์หรือออบเจ็กต์

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

class A {
    int a;
    int b;

    public void setParameters(int a, int b){
        this.a = a;
        this.b = b;
    }
    public int add(){
        return this.a + this.b;
   }

    public static returnSum(int s1, int s2){
        return (s1 + s2);
    }
}

ในตัวอย่างข้างต้นเมื่อคุณเรียก add () เป็น:

A objA = new A();
objA.setParameters(1,2); //since it is instance method, call it using object
objA.add(); // returns 3 

B objB = new B();
objB.setParameters(3,2);
objB.add(); // returns 5

//calling static method
// since it is a class level method, you can call it using class itself
A.returnSum(4,6); //returns 10

class B{
    int s=8;
    int t = 8;
    public addition(int s,int t){
       A.returnSum(s,t);//returns 16
    }
}

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

วิธีการอินสแตนซ์เทียบกับวิธีคงที่

1. วิธีการอินสแตนซ์สามารถเข้าถึงวิธีการของอินสแตนซ์และตัวแปรอินสแตนซ์ได้โดยตรง

2. วิธีการอินสแตนซ์สามารถเข้าถึงตัวแปรคงที่และวิธีการแบบคงที่ได้โดยตรง

3. วิธีการคงที่สามารถเข้าถึงตัวแปรคงที่และวิธีการคงที่โดยตรง

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

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