ที่ JavaRush นักเรียนจะได้รับการแนะนำให้รู้จักกับคำหลักตั้งแต่การบรรยายครั้ง
ตามกฎแล้ว
มา
ไปยังเมธอด (ตัวตั้งค่า ) . เราได้แนะนำตัวแปรใหม่และ (โดยทั่วไป) สามารถเรียกมันว่าอะไรก็ได้ที่เราต้องการ เพราะว่ามันจะมองเห็นได้ภายใน {curly bras} ของ method เท่านั้น โปรดสังเกตว่ามีหนึ่งบรรทัดในตัวตั้งค่า:
แต่ในกรณีนี้มีปัญหาเกิดขึ้น . ตอนนี้เรามีตัวแปรสองตัวที่ชื่อเหมือนกัน อันหนึ่ง
และปรากฎว่าคุณเพียงกำหนดค่าให้กับตัวแปร
นั่นคือ
และด้านล่างคือโค้ดโปรแกรมที่มีคีย์เวิร์ด
this
แรก และเมื่อเวลาผ่านไปก็จะชัดเจนว่ามันหมายถึงอะไร แต่หลายคนเมื่อมองย้อนกลับไปอาจจะพูดกับตัวเองอย่างตรงไปตรงมาว่าเป็นเวลานานที่พวกเขาไม่สามารถตระหนักถึงเซนของคำสำคัญนี้ได้ ในบทความนี้ เราจะไขความลับเกี่ยวกับการใช้คีย์เวิร์ดthis
สำหรับผู้ที่ยังคิดไม่ออก... ยินดีต้อนรับ! หากคุณหยิบ หนังสืออ้างอิง Java ของ Schildtในหน้า 171 คุณจะอ่านได้ว่าจำเป็นต้องมีคีย์เวิร์ดthis
เพื่อให้เมธอดสามารถอ้างอิงออบเจ็กต์ที่เรียกมันได้ นี่อาจเป็นจุดสิ้นสุดของมันจริงๆ แต่เราต้องการข้อมูลเฉพาะ this
ควร ใช้ ในสองกรณี:
- เมื่อตัวแปรอินสแตนซ์คลาสและตัวแปรเมธอด/ตัวสร้างมีชื่อเหมือนกัน
- เมื่อคุณต้องการเรียก Constructor ประเภทหนึ่ง (เช่น Constructor ที่เป็นค่าเริ่มต้นหรือแบบกำหนดพารามิเตอร์) จากอีกประเภทหนึ่ง สิ่งนี้เรียกว่าการเรียกคอนสตรัคเตอร์ที่ชัดเจน
ตัวอย่างที่หนึ่ง - ตัวแปรอินสแตนซ์และตัวแปรเมธอดมีชื่อเดียวกัน
สมมติว่าเรามีคลาสHuman
ที่ฟิลด์ "ชื่อ" ถูกกำหนดไว้: 
name
สร้างตัวตั้งค่าสำหรับตัวแปรกันดีกว่า (ตัวตั้งค่าทำงานได้ค่อนข้างดีและไม่มีเคล็ดลับที่นี่): โปรดทราบว่า เรากำลังส่งตัวแปร
setName
String newName
setName
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 ตัว:
- เรียกตัวสร้างนี้ซึ่งมีพารามิเตอร์สองตัว
- และเพิ่มตัวแปรที่หายไป
this
จะถูกส่งผ่านไปยังเมธอดทั้งหมด ยกเว้นเมธอดแบบคงที่ (ด้วยเหตุนี้เหตุใดจึงthis
มักเรียกว่าพารามิเตอร์โดยนัย) และสามารถใช้เพื่ออ้างถึงอ็อบเจ็กต์ที่เรียกว่าเมธอดได้ คีย์เวิร์ดนี้ไม่ต้องกลัวเพราะThis
มันไม่น่ากลัว

GO TO FULL VERSION