ใน CodeGym นักเรียนจะได้รู้จักกับ Java คำสำคัญ นี้อย่างแท้จริงตั้งแต่บทเรียนแรก เมื่อเวลาผ่านไปความหมายของมันก็ชัดเจน แต่เมื่อมองย้อนกลับไป หลายๆ คนคงยอมรับกับตัวเองว่าไม่เข้าใจ Zen ของคีย์เวิร์ดนี้มานาน บทความนี้จะดึงม่านปิดความลับของ คีย์เวิร์ด นี้สำหรับใครก็ตามที่ยังไม่สามารถทำได้... ฉันมีการอ้างอิง Java ของ Schildtแล้ว ในหน้า 171 คุณจะเห็นว่าคีย์เวิร์ดนี้จำเป็นสำหรับวิธีการอ้างอิงวัตถุที่เรียกมัน เราสามารถจบบทเรียนด้วยสิ่งนั้น แต่เราต้องการข้อมูลเฉพาะ ตามกฎแล้ว คุณต้องใช้สิ่งนี้ ในสองกรณี:
  1. เมื่อตัวแปรอินสแตนซ์และตัวแปรเมธอด/คอนสตรัคเตอร์มีชื่อเดียวกัน
  2. เมื่อคุณต้องการเรียกใช้คอนสตรัคเตอร์ประเภทใดประเภทหนึ่ง (เช่น คอนสตรัคเตอร์เริ่มต้นหรือคอนสตรัคเตอร์ที่กำหนดพารามิเตอร์) จากคอนสตรัคเตอร์ประเภทอื่น สิ่งนี้เรียกว่าการเรียกตัวสร้างที่ชัดเจน
และนั่นคือทั้งหมด — มีเพียงสองกรณีที่มีการใช้คำหลักที่น่ากลัวนี้ ทีนี้ลองดูตัวอย่างทั้งสองกรณีนี้

ตัวอย่างที่ 1: ตัวแปรอินสแตนซ์และตัวแปรเมธอดมีชื่อเดียวกัน

สมมติว่าเรามี คลาส Humanที่กำหนดฟิลด์ชื่อ: ลองสร้าง setter สำหรับ ตัวแปร ชื่อ (setter ทำงานได้อย่างสมบูรณ์ — ไม่มี catch ที่นี่): 

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}
โปรดทราบว่าเราส่งString newNameไปยัง เมธอด setName setter เราประกาศตัวแปรใหม่และสามารถตั้งชื่อตัวแปรตามที่เราต้องการได้ เพราะจะมองเห็นได้เฉพาะในวงเล็บปีกกา ({}) ที่ล้อมรอบเมธอดsetName โปรดทราบว่าตัวตั้งค่ามีบรรทัดเดียว: 

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

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}
แต่ที่นี่เราพบปัญหา ตอนนี้เรามีตัวแปรสองตัวที่มีชื่อเดียวกัน ชื่อสตริงหนึ่ง ชื่อ เป็นของ คลาส Human ในขณะที่ ชื่อสตริงอื่นเป็นของเมธอดsetName เป็นผลให้ JVM ไม่ทราบว่าตัวแปรใดที่คุณอ้างถึงเมื่อคุณเขียนบรรทัดต่อไปนี้ใน setter: 

name = name;
Java ถือว่าคุณหมายถึง ตัวแปร ชื่อ ที่ใกล้เคียงที่สุด เช่น ตัวแปรจากเมธอด setNameคำหลักนี้ (พร้อมตัวอย่าง) - 3ดังนั้น กลายเป็นว่าคุณแค่กำหนดตัวแปรชื่อ เมธอด ให้กับตัวมันเอง ซึ่งแน่นอนว่าไม่สมเหตุสมผลเลย ดังนั้น ภาษาจึงต้องการวิธีแยกแยะ ตัวแปร ชื่อคลาสHumanจาก ตัวแปร ชื่อในเมธอดsetName ปัญหานี้ได้รับการแก้ไขโดยการแนะนำ คีย์เวิร์ด นี้ซึ่งในกรณีนี้บ่งชี้ว่าคุณตั้งใจที่จะอ้างอิงตัวแปรที่เกี่ยวข้องกับอินสแตนซ์ของคลาสHumanไม่ใช่ตัวแปรในเมธอด: กล่าวอีกนัยหนึ่งนี่คำหลักนี้ (พร้อมตัวอย่าง) - 4หมายถึงวัตถุที่เรียกตามที่เรากล่าวถึงในตอนต้นของบทความ เป็นผลให้ เมธอด setNameตั้งชื่อบุคคลบนวัตถุที่สร้างขึ้น ด้านล่างนี้คือโค้ดของโปรแกรมโดยไม่ต้องใช้คีย์เวิร์ดนี้ รหัสสร้าง วัตถุ มนุษย์และกำหนดชื่อให้กับมัน: คำหลักนี้ (พร้อมตัวอย่าง) - 5และนี่คือรหัสที่มี คำหลัก นี้ : 

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        human1.print();
    }
}
class Human {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print() {
        System.out.println(name);
    }
}
ดังนั้นสิ่งนี้ช่วยให้เราหลีกเลี่ยงการแนะนำตัวแปรใหม่เพื่อแสดงถึงสิ่งเดียวกัน ทำให้โค้ดสะอาดขึ้นและยุ่งเหยิงน้อยลงด้วยตัวแปรพิเศษ

ตัวอย่างที่ 2: ใช้สิ่งนี้สำหรับการเรียกตัวสร้างที่ชัดเจน

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

class Human {
    int age;
    int weight;
    int height;

    Human(int age, int weight) {
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}
ขั้นแรกเราได้จัดเตรียมคอนสตรัคเตอร์ด้วยพารามิเตอร์สองตัว: int ageและint weight สมมติว่ามีรหัสสองบรรทัด: 

this.age = age;
this.weight = weight;
ต่อมาเราตัดสินใจเพิ่มตัวสร้างอีกตัวที่มีพารามิเตอร์สามตัว เพิ่มความสูงให้กับพารามิเตอร์อายุและน้ำหนักที่มีอยู่ คุณสามารถเขียนตัวสร้างใหม่ดังนี้: 

this.age = age;
this.weight = weight;
this.height = height;
แต่แทนที่จะทำซ้ำโค้ดที่มีอยู่ในตัวสร้างนี้ คุณสามารถใช้ คีย์เวิร์ด นี้เพื่อเรียกตัวสร้างอย่างชัดเจนด้วยพารามิเตอร์สองตัว: 

this(age, weight);
// and then initialize the missing variable:
this.height = height;
เหมือนกับว่าเรากำลังพูดกับตัวสร้างสามพารามิเตอร์:
  • เรียกตัวสร้างอื่นที่มีสองพารามิเตอร์นี้
  • แล้วเพิ่มตัวแปรอื่น
นั่นคือทั้งหมด =) สุดท้าย เราทราบว่าใน Java คีย์เวิร์ดนี้ใช้ในเมธอดและคอนสตรัคเตอร์เท่านั้น แต่วิธีนี้ จะถูกส่งผ่านไปยังเมธอดที่ไม่คงที่ทั้งหมดโดยปริยาย ( นั่นคือเหตุผลที่มักเรียกว่าพารามิเตอร์โดยปริยาย) และสามารถใช้เพื่ออ้างถึงวัตถุที่เรียกเมธอดได้ อย่ากลัวคำหลักนี้ เพราะคำนี้ไม่น่ากลัว