คำหลักนี้ {ในตัวอย่าง}

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

1. เมื่อตัวแปรอินสแตนซ์คลาสและตัวแปรเมธอด/ตัวสร้างมีชื่อเหมือนกัน
2. เมื่อคุณต้องการเรียก Constructor ประเภทหนึ่ง (เช่น Constructor ที่เป็นค่าเริ่มต้นหรือแบบกำหนดพารามิเตอร์) จากอีกประเภทหนึ่ง สิ่งนี้เรียกว่าการเรียกคอนสตรัคเตอร์ที่ชัดเจน

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

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

สมมติว่าเรามีคลาสHumanที่ฟิลด์ "ชื่อ" ถูกกำหนดไว้: มาnameสร้างตัวตั้งค่าสำหรับตัวแปรกันดีกว่า (ตัวตั้งค่าทำงานได้ค่อนข้างดีและไม่มีเคล็ดลับที่นี่): โปรดทราบว่า เรากำลังส่งตัวแปรไปยังเมธอด (ตัวตั้งค่า ) . เราได้แนะนำตัวแปรใหม่และ (โดยทั่วไป) สามารถเรียกมันว่าอะไรก็ได้ที่เราต้องการ เพราะว่ามันจะมองเห็นได้ภายใน {curly bras} ของ method เท่านั้น โปรดสังเกตว่ามีหนึ่งบรรทัดในตัวตั้งค่า: setNameString newNamesetName

name = newName;

ที่จริงแล้วเราได้แนะนำตัวแปรใหม่และnewNameกำหนดให้กับตัวแปรที่มีอยู่แล้วในคลาส nameโปรแกรมเมอร์หลายคนคิดว่ามันแปลกที่จะแนะนำตัวแปรด้วยชื่อใหม่หากท้ายที่สุดแล้วเรากำลังพูดถึงสิ่งเดียวกัน เกี่ยวกับชื่อในชั้นHumanเรียน ดังนั้นผู้พัฒนาภาษาจึงคิดที่จะทำให้สะดวกในการใช้ชื่อตัวแปรตัวเดียว กล่าวอีกนัยหนึ่ง เหตุใดจึงต้องมีสองชื่อสำหรับตัวแปรที่มีความหมายเหมือนกัน นั่นคือฉันต้องการทำสิ่งนี้: แต่ในกรณีนี้มีปัญหาเกิดขึ้น . ตอนนี้เรามีตัวแปรสองตัวที่ชื่อเหมือนกัน อันหนึ่งString nameเป็นของคลาสHumanและอีกอันเป็นของString nameวิธีการของมัน setNameดังนั้นเครื่อง Java จึงไม่ทราบว่าคุณหมายถึงตัวแปรใดเมื่อคุณเขียนสตริงใน setter:

name = name;

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

public class Solution{
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Volodya");
        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);
    }
}

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

ตัวอย่างที่สอง - การใช้สิ่งนี้เพื่อเรียกตัวสร้างอย่างชัดเจน

การเรียกคอนสตรัคเตอร์ตัวหนึ่งจากอีกตัวหนึ่งอาจมีประโยชน์เมื่อคุณ (ผิดปกติพอสมควร) มีคอนสตรัคเตอร์หลายตัว และคุณไม่ต้องการเขียนโค้ดเริ่มต้นที่ให้ไว้ก่อนหน้าในตัวคอนสตรัคเตอร์ในคอนสตรัคเตอร์ใหม่ สับสน? ทุกอย่างไม่ได้น่ากลัวอย่างที่คิด ดูโค้ดด้านล่างนี้ มันมีตัวสร้างคลาสสองตัว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){
        //you call the constructor with two parameters
        this(age, weight);
        //and add the missing variable
        this.height = height;
    }
}

ที่นี่ก่อนอื่นเรามีตัวสร้างพารามิเตอร์สองตัวที่ยอมรับint ageและ int weightสมมติว่าเราเขียนโค้ดสองบรรทัดลงไป:

this.age = age;
this.weight = weight;

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

this.age = age;
this.weight = weight;
this.height = height;

แต่แทนที่จะทำซ้ำโค้ดที่คุณเขียนไว้ใน Constructor นี้ คุณสามารถใช้คีย์เวิร์ดเพื่อthisเรียก Constructor อย่างชัดเจนด้วยพารามิเตอร์สองตัว:

this(age, weight);
// and add the missing variable:
this.height = height;

คุณกำลังบอก Constructor ด้วยพารามิเตอร์ 3 ตัว:

• เรียกตัวสร้างนี้ซึ่งมีพารามิเตอร์สองตัว
• และเพิ่มตัวแปรที่หายไป

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