ฉันควรใช้“ สิ่งนี้” ในชั้นเรียนเมื่อใด

ฉันรู้ว่าthisหมายถึงวัตถุปัจจุบัน แต่ฉันไม่รู้ว่าเมื่อไรฉันต้องใช้มันจริงๆ ตัวอย่างเช่นจะมีความแตกต่างหรือไม่หากฉันใช้xแทนthis.xวิธีการบางอย่าง? อาจxจะหมายถึงตัวแปรซึ่งเป็นท้องถิ่นสำหรับวิธีการพิจารณา? ฉันหมายถึงตัวแปรที่เห็นในวิธีนี้เท่านั้น

เกี่ยวกับthis.method()อะไร ฉันสามารถใช้มันได้หรือไม่ ฉันควรจะใช้มัน ถ้าฉันเพิ่งใช้method()มันจะไม่ถูกนำไปใช้กับวัตถุปัจจุบันหรือไม่

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

กรณีที่ 1:การใช้thisเพื่อแก้ปัญหาการอ้างอิงตัวแปร ในเมธอดเซ็ตเตอร์ Java เรามักส่งผ่านอาร์กิวเมนต์ที่มีชื่อเดียวกันกับตัวแปรสมาชิกส่วนตัวที่เรากำลังพยายามตั้งค่า จากนั้นเราจะกำหนดโต้แย้งไปx this.xสิ่งนี้ทำให้ชัดเจนว่าคุณกำลังกำหนดค่าของพารามิเตอร์ "name" ให้กับตัวแปร instance "name"

public class Foo
{
    private String name;

    public void setName(String name) {
        this.name = name;
    }
}

กรณีที่ 2:ใช้thisเป็นอาร์กิวเมนต์ที่ส่งไปยังวัตถุอื่น

public class Foo
{
    public String useBarMethod() {
        Bar theBar = new Bar();
        return theBar.barMethod(this);
    }

    public String getName() {
        return "Foo";
    }
}

public class Bar
{
    public void barMethod(Foo obj) {
        obj.getName();
    }
}

กรณีที่ 3:การใช้thisเพื่อเรียก constructors สำรอง ในความคิดเห็นที่trinithisthisชี้ได้อย่างถูกต้องออกมาอีกใช้งานทั่วไปของ เมื่อคุณมีคอนสตรัคเตอร์หลายตัวสำหรับคลาสเดียวคุณสามารถใช้this(arg0, arg1, ...)เรียกคอนสตรัคเตอร์อื่นที่คุณเลือกได้โดยให้คุณทำในบรรทัดแรกของตัวสร้าง

class Foo
{
    public Foo() {
        this("Some default value for bar");

        //optional other lines
    }

    public Foo(String bar) {
        // Do something with bar
    }
}

ฉันเคยเห็นthisเคยเน้นย้ำความจริงที่ว่าตัวแปรอินสแตนซ์กำลังถูกอ้างอิง (ไม่จำเป็นต้องแก้ความกำกวม) แต่นั่นเป็นกรณีที่หายากในความคิดของฉัน

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

public class Outer {
  protected int a;

  public class Inner {
    protected int a;

    public int foo(){
      return Outer.this.a;
    }

    public Outer getOuter(){
      return Outer.this;
    }
  }
}

คุณจะต้องใช้this- และคนส่วนใหญ่ใช้มันเท่านั้น - เมื่อมีตัวแปรโลคัลที่ซ้อนทับกันด้วยชื่อเดียวกัน (ตัวอย่างเช่นวิธีตั้งค่า)

แน่นอนอีกเหตุผลที่ดีที่ใช้thisคือมันทำให้เกิด intellisense ปรากฏขึ้นใน IDEs :)

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

"นี่" ยังมีประโยชน์เมื่อเรียกตัวสร้างหนึ่งจากที่อื่น:

public class MyClass {
    public MyClass(String foo) {
        this(foo, null);
    }
    public MyClass(String foo, String bar) {
        ...
    }
}

this มีประโยชน์ในรูปแบบการสร้าง

public class User {

    private String firstName;
    private String surname;

    public User(Builder builder){
        firstName = builder.firstName;
        surname = builder.surname;
    }

    public String getFirstName(){
        return firstName;
    }

    public String getSurname(){
        return surname;
    }

    public static class Builder {
        private String firstName;
        private String surname;

        public Builder setFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder setSurname(String surname) {
            this.surname = surname;
            return this;
        }

        public User build(){
            return new User(this);
        }

    }

    public static void main(String[] args) {
        User.Builder builder = new User.Builder();
        User user = builder.setFirstName("John").setSurname("Doe").build();
    }

}

มีคำตอบที่ดีมากมาย แต่ก็มีอีกเหตุผลเล็กน้อยที่ให้thisทุกที่ หากคุณได้ลองเปิดซอร์สโค้ดของคุณจาก text editor ธรรมดา (เช่น notepad เป็นต้น) การใช้thisจะทำให้การอ่านชัดเจนยิ่งขึ้น

ลองนึกภาพสิ่งนี้:

public class Hello {
    private String foo;

    // Some 10k lines of codes

    private String getStringFromSomewhere() {
        // ....
    }

    // More codes

    public class World {
        private String bar;

        // Another 10k lines of codes

        public void doSomething() {
            // More codes
            foo = "FOO";
            // More codes
            String s = getStringFromSomewhere();
            // More codes
            bar = s;
        }
    }
}

นี่เป็นสิ่งที่ชัดเจนมากที่จะอ่านกับ IDE ที่ทันสมัยใด ๆ แต่นี่จะเป็นฝันร้ายทั้งหมดที่จะอ่านด้วยโปรแกรมแก้ไขข้อความปกติ

คุณจะต้องดิ้นรนหาที่fooอยู่จนกว่าคุณจะใช้ฟังก์ชั่น "ค้นหา" ของบรรณาธิการ จากนั้นคุณจะกรีดร้องgetStringFromSomewhere()ด้วยเหตุผลเดียวกัน ท้ายที่สุดหลังจากที่คุณลืมสิ่งsที่bar = sเกิดขึ้นนั่นคือสิ่งที่จะทำให้คุณระเบิดครั้งสุดท้าย

เปรียบเทียบกับสิ่งนี้:

public void doSomething() {
    // More codes
    Hello.this.foo = "FOO";
    // More codes
    String s = Hello.this.getStringFromSomewhere();
    // More codes
    this.bar = s;
}

1. คุณจะรู้ว่าเป็นตัวแปรประกาศในชั้นเรียนนอกfooHello
2. คุณรู้ว่าgetStringFromSomewhere()เป็นวิธีการประกาศในชั้นนอกเช่นกัน
3. คุณรู้ว่าbarเป็นของWorldชั้นเรียนและsเป็นตัวแปรท้องถิ่นประกาศในวิธีการที่

แน่นอนว่าเมื่อใดก็ตามที่คุณออกแบบบางอย่างคุณจะสร้างกฎ ดังนั้นในขณะที่การออกแบบ API หรือโครงการของคุณถ้ากฎของคุณรวมถึง "ถ้ามีคนเปิดทุกรหัสแหล่งที่มาเหล่านี้ด้วย notepad เขาหรือเธอควรจะยิงเขา / เธอในหัว" แล้วคุณมีทั้งหมดปรับไม่ที่จะทำนี้

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

@William Brendel ให้สามกรณีการใช้งานที่แตกต่างกันในวิธีที่ดี

ใช้กรณีที่ 1:

หน้าเอกสาร Java อย่างเป็นทางการเกี่ยวกับเรื่องนี้ให้ใช้กรณีเดียวกัน

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

ครอบคลุมสองตัวอย่าง:

การใช้สิ่งนี้กับฟิลด์และการใช้สิ่งนี้กับคอนสตรัคเตอร์

ใช้กรณีที่ 2:

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

synchronized(this){
    // Do some thing. 
}

ใช้กรณีที่ 3:

การนำไปใช้ของรูปแบบตัวสร้างขึ้นอยู่กับการใช้thisเพื่อส่งคืนวัตถุที่ถูกปรับเปลี่ยน

อ้างถึงโพสต์นี้

การรักษาผู้สร้างในคลาสที่แยกต่างหาก (ส่วนต่อประสานที่คล่องแคล่ว)

Google เปิดหน้าในเว็บไซต์ Sun ที่กล่าวถึงนี้เล็กน้อย

คุณพูดถูกเกี่ยวกับตัวแปร thisสามารถนำมาใช้เพื่อแยกความแตกต่างของตัวแปรวิธีจากสนามชั้น

    private int x;
    public void setX(int x) {
        this.x=x;
    }

แต่ผมจริงๆเกลียดการประชุมว่า การให้ชื่อสองตัวแปรที่เหมือนกันอย่างแท้จริงนั้นเป็นสูตรสำหรับข้อบกพร่อง ฉันชอบอะไรบางอย่างตามสายของ:

    private int x;
    public void setX(int newX) {
        x=newX;
    }

ผลลัพธ์เดียวกัน แต่ไม่มีโอกาสที่จะเกิดข้อผิดพลาดที่คุณอ้างถึงโดยไม่ตั้งใจxเมื่อคุณตั้งใจจะอ้างถึงxแทน

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

ต่อไปนี้เป็นวิธีการใช้คำสำคัญ 'this' ใน java:

1. การใช้thisคำสำคัญเพื่ออ้างอิงตัวแปรอินสแตนซ์ของคลาสปัจจุบัน
2. ใช้this()เพื่อเรียกใช้ตัวสร้างคลาสปัจจุบัน
3. การใช้thisคำหลักเพื่อส่งคืนอินสแตนซ์ของคลาสปัจจุบัน
4. การใช้thisคำหลักเป็นพารามิเตอร์วิธี

https://docs.oracle.com/javase/tutorial/java/javaOO/thiskey.html

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

thisเป็นการอ้างอิงถึงวัตถุปัจจุบัน มันถูกใช้ในตัวสร้างเพื่อแยกความแตกต่างระหว่างตัวแปรระดับท้องถิ่นและปัจจุบันที่มีชื่อเดียวกัน เช่น:

public class circle {
    int x;
    circle(int x){
        this.x =x;
        //class variable =local variable 
    }
} 

thisยังสามารถใช้เรียกคอนสตรัคเตอร์หนึ่งจากคอนสตรัคอื่น เช่น:

public class circle {
    int x;

    circle() { 
        this(1);
    }

    circle(int x) {
        this.x = x; 
    }
}

จะมีความแตกต่างหรือไม่ถ้าฉันใช้ "x" แทน "this.x" ในบางวิธี

มักจะไม่ แต่บางครั้งก็สร้างความแตกต่าง:

  class A {
     private int i;
     public A(int i) {
        this.i = i; // this.i can be used to disambiguate the i being referred to
     }
  }

หากฉันเพิ่งใช้ "method ()" จะไม่ใช้กับวัตถุปัจจุบันตามค่าเริ่มต้นหรือไม่

ใช่. แต่ถ้าจำเป็นให้this.method()ชี้แจงว่าการโทรถูกทำโดยวัตถุนี้

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

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

class POJO {
   protected int i;

   public void modify() {
      i = 9;
   }

   public void thisModify() {
      this.i = 9;
   }
}

โค้ดผลลัพธ์ของทั้งสองวิธีจะเหมือนกัน ความแตกต่างจะเกิดขึ้นหากวิธีการบางอย่างประกาศตัวแปรท้องถิ่นที่มีชื่อเดียวกัน

  public void m() {
      int i;
      i = 9;  // i refers to variable in method's scope
      this.i = 9; // i refers to class variable
  }

ด้วยความเคารพวิลเลียม Brendelโพสต์และ 's dbconfessionsคำถามเกี่ยวกับกรณีที่ 2 นี่คือตัวอย่าง:

public class Window {

  private Window parent;

  public Window (Window parent) {
    this.parent = parent;
  }

  public void addSubWindow() {
    Window child = new Window(this);
    list.add(child);
  }

  public void printInfo() {
    if (parent == null) {
      System.out.println("root");
    } else {
      System.out.println("child");
    }
  }

}

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

คีย์เวิร์ด“ This” ใน java ใช้เพื่ออ้างอิงคลาสอ็อบเจ็กต์ปัจจุบัน

คีย์เวิร์ด“ this” ในจาวามีประโยชน์ 6 ข้อ

1. การเข้าถึงตัวแปรระดับชั้นเรียนส่วนใหญ่จะใช้หากตัวแปรระดับท้องถิ่นและระดับเดียวกัน
2. การเข้าถึงวิธีการเรียน : นี่คือพฤติกรรมเริ่มต้นและสามารถละเว้น
3. สำหรับการเรียกคอนสตรัคเตอร์อื่นของคลาสเดียวกัน
4. การใช้คำหลัก 'this' เป็นค่าตอบแทน : สำหรับส่งคืนอินสแตนซ์ปัจจุบันจากวิธีการ
5. การส่งคีย์เวิร์ด 'this' เป็นอาร์กิวเมนต์ไปยังเมธอด Passing: สำหรับการผ่านอินสแตนซ์ของคลาสปัจจุบันเป็นอาร์กิวเมนต์
6. คำหลักนี้เป็นข้อโต้แย้งให้กับคอนสตรัค : สำหรับการส่งอินสแตนซ์ของคลาสปัจจุบันเป็นอาร์กิวเมนต์

ref: https://stacktraceguru.com/java/this-keyword-in-java

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

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