Haruskah "pemblokir akhir statis" dideklarasikan dalam UPPER-CASE?

Di Jawa, variabel final statis adalah konstanta dan konvensi adalah bahwa mereka harus dalam huruf besar. Namun, saya telah melihat bahwa kebanyakan orang menyatakan penebang dalam huruf kecil yang muncul sebagai pelanggaran dalam PMD .

misalnya:

private static final Logger logger = Logger.getLogger(MyClass.class);

Cukup cari google atau SO untuk "pencatat akhir statis" dan Anda akan melihatnya sendiri.

Haruskah kita menggunakan LOGGER saja?

Referensi logger bukan konstanta, tetapi referensi final, dan TIDAK boleh dalam huruf besar. VALUE konstan harus dalam huruf besar.

private static final Logger logger = Logger.getLogger(MyClass.class);

private static final double MY_CONSTANT = 0.0;

Untuk menambah nilai pada jawaban crunchdog, Java Coding Style Guide menyatakan ini dalam paragraf 3.3 Penamaan Bidang

Nama bidang yang digunakan sebagai konstanta harus huruf besar semua, dengan menggarisbawahi kata-kata yang memisahkan. Berikut ini dianggap konstanta:

1. Semua static finaltipe primitif (Ingat bahwa semua bidang antarmuka secara inheren static final).
2. Semua static finaltipe referensi objek yang tidak pernah diikuti oleh " ." (titik).
3. Semua static finalarray yang tidak pernah diikuti oleh " [" (pembukaan braket persegi).

Contoh:

MIN_VALUE, MAX_BUFFER_SIZE, OPTIONS_FILE_NAME

Berikut konvensi ini, loggermerupakan static finalreferensi obyek sebagaimana dimaksud dalam butir 2, tetapi karena ini diikuti oleh " ." setiap kali Anda menggunakannya, itu tidak dapat dianggap sebagai konstan dan dengan demikian harus huruf kecil.

Dari java efektif, edisi ke-2,

Satu-satunya pengecualian pada aturan sebelumnya adalah “bidang konstan,” yang namanya harus terdiri dari satu atau beberapa kata huruf besar yang dipisahkan oleh karakter garis bawah, misalnya, VALUES atau NEGATIVE_INFINITY. Bidang konstan adalah bidang final statis yang nilainya tidak berubah . Jika bidang final statis memiliki tipe primitif atau tipe referensi yang tidak dapat diubah (Butir 15), maka itu adalah bidang konstan. Sebagai contoh, konstanta enum adalah bidang konstan. Jika bidang akhir statis memiliki jenis referensi yang bisa berubah, itu masih bisa menjadi bidang konstan jika objek yang direferensikan tidak dapat diubah.

Singkatnya, konstan == final statis, ditambah jika itu referensi (vs tipe sederhana), kekekalan.

Melihat logger slf4j, http://www.slf4j.org/api/org/slf4j/Logger.html

Itu tidak berubah. Di sisi lain, JUL logger bisa berubah. Log4j logger juga bisa berubah. Jadi benar, jika Anda menggunakan log4j atau JUL, itu harus "logger", dan jika Anda menggunakan slf4j, itu harus LOGGER.

Perhatikan bahwa halaman jfcj slf4j yang ditautkan di atas memiliki contoh di mana mereka menggunakan "logger", bukan "LOGGER".

Ini tentu saja hanya konvensi dan bukan aturan. Jika Anda kebetulan menggunakan slf4j dan Anda ingin menggunakan "logger" karena Anda terbiasa dengan itu dari kerangka kerja lain, atau jika lebih mudah untuk mengetik, atau untuk keterbacaan, silakan.

Saya suka Google mengambilnya ( Google Java Style )

Setiap konstanta adalah bidang final statis, tetapi tidak semua bidang final statis adalah konstanta. Sebelum memilih kasus konstan, pertimbangkan apakah bidang tersebut benar-benar terasa seperti konstan. Sebagai contoh, jika salah satu dari keadaan yang dapat diamati contoh itu dapat berubah, hampir pasti tidak konstan. Hanya berniat untuk tidak pernah bermutasi objek umumnya tidak cukup.

Contoh:

// Constants
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final Joiner COMMA_JOINER = Joiner.on(',');  // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }

// Not constants
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};

Jika Anda menggunakan alat otomatis untuk memeriksa standar pengkodean Anda dan itu melanggar standar kata maka itu atau standar harus diperbaiki. Jika Anda menggunakan standar eksternal, perbaiki kodenya.

Konvensi di Sun Java adalah huruf besar untuk konstanta statis publik. Jelas logger tidak konstan, tetapi merupakan hal yang bisa berubah (jika tidak, tidak ada gunanya memanggil metode dengan harapan bahwa sesuatu akan terjadi); tidak ada standar khusus untuk bidang final yang tidak konstan.

Jika Anda Google ini, Anda mungkin menemukan bahwa dalam beberapa kasus, para penebang tidak didefinisikan sebagai final statis. Tambahkan beberapa copy-n-paste cepat ke ini, dan ini mungkin menjelaskannya.

Kami menggunakan LOGGER di semua kode kami, dan ini sesuai dengan konvensi penamaan kami (dan CheckStyle kami senang dengan itu).

Kami bahkan melangkah lebih jauh, mengambil keuntungan dari konvensi penamaan yang ketat di Eclipse. Kami membuat kelas baru dengan templat kode:

    // private static final Logger LOGGER = Logger.getLogger(${enclosing_type}.class);

Logger dikomentari, karena pada awalnya kita tidak membutuhkannya. Tetapi jika kita membutuhkannya nanti, kita cukup batalkan komentar itu.

Kemudian dalam kode, kami menggunakan templat kode yang mengharapkan pencatat ini hadir. Contoh dengan templat coba tangkap:

    try {
      ${cursor} or some other template
    } catch (Exception t) {
      LOGGER.error("${methodName} ${method parameters}", t);
    }

Kami memiliki beberapa templat lagi yang menggunakannya.

The konvensi yang ketat memungkinkan kita untuk menjadi lebih produktif dan koheren dengan kode template .

Saya pribadi berpikir itu terlihat sangat besar dalam huruf besar. Selain itu, karena itu adalah kelas yang itu tidak berkaitan langsung dengan perilaku kelas, saya tidak melihat masalah besar dalam menggunakan loggerbukan LOGGER. Tetapi jika Anda akan benar-benar bertele-tele, maka gunakan LOGGER.

Jangan lupa bahwa PMD akan menghormati komentar

// NOPMD

di dalamnya. Ini akan menyebabkan PMD melewatkan garis dari pemeriksaannya, ini akan memungkinkan Anda untuk memilih gaya mana yang Anda inginkan.

Biasanya konstanta dalam huruf besar.

Logger, bagaimanapun, tidak boleh statis tetapi mencari setiap "baru" dari kelas yang mengandung jika menggunakan fasad slf4j. Ini menghindari beberapa masalah classloader yang tidak menyenangkan dalam wadah web khusus, ditambah lagi memungkinkan kerangka logger untuk melakukan hal-hal khusus tergantung pada konteks doa.

Saya lebih suka 'logger', yaitu huruf kecil. Alasannya bukan karena itu adalah konstanta atau bukan konstanta (bisa berubah atau tidak berubah). Jika kita menggunakan alasan itu, kita harus mengubah nama variabel jika kita mengubah kerangka kerja logging (atau jika kerangka kerja mengubah mutabilitas penebang).

Bagi saya, alasan lain lebih penting.

1. Logger adalah objek bayangan di kelas dan seharusnya tidak terlalu menonjol karena tidak mengimplementasikan logika utama. Jika kita menggunakan 'LOGGER', itu adalah eye catcher dalam kode yang menarik terlalu banyak perhatian.

2. Kadang-kadang penebang dideklarasikan pada level instance (yaitu tidak statis), dan bahkan disuntikkan sebagai dependensi. Saya tidak ingin mengubah kode saya jika saya memutuskan untuk mengubah cara saya mendapatkan logger. Stabilitas kode wrt. perubahan (hipotetis dalam banyak kasus) ini adalah alasan lain mengapa saya lebih suka huruf kecil.

Jika standar pengkodean Anda - jika Anda punya - katakan itu huruf besar maka ya.

Saya tidak melihat alasan ketat untuk satu atau lain cara. Saya pikir itu benar-benar tergantung pada resp suka pribadi Anda. standar pengkodean perusahaan Anda.

BTW: Saya lebih suka "LOGGER" ;-)