Bagaimana Anda mendefinisikan kelas konstanta di Java?

Misalkan Anda perlu mendefinisikan kelas yang semuanya hanya memegang konstanta.

public static final String SOME_CONST = "SOME_VALUE";

Apa cara yang disukai untuk melakukan ini?

1. Antarmuka
2. Kelas Abstrak
3. Kelas Akhir

Mana yang harus saya gunakan dan mengapa?

Enum - Saya tidak akan menggunakan enum, saya tidak menghitung apa pun, hanya mengumpulkan beberapa konstanta yang tidak terkait satu sama lain dengan cara apa pun.

Antarmuka - Saya tidak akan menetapkan kelas apa pun sebagai salah satu yang mengimplementasikan antarmuka. Hanya ingin menggunakan antarmuka untuk memanggil konstanta seperti: ISomeInterface.SOME_CONST.

Gunakan kelas terakhir. untuk kesederhanaan Anda kemudian dapat menggunakan impor statis untuk menggunakan kembali nilai-nilai Anda di kelas lain

public final class MyValues {
  public static final String VALUE1 = "foo";
  public static final String VALUE2 = "bar";
}

di kelas lain:

import static MyValues.*
//...

if(variable.equals(VALUE1)){
//...
}

Klarifikasi Anda menyatakan: "Saya tidak akan menggunakan enum, saya tidak menghitung apa pun, hanya mengumpulkan beberapa konstanta yang tidak terkait satu sama lain dengan cara apa pun."

Jika konstanta sama sekali tidak terkait satu sama lain, mengapa Anda ingin mengumpulkannya? Letakkan setiap konstanta di kelas yang paling terkait dengannya.

Saran saya (dalam urutan preferensi yang menurun):

1) Jangan lakukan itu . Buat konstanta di kelas sebenarnya yang paling relevan. Memiliki kelas / antarmuka 'bag of constants' tidak benar-benar mengikuti praktik terbaik OO.

Saya, dan semua orang, mengabaikan # 1 dari waktu ke waktu. Jika Anda akan melakukannya, maka:

2) kelas akhir dengan konstruktor privat Ini setidaknya akan mencegah siapa pun menyalahgunakan 'bag of constants' Anda dengan memperluas / menerapkannya untuk mendapatkan akses mudah ke konstanta. (Saya tahu Anda mengatakan Anda tidak akan melakukan ini - tetapi itu tidak berarti seseorang datang setelah Anda tidak mau)

3) antarmuka Ini akan berfungsi, tetapi bukan preferensi saya memberikan kemungkinan penyalahgunaan yang disebutkan di # 2.

Secara umum, hanya karena ini adalah konstanta bukan berarti Anda tidak harus tetap menerapkan prinsip oo normal padanya. Jika tidak ada kecuali satu kelas yang peduli tentang konstanta - itu harus privat dan di kelas itu. Jika hanya pengujian yang peduli tentang konstanta - pengujian harus berada dalam kelas pengujian, bukan kode produksi. Jika konstanta didefinisikan di banyak tempat (tidak hanya secara tidak sengaja sama) - refactor untuk menghilangkan duplikasi. Dan seterusnya - perlakukan mereka seperti Anda memperlakukan sebuah metode.

Seperti yang dicatat Joshua Bloch dalam Effective Java:

• Antarmuka sebaiknya hanya digunakan untuk menentukan tipe,
• kelas abstrak tidak mencegah ketidakstabilan (mereka dapat dibuat subkelas, dan bahkan menyarankan bahwa kelas tersebut dirancang untuk dijadikan subkelas).

Anda dapat menggunakan Enum jika semua konstanta Anda terkait (seperti nama planet), meletakkan nilai konstanta di kelas yang terkait dengannya (jika Anda memiliki akses ke sana), atau menggunakan kelas utilitas yang tidak instan (tentukan konstruktor default pribadi) .

class SomeConstants
{
    // Prevents instanciation of myself and my subclasses
    private SomeConstants() {}

    public final static String TOTO = "toto";
    public final static Integer TEN = 10;
    //...
}

Kemudian, seperti yang telah dinyatakan, Anda dapat menggunakan impor statis untuk menggunakan konstanta Anda.

Metode pilihan saya adalah tidak melakukan itu sama sekali. Umur konstanta cukup banyak mati ketika Java 5 memperkenalkan enum typesafe. Dan bahkan sebelum itu Josh Bloch menerbitkan versi (yang sedikit lebih bertele-tele) dari itu, yang bekerja pada Java 1.4 (dan sebelumnya).

Kecuali Anda memerlukan interoperabilitas dengan beberapa kode lama, sebenarnya tidak ada alasan untuk menggunakan konstanta String / integer lagi.

Gunakan saja kelas terakhir.

Jika Anda ingin dapat menambahkan nilai lain gunakan kelas abstrak.

Tidak masuk akal menggunakan antarmuka, antarmuka seharusnya menentukan kontrak. Anda hanya ingin mendeklarasikan beberapa nilai konstan.

Bukankah enum adalah pilihan terbaik untuk hal-hal semacam ini?

enums baik-baik saja. IIRC, satu item di Java efektif (2nd Ed) memiliki enumkonstanta yang menghitung opsi standar yang mengimplementasikan [kata kunci Java] interfaceuntuk nilai apa pun.

Preferensi saya adalah dengan menggunakan [Java kata kunci] interfacedi atas final classuntuk konstanta. Anda secara implisit mendapatkan file public static final. Beberapa orang akan berpendapat bahwa interfacememungkinkan pemrogram yang buruk untuk menerapkannya, tetapi pemrogram yang buruk akan menulis kode yang menyebalkan apa pun yang Anda lakukan.

Mana yang terlihat lebih baik?

public final class SomeStuff {
     private SomeStuff() {
         throw new Error();
     }
     public static final String SOME_CONST = "Some value or another, I don't know.";
}

Atau:

public interface SomeStuff {
     String SOME_CONST = "Some value or another, I don't know.";
}

Atau 4. Letakkan mereka di kelas yang berisi logika yang paling banyak menggunakan konstanta

... maaf, tidak bisa menahan ;-)

1. Salah satu kelemahan dari private constructor adalah adanya metode yang tidak dapat diuji.

2. Konsep enum menurut sifatnya baik untuk diterapkan dalam tipe domain tertentu, menerapkannya pada konstanta desentralisasi terlihat tidak cukup baik

Konsep Enum adalah "Pencacahan adalah sekumpulan item yang terkait erat".

3. Memperluas / mengimplementasikan antarmuka konstan adalah praktik yang buruk, sulit untuk memikirkan persyaratan untuk memperluas konstanta yang tidak dapat diubah alih-alih merujuknya secara langsung.

4. Jika menerapkan alat berkualitas seperti SonarSource, ada aturan yang memaksa pengembang untuk menjatuhkan antarmuka konstan, ini adalah hal yang aneh karena banyak proyek menikmati antarmuka yang konstan dan jarang melihat hal-hal "memperluas" terjadi pada antarmuka yang konstan