คำหลักนี้ใน Java - สิ่งที่คุณต้องรู้

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

ด้านล่างนี้เป็นหัวข้อที่ฉันจะกล่าวถึงในบทความนี้:

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

เริ่มกันเลย!

คำหลักนี้ใน Java คืออะไร?

นี้ คีย์เวิร์ดใน แสดงถึงปัจจุบัน . ส่วนใหญ่จะใช้เพื่อเข้าถึงสมาชิกคนอื่น ๆ ในคลาสเดียวกัน ด้วยความช่วยเหลือของ นี้ คำหลักคุณสามารถเข้าถึงวิธีการฟิลด์และ ช่างก่อสร้าง ของคลาสเดียวกันภายในคลาส

ตอนนี้เรามาดูกันดีกว่าว่าอะไรคือความจำเป็น นี้ คีย์เวิร์ดใน Java

เหตุใดจึงใช้คำสำคัญนี้ใน Java

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

โดยพื้นฐานแล้ว 'นี้' คำหลักสามารถใช้ได้สองวิธี

1. นี้.
2. นี้()

1. สิ่งนี้

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

ไวยากรณ์

วิธีปิดแอปพลิเคชัน java

this.data สมาชิกของคลาสปัจจุบัน

บันทึก: หากมีตัวแปรใด ๆ ที่นำหน้าด้วย 'นี้', จากนั้น JVM ถือว่าตัวแปรนั้นเป็นตัวแปรคลาส .

2. สิ่งนี้ ()

สามารถใช้โทรได้ ผู้สร้าง ภายในวัตถุอื่นโดยไม่ต้องสร้างวัตถุหลาย ๆ ครั้งสำหรับคลาสเดียวกัน

ไวยากรณ์

this () // ไม่เรียกตัวสร้างพารามิเตอร์หรือค่าเริ่มต้นนี้ (ค่า 1, ค่า 2, ..... ) // เรียกตัวสร้างพารามิเตอร์

ตอนนี้คุณรู้แล้วว่าอะไรคืออะไร นี้ คำหลักและเหตุใดคุณจึงต้องใช้เรามาเจาะลึกบทความนี้และทำความเข้าใจในแง่มุมต่างๆที่ นี้ สามารถใช้คำหลักใน Java .

การใช้คำหลักนี้

มี 6 วิธีที่ คำหลักนี้ สามารถใช้ใน Java มีดังต่อไปนี้:

1. ใช้กับสนาม
2. ใช้เพื่อเรียกตัวสร้าง
3. ใช้เพื่อส่งคืนอินสแตนซ์คลาสปัจจุบัน
4. ใช้เป็นพารามิเตอร์วิธีการ
5. ใช้เพื่อเรียกใช้เมธอดคลาสปัจจุบัน
6. ใช้เป็นอาร์กิวเมนต์ในการเรียกตัวสร้าง

ตอนนี้เรามาดูรายละเอียดของแต่ละวิธีกัน

hashmap vs แฮชแท็กใน java

1. คำสำคัญนี้สามารถใช้กับเขตข้อมูล / การซ่อนตัวแปร

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

package Edureka import java.util. * public class field {int j, n // Parameterized constructor Test (int j, int n) {this.j = j this.n = n} void display () {// การแสดงค่าของ ตัวแปร j และ n System.out.println ('j =' + j + 'n =' + n)} public static void main (String [] args) {field obj = new field (27, 01) obj.display ( )}}

เอาท์พุต:

j = 27 n = 01

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

ตอนนี้เรามาดูวิธีการ นี้ คำสำคัญใน Java สามารถใช้เพื่อเรียกใช้ตัวสร้าง

2. คำหลักนี้สามารถใช้เพื่อเรียกตัวสร้าง

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

package Edureka import java.util. * public class ตัวอย่าง {{int j, n // Default constructor Example () {this (27, 01) System.out.println ('Inside default constructor n')} // Parameterized constructor Example (int j, int n) {this.j = j this.n = n System.out.println ('Inside parameterized constructor')} public static void main (String [] args) {Example obj = new Example ()} }

เอาท์พุต:

ภายในตัวสร้างที่กำหนดพารามิเตอร์ภายในตัวสร้างเริ่มต้น

ในตัวอย่างข้างต้นคุณจะเห็นว่า“ นี้ 'คีย์เวิร์ดใช้เพื่อเรียกตัวสร้างโอเวอร์โหลดในตัวเดียวกัน .

3. คีย์เวิร์ดนี้สามารถใช้เพื่อส่งคืนอินสแตนซ์คลาสปัจจุบัน

ที่นี่คุณสามารถกลับ นี้ คำหลักเป็นคำสั่งจากวิธีการ ในกรณีนี้ประเภทการส่งคืนของเมธอดต้องเป็นประเภทคลาส เรามาทำความเข้าใจกันโดยใช้ตัวอย่าง

คลาสสาธารณะ Edureka {int j, int n // ตัวสร้างเริ่มต้น Edureka () {j = 100 n = 200} // วิธีที่ส่งคืนอินสแตนซ์คลาสปัจจุบัน Edureka get () {return this} // การแสดงค่าของตัวแปร j และ n โมฆะ display () {System.out.println ('j =' + j + 'n =' + n)} public static void main (String [] args) {Edureka obj = new Edureka () obj.get (). display ()}}

เอาท์พุต:

j = 100, n = 200

4. คำหลักนี้สามารถใช้เป็นพารามิเตอร์วิธีการ

นี้ สามารถใช้คีย์เวิร์ดภายในเมธอดเพื่อเรียกเมธอดอื่นจากคลาสเดียวกัน ตัวอย่างด้านล่างแสดงให้เห็นถึงสิ่งเดียวกัน

คลาสสาธารณะ Edureka {int j, n // ตัวสร้างค่าเริ่มต้น Edureka () {j = 100 n = 200} // วิธีที่ได้รับคีย์เวิร์ด 'this' เป็นพารามิเตอร์แสดงโมฆะ (Edureka obj) {System.out.println ('j = '+ j +' n = '+ n)} // เมธอดที่คืนค่า class ปัจจุบันเป็นโมฆะ get () {display (this)} public static void main (String [] args) {Edureka obj = new Edureka () obj. รับ ()}}

เอาท์พุต:

j = 100, n = 200

5. คีย์เวิร์ดนี้ใช้เป็นเมธอดคลาสปัจจุบัน

นี้ คำหลักสามารถใช้เพื่อเรียกใช้เมธอดของคลาสปัจจุบัน เรามาทำความเข้าใจกันโดยใช้ตัวอย่าง

คลาส pubic Edureka {void display () {// เรียก fuction show () this.show () System.out.println ('Inside display function')} void show () {System.out.println ('Inside show funcion' )} public static void main (String args []) {Edureka j = new Edureka () j.display ()}}

เอาท์พุต:

ภายในแสดง funcion ฟังก์ชันการแสดงผลภายใน

6. คีย์เวิร์ดนี้ใช้เป็นอาร์กิวเมนต์ในการเรียกตัวสร้าง

คุณสามารถผ่าน นี้ คำสำคัญในตัวสร้างด้วย จะมีประโยชน์ถ้าคุณต้องใช้อย่างใดอย่างหนึ่ง ในหลายชั้นเรียน ตอนนี้เรามาทำความเข้าใจกันด้วยความช่วยเหลือของตัวอย่าง

คลาสสาธารณะ Y {X obj // ตัวสร้างพารามิเตอร์ที่มีอ็อบเจ็กต์ X // เป็นพารามิเตอร์ Y (X obj) {this.obj = obj // เรียกวิธีการแสดงของคลาส X obj.display ()}} คลาส X {int x = 45 // Contructor เริ่มต้นที่สร้างออบเจ็กต์ของ Y // โดยส่งสิ่งนี้เป็นอาร์กิวเมนต์ใน // constructor X () {Y obj = new Y (this)} // วิธีการเพื่อแสดงค่า x void display () {System.out.println ('Value of x in Class X:' + x)} public static void main (String [] args) {X obj = new X ()}}

เอาต์พุต :

ค่า x ในคลาส X: 45

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

ปัจจัยสำคัญของคำหลักนี้:

1. คุณไม่สามารถใช้ super และ นี้ คำหลักใน วิธีการคงที่ และในบล็อกการเริ่มต้นแบบคงที่แม้ว่าคุณจะอ้างถึงสมาชิกแบบคงที่

   overriding vs overloading ใน java

2. คุณควรโทร ซุปเปอร์ () และ นี้() เรียกคำสั่งภายในตัวสร้างเท่านั้นและต้องเป็นคำสั่งแรกในตัวสร้าง

เรามาถึงตอนท้ายของบทความเกี่ยวกับ นี้ คีย์เวิร์ดใน Java ฉันหวังว่าคุณจะพบว่าข้อมูลนี้

ตรวจสอบไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ซึ่งมีเครือข่ายผู้เรียนที่พึงพอใจมากกว่า 250,000 คนกระจายอยู่ทั่วโลก เราพร้อมที่จะช่วยเหลือคุณในทุกขั้นตอนในการเดินทางของคุณสำหรับการเป็นนอกเหนือจากคำถามสัมภาษณ์ java นี้เรามาพร้อมกับหลักสูตรที่ออกแบบมาสำหรับนักเรียนและมืออาชีพที่ต้องการเป็น Java Developer

มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบทความ 'คำหลักนี้ใน Java' และเราจะติดต่อกลับโดยเร็วที่สุด