แก้ไข:ไม่สามารถอ้างอิงวิธีการที่ไม่คงที่จากบริบทแบบคงที่

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

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

วิธีการคงที่คืออะไร

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

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

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

class Students{ 

 int roll_no; 

 String name; 

 static String college = "InformationTech"; 

 static void change(){ 

 college = “Management"; } 

 Students (int number, String name_self){ 

 roll_no = number; 

 name = name_self;  } 

 void display (){System.out.println(rollno+" "+name+" "+college);} 

public static void main(String args[]){ 

Students.change(); 

Students stu_1 = new Students (100,"Mexican"); 

Students stu_2 = new Students (202,"American"); 

Students stu_3 = new Students (309,"British"); 

stu_1.display(); 

stu_2.display(); 

stu_3.display(); 

}  }

ผลลัพธ์ของโปรแกรมจะเป็น:

100 Mexican Management 202 American Management 309 British Management

คลาสและอินสแตนซ์ของคลาสต่างกันอย่างไร

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

เมื่อคุณเข้าใกล้มากขึ้น คุณจะเห็นรุ่นและยี่ห้อของรถ ที่นี่คุณจำ 'ตัวอย่าง' ของ 'รถยนต์' คลาสได้ คุณสมบัติทั้งหมดจะแสดงรายละเอียดที่นี่ ล้อ แรงม้า ขอบล้อ ฯลฯ

ตัวอย่างของคุณสมบัติได้แก่ คลาส 'car' ระบุว่ารถทุกคันควรมีล้อ รถที่คุณเห็น (ตัวอย่างของรถระดับเดียวกัน) มีขอบอัลลอยด์

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

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

ตอนนี้ เราจะดูกรณีต่างๆ ทั้งหมดที่การเขียนโค้ดของคุณอาจผิดพลาด และดูวิธีแก้ไขปัญหาชั่วคราว

ปัญหาที่ 1:คุณกำลังเรียกสิ่งที่ไม่มีอยู่จริง

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

private java.util.List<String> someMethod(){

    /* Some Code */

    return someList;           }

public static void main(String[] strArgs){         

     // The following statement causes the error. You know why..

    java.util.List<String> someList = someMethod();        }

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

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

ปัญหาที่ 2:วิธีการไม่คงที่

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

public class BookStoreApp2 {

    //constants for options

    Scanner input = new Scanner (System.in);

    public static void main(String[] args) {

        BookStoreItem[] item;//declaring array

        item = new BookStoreItem[10];//initializing array

        int itemType = -1;

        printMenu();

        getUserChoice();

        for (int i = 0; i < item.length; i++){

            }//end of switch statement

        }//end of for loop

        for (int i = 0; i < item.length; i++) {

        }//end of for

    }//end of main method

ในโค้ดนี้ คุณต้องแปลงทั้งสองวิธี printMenu() และ getUserChoice() เป็นวิธีการคงที่

ดังนั้น หากคุณต้องการหลีกเลี่ยงสถานการณ์เช่นนี้ คุณสามารถใช้ ตัวสร้าง แทนที่. ตัวอย่างเช่น คุณสามารถใช้เนื้อหาของเมธอด main() และวางไว้ในคอนสตรัคเตอร์

public BookStoreApp2()

{
   // Put contents of main method here}
After doing this, do the following inside your main() method:

public void main( String[] args )

{ 
new BookStoreApp2();           }

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