Apakah saya tetap menentang penamaan all-caps untuk enum untuk membuat representasi String mereka lebih sederhana?

Beberapa kali saya melihat orang menggunakan case-title atau bahkan semua penamaan huruf kecil untuk konstanta enum, misalnya:

enum Color {
  red,
  yellow,
  green;
}

Ini membuat bekerja dengan bentuk string mereka menjadi sederhana dan mudah, jika Anda ingin melakukannya throw new IllegalStateException("Light should not be " + color + "."), misalnya.

Ini tampaknya lebih dapat diterima jika enum private, tetapi saya masih tidak menyukainya. Saya tahu saya bisa membuat konstruktor enum dengan bidang String, dan kemudian menimpa toString untuk mengembalikan nama itu, seperti ini:

enum Color {
  RED("red"),
  YELLOW("yellow"),
  GREEN("green");

  private final String name;

  private Color(String name) { 
    this.name = name 
  }

  @Override public String toString() {
    return name; 
  }
}

Tapi lihat berapa lama lagi. Ini menjengkelkan untuk terus dilakukan jika Anda memiliki banyak enum kecil yang ingin tetap sederhana. Apakah saya tetap bisa menggunakan format kasus yang tidak konvensional di sini?

Jawaban singkatnya adalah, tentu saja, apakah Anda ingin memutuskan konvensi penamaan untuk apa yang pada dasarnya adalah konstanta ... Mengutip dari JLS :

Nama Konstan

Nama-nama konstanta dalam tipe antarmuka harus, dan variabel akhir dari tipe kelas dapat secara konvensional, urutan satu atau lebih kata, akronim, atau singkatan, semuanya huruf besar, dengan komponen yang dipisahkan oleh karakter "_" garis bawah. Nama konstan harus deskriptif dan tidak perlu disingkat. Secara konvensional mereka dapat menjadi bagian dari pidato yang tepat.

Jawaban panjangnya, berkenaan dengan penggunaan toString(), adalah pasti metode untuk menimpa jika Anda ingin representasi nilai yang lebih mudah dibacaenum . Mengutip dari Object.toString()(penekanan milikku):

Mengembalikan representasi string objek. Secara umum, toStringmetode mengembalikan string yang "secara teks mewakili" objek ini . Hasilnya haruslah representasi yang ringkas namun informatif yang mudah dibaca oleh seseorang . Disarankan bahwa semua subclass menimpa metode ini.

Sekarang, saya tidak yakin mengapa beberapa jawaban melayang untuk berbicara tentang mengubah enumske sana kemari dengan Stringnilai - nilai, tetapi saya hanya akan memberikan pendapat saya di sini juga. Serialisasi enumnilai seperti itu dapat dengan mudah diatasi dengan menggunakan metode name()atau ordinal(). Keduanya finaldan dengan demikian Anda dapat yakin tentang nilai yang dikembalikan selama nama atau posisi nilai tidak berubah . Bagi saya, itu penanda yang cukup jelas.

Yang saya kumpulkan dari hal di atas adalah: hari ini, Anda mungkin ingin menggambarkannya YELLOWsebagai "kuning" saja. Besok, Anda mungkin ingin menggambarkannya sebagai "Pantone Minion Yellow" . Deskripsi ini harus dikembalikan dari menelepon toString(), dan saya tidak akan mengharapkan salah satu name()atau ordinal()berubah. Jika saya melakukannya, itu adalah sesuatu yang harus saya selesaikan dalam basis kode atau tim saya, dan menjadi pertanyaan yang lebih besar dari sekadar enumgaya penamaan .

Sebagai kesimpulan, jika semua yang Anda ingin lakukan adalah mencatat representasi yang lebih mudah dibaca dari enumnilai - nilai Anda , saya masih menyarankan untuk tetap berpegang pada konvensi dan kemudian mengesampingkan toString(). Jika Anda juga ingin membuat cerita bersambung menjadi file data, atau ke tujuan non-Jawa lainnya, Anda masih memiliki name()dan ordinal()metode untuk mendukung Anda, jadi tidak perlu khawatir tentang overriding toString().

Jangan modifikasi ENUMitu hanya bau kode yang buruk. Biarkan enum menjadi enum dan string menjadi string.

Sebagai gantinya, gunakan konverter CamelCase untuk nilai string.

throw new IllegalStateException("Light should not be " + CamelCase(color) + ".");

Ada banyak pustaka sumber terbuka yang sudah memecahkan masalah ini untuk Java.

http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/CaseFormat.html

Mengirim enum antara kode Java dan aplikasi database atau klien, saya sering berakhir membaca dan menulis nilai enum sebagai string. toString()disebut secara implisit ketika menggabungkan string. Overriding toString () pada beberapa enums berarti bahwa kadang-kadang saya bisa saja

"<input type='checkbox' value='" + MY_CONST1 + "'>"

dan terkadang saya harus ingat untuk menelepon

"<input type='checkbox' value='" + MY_CONST1.name() + "'>"

yang menyebabkan kesalahan, jadi saya tidak melakukan itu lagi. Sebenarnya, saya tidak mengesampingkan metode apa pun pada Enum karena jika Anda melemparkannya ke kode klien yang cukup, pada akhirnya Anda akan mematahkan harapan seseorang.

Buat nama metode baru Anda sendiri, seperti public String text()atau toEnglish()atau apa pun.

Ini adalah fungsi pembantu kecil yang bisa menghemat pengetikan jika Anda memiliki banyak enum seperti di atas:

public static String ucFirstLowerRest(String s) {
    if ( (s == null) || (s.length() < 1) ) {
        return s;
    } else if (s.length() == 1) {
        return s.toUpperCase();
    } else {
        return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
    }
}

Selalu mudah untuk memanggil .toUpperCase () atau .toLowerCase () tetapi mengembalikan case campuran bisa rumit. Perhatikan warnanya, "bleu de France." Prancis selalu menggunakan huruf kapital, jadi Anda mungkin ingin menambahkan metode textLower () ke enum Anda jika Anda mengalami itu. Saat Anda menggunakan teks ini di awal kalimat, vs. tengah kalimat, vs. dalam judul, Anda bisa melihat bagaimana satu toString()metode akan gagal. Dan itu bahkan tidak menyentuh karakter yang ilegal di pengidentifikasi Java, atau yang sulit untuk mengetik karena mereka tidak diwakili pada keyboard standar, atau karakter yang tidak memiliki huruf besar (Kanji, dll.).

enum Color {
  BLEU_DE_FRANCE {
    @Override public String textTc() { return "Bleu De France"; }
    @Override public String textLc() { return "bleu de France"; }
  }
  CAFE_NOIR {
    @Override public String textTc() { return "Café Noir"; }
  }
  RED,
  YELLOW,
  GREEN;

  // The text in title case
  private final String textTc;

  private Color() { 
    textTc = ucFirstLowerRest(this.toString());
  }

  // Title case
  public String textTc() { return textTc; }

  // For the middle of a sentence
  public String textLc() { return textTc().toLowerCase(); }

  // For the start of a sentence
  public String textUcFirst() {
    String lc = textLc();
    return lc.substring(0, 1).toUpperCase() + lc.substring(1);
  }
}

Tidak begitu sulit untuk menggunakan ini dengan benar:

IllegalStateException(color1.textUcFirst() + " clashes horribly with " +
                      color2.textLc() + "!")

Semoga itu juga menunjukkan mengapa menggunakan nilai case campuran enum akan mengecewakan Anda juga. Salah satu alasan terakhir untuk tetap menggunakan all-caps dengan konstanta garis bawah enum adalah bahwa hal tersebut mengikuti Prinsip Least Astonishment. Orang-orang mengharapkannya, jadi jika Anda melakukan sesuatu yang berbeda, Anda harus selalu menjelaskan diri sendiri, atau berurusan dengan orang-orang yang menyalahgunakan kode Anda.

Jika ada kemungkinan sekecil apa pun representasi string ini dapat disimpan di tempat-tempat seperti database atau file teks, maka mengikat mereka ke konstanta enum aktual akan menjadi sangat bermasalah jika Anda perlu refactor enum Anda.

Bagaimana jika suatu hari Anda memutuskan untuk mengubah nama Color.Whiteuntuk Color.TitaniumWhitesementara ada file data di luar sana yang mengandung "Putih"?

Juga, setelah Anda mulai mengkonversi konstanta enum ke string, langkah selanjutnya lebih jauh di jalan adalah menghasilkan string untuk dilihat pengguna, dan masalahnya di sini adalah, karena saya yakin Anda sudah tahu, bahwa sintaks java tidak izinkan spasi dalam pengidentifikasi. (Anda tidak akan pernah punya Color.Titanium White.) Jadi, karena Anda mungkin akan memerlukan mekanisme yang tepat untuk menghasilkan nama enum untuk ditampilkan kepada pengguna, yang terbaik adalah menghindari kerumitan enum yang tidak perlu.

Yang telah dikatakan, Anda tentu saja dapat melanjutkan dan melakukan apa yang Anda pikirkan lakukan, dan kemudian refactor Anda nanti, untuk memberikan nama kepada konstruktor, ketika (dan jika) Anda mengalami masalah.

Anda dapat mencukur beberapa baris dari enum-with-constructor Anda dengan mendeklarasikan namebidang public finaldan kehilangan pengambil. (Apa cinta ini yang dimiliki programmer java terhadap getter?)

Bisa dibilang, mengikuti konvensi penamaan UPPERCASE melanggar KERING . (Dan YAGNI ). misalnya, pada contoh kode Anda # 2: "RED" dan "red" diulang.

Jadi, apakah Anda mengikuti konvensi resmi atau mengikuti KERING? Panggilanmu.

Dalam kode saya, saya akan mengikuti KERING. Namun, saya akan memberikan komentar pada kelas Enum, mengatakan "tidak semua huruf besar karena (penjelasan di sini)"