Apa gaya yang diterima untuk menggunakan kata kunci `this` di Jawa?

Saya berasal dari bahasa seperti Python atau Javascript (dan yang lain yang kurang berorientasi objek) dan saya mencoba untuk meningkatkan pengetahuan saya tentang Java, yang saya tahu hanya dengan cara yang dangkal.

Apakah dianggap praktik yang buruk untuk selalu bergantung thispada atribut instance saat ini? Rasanya lebih alami bagi saya untuk menulis

...
private String foo;

public void printFoo() {
    System.out.println(this.foo);
}
...

dari

...
private String foo;

public void printFoo() {
    System.out.println(foo);
}
...

karena ini membantu saya membedakan atribut instance dari variabel lokal.

Tentu saja dalam bahasa seperti Javascript lebih masuk akal untuk selalu menggunakan this, karena seseorang dapat memiliki lebih banyak fungsi bersarang, maka variabel lokal berasal dari cakupan yang lebih besar. Di Jawa, sejauh yang saya mengerti, bersarang seperti ini tidak mungkin (kecuali untuk kelas dalam), jadi mungkin itu bukan masalah besar.

Bagaimanapun, saya lebih suka menggunakan this. Apakah akan terasa aneh dan tidak idiomatis?

Di sebagian besar IDE, Anda dapat dengan mudah memindahkan variabel jika Anda ingin tahu. Selain itu, sungguh, jika Anda bekerja dalam metode instan, Anda harus benar-benar mengetahui semua variabel yang terlibat. Jika Anda memiliki terlalu banyak, atau nama mereka berbenturan, maka Anda perlu refactor.

Ini benar-benar berlebihan.

Saya lebih suka menggunakan this. Itu membuatnya lebih mudah untuk membaca kode di berbagai editor yang mewarnai variabel lokal dan instance dengan cara yang sama. Ini juga membuatnya lebih mudah untuk membaca kode pada halaman yang dicetak selama sesuatu seperti tinjauan kode. Ini juga merupakan pengingat yang cukup kuat untuk ruang lingkup variabel ke pengembang lain.

Namun, ada argumen yang menentang hal ini. Dalam IDE modern, Anda bisa mengetahui ruang lingkup variabel dengan melayang di atasnya atau melihatnya dalam struktur seperti pohon. Anda juga dapat mengubah warna dan / atau font dari variabel tergantung pada cakupannya (bahkan sedemikian rupa sehingga, ketika dicetak, jelas apa cakupan variabel itu).

Saya percaya bahwa kalimat terakhir ChrisF sudah mati: konsisten dalam penggunaan Anda.

Satu tempat yang secara konsisten saya gunakan 'ini' adalah setter dan atau konstruktor:

public void setFoo(String foo) {
    this.foo = foo;
}

Selain itu, saya tidak merasa perlu menambahkannya. Saat membaca isi metode, parameter dan penduduk lokal ada di sana - dan cukup mudah untuk dilacak (bahkan tanpa bantuan IDE). Juga penduduk setempat dan bidang cenderung memiliki sifat yang berbeda (keadaan objek vs penyimpanan sementara atau parameter).

Jika ada kebingungan tentang apa itu variabel dan apa bidang, itu mungkin berarti metode memiliki terlalu banyak variabel / parameter, terlalu panjang dan terlalu kompleks, dan harus disederhanakan.

Jika Anda memilih untuk menggunakan 'ini' untuk menandai bidang, saya akan merekomendasikan untuk memastikan konvensi selalu diikuti dengan ketat - akan sangat mudah untuk memulai dengan asumsi tidak 'ini' berarti ini adalah lokal dan memecah barang berdasarkan asumsi.

sunting: Saya juga akhirnya menggunakan ini dalam equals, clone atau apapun yang memiliki parameter 'that' dari tipe objek yang sama:

public boolean isSame(MyClass that) {
    return this.uuid().equals(that.uuid());
}

Ini bisa diperdebatkan.

Mengambil C # sebagai analogi karena memiliki sintaks dan struktur yang sangat mirip dengan Java, kami menemukan bahwa C # StyleCop memiliki aturan default yang menegaskan Anda menambahkan this, tetapi ReSharper memiliki aturan default yang mengatakan bahwa thisitu mubazir (yang itu) dan dapat dihapus.

Jadi jika Anda menggunakan satu alat Anda akan menambahkannya tetapi jika Anda menggunakan yang lain Anda akan menghapusnya. Jika Anda menggunakan kedua alat maka Anda harus memilih dan menonaktifkan salah satu aturan.

Namun, yang dimaksud aturan adalah Anda konsisten dalam penggunaan - yang mungkin merupakan hal terpenting.

Apakah dianggap praktik buruk untuk selalu menambahkan ini ke atribut instance saat ini?

Ya - oleh sebagian orang, tidak - oleh orang lain.

Saya suka dan menggunakan thiskata kunci dalam proyek saya di Jawa dan C #. Orang dapat berargumen bahwa IDE akan selalu menyorot parameter dan bidang dengan warna yang berbeda namun kami tidak selalu bekerja di IDE - kami harus melakukan banyak penggabungan / perubahan / beberapa perubahan cepat pada notepad / periksa beberapa cuplikan kode dalam email . Ini cara yang lebih mudah bagi saya untuk melihat dari tampilan pertama di mana negara contoh ini berubah - misalnya, untuk meninjau beberapa masalah concurrency mungkin.

Saya pikir jika Anda perlu menggunakan ini, Anda memiliki metode yang terlalu panjang, atau kelas yang mencoba melakukan terlalu banyak, atau keduanya.

Metode seharusnya tidak boleh lebih dari beberapa baris kode, gunakan satu atau dua variabel lokal, tentukan apa yang menjadi mudah; bahkan dengan hanya 3 baris konteks dari sebagian besar alat diff. Jika metode Anda terlalu panjang dan kelas Anda memiliki terlalu banyak tanggung jawab (seringkali berarti terlalu banyak bidang), solusinya adalah dengan membaginya.

Saya pikir "ini" hanya mengacaukan kode. Apalagi dengan IDE modern yang akan mewarnai parameter lokal / variabel lokal / bidang berbeda.

Saya pikir Anda menjawab pertanyaan Anda sendiri dengan ini:

Rasanya lebih alami bagi saya untuk menulis

... ini ...

dari

... sial ...

karena ini membantu saya membedakan atribut instance dari variabel lokal.

Jika Anda lebih nyaman menggunakan this.sambil meningkatkan pengetahuan kerja Anda dengan Java, maka tentu saja gunakan hal itu ( saya pikir itu, dengan cara, diri Python akrab yang berhubungan dengan Anda ).

Masalahnya adalah, meskipun orang akan memberikan argumen yang kuat tentang penggunaan atau tidak menggunakan this., itu masih terdengar seperti perdebatan, contoh yang diberikan:

• itu membuat tujuan variabel jelas vs Anda harus menulis ulang kode jika tidak jelas apa masing-masing variabel;
• this.redundan jika Anda menghabiskan seluruh hari di IDE vs. Saya melakukan review kode dan membuat perbedaan pada versi yang berbeda menggunakan komparator tanpa penyorotan sintaksis;
• tidak mengetikkan this.keuntungan bagi saya milidetik penting dari produktivitas vs. Saya dibayar dengan penekanan tombol dan menambahkan this.seperti kenaikan gaji: D;
• dll

Tetapi intinya adalah, bahwa pada akhirnya, masih berlanjut ke preferensi pribadi dan lingkungan kerja .

Biasanya menambahkan ini tidak perlu. Saya tidak berpikir itu adalah praktik yang buruk per se, tetapi penggunaan berlebihan ini mungkin akan dianggap tidak biasa di sebagian besar basis kode Java yang pernah saya lihat.

Namun saya merasa berharga dalam beberapa situasi tertentu:

Mengganti parameter lokal - kadang-kadang perlu untuk menentukan bahwa Anda ingin menggunakan variabel instan daripada variabel / variabel lokal dengan nama yang sama. Ini cukup umum di konstruktor, di mana Anda ingin nama parameter untuk mencocokkan nama internal dari variabel instance yang digunakan untuk menginisialisasi mis.

class MyObject {
  int value;

  public MyObject(int value) {
    this.value=value;
  }
}

Ketika menangani instance lain dari kelas yang sama - saya percaya itu membuat kode lebih jelas dan lebih mudah dipahami secara eksplisit instance kelas mana yang Anda maksud, misalnya

class MyObject {
  int value;
  ....

  public MyObject add(MyObject other) {
    return new MyObject( this.value + other.value )
  }
}