Pemalar di Jawa: Corak dan Anti-Pola

1. Pengenalan

Dalam artikel ini, kita akan belajar tentang penggunaan pemalar di Java dengan fokus pada pola umum dan anti-pola.

Kita akan mulakan dengan beberapa konvensyen asas untuk menentukan pemalar. Dari sana, kita akan beralih ke pola anti biasa sebelum menyelesaikan dengan melihat corak biasa.

2. Asas

Pemalar ialah pemboleh ubah yang nilainya tidak akan berubah setelah ditentukan.

Mari lihat asas untuk menentukan pemalar:

private static final int OUR_CONSTANT = 1;

Sebilangan corak yang akan kita lihat akan menangani keputusan pengubah akses awam atau swasta . Kami menjadikan pemalar kami statik dan akhir dan memberi mereka jenis yang sesuai, baik itu primitif Java, kelas, atau enum . Nama itu harus berupa huruf besar dengan kata-kata yang dipisahkan oleh garis bawah , kadang-kadang dikenali sebagai cengkerik ular. Akhirnya, kami memberikan nilai itu sendiri.

3. Anti-Corak

Pertama, mari mulakan dengan belajar apa yang tidak boleh dilakukan. Mari kita lihat beberapa pola anti-umum yang mungkin kita hadapi ketika bekerja dengan pemalar Java.

3.1. Nombor Ajaib

Nombor ajaib adalah literal numerik dalam sekumpulan kod:

if (number == 3.14159265359) { // ... }

Mereka sukar difahami oleh pemaju lain. Selain itu, jika kita menggunakan nombor di seluruh kod kita, sukar untuk mengubah nilai. Sebaliknya, kita harus menentukan nombor sebagai pemalar.

3.2. Kelas Pemalar Global yang Besar

Semasa kita memulakan projek, mungkin wajar untuk membuat kelas bernama Constants or Utils dengan tujuan untuk menentukan semua pemalar untuk aplikasi di sana. Untuk projek yang lebih kecil, ini mungkin baik, tetapi mari kita pertimbangkan beberapa sebab mengapa ini bukan penyelesaian yang ideal.

Pertama, bayangkan kita mempunyai seratus atau lebih pemalar di kelas pemalar kita. Sekiranya kelas tidak dikekalkan, baik untuk mengikuti dokumentasi dan kadang-kadang mengubah pemalar menjadi pengelompokan logik, ia akan menjadi sangat sukar dibaca. Kita bahkan boleh berakhir dengan pendua pendua dengan nama yang sedikit berbeza. Pendekatan ini mungkin memberi kita masalah kebolehbacaan dan kesenggaraan dalam apa jua projek yang terkecil.

Sebagai tambahan kepada logistik untuk mengekalkan kelas Konstanta itu sendiri, kami juga mengundang masalah pemeliharaan lain dengan mendorong ketergantungan terlalu banyak dengan kelas pemalar global yang satu ini dan pelbagai bahagian lain dari aplikasi kami.

Di sisi yang lebih teknikal, penyusun Java meletakkan nilai pemalar menjadi pemboleh ubah rujukan dalam kelas di mana kita menggunakannya . Oleh itu, jika kita menukar salah satu pemalar di kelas pemalar kita dan hanya mengumpul semula kelas itu dan bukan kelas rujukan, kita dapat memperoleh nilai pemalar yang tidak konsisten.

3.3. Anti-Corak Antara Muka Yang Tetap

Corak antara muka malar adalah ketika kita menentukan antara muka yang mengandungi semua pemalar untuk fungsi tertentu dan kemudian mempunyai kelas yang memerlukan fungsi tersebut untuk melaksanakan antara muka.

Mari tentukan antara muka tetap untuk kalkulator:

public interface CalculatorConstants { double PI = 3.14159265359; double UPPER_LIMIT = 0x1.fffffffffffffP+1023; enum Operation {ADD, SUBTRACT, MULTIPLY, DIVIDE}; }

Seterusnya, kami akan melaksanakan antara muka CalculatorConstants kami :

public class GeometryCalculator implements CalculatorConstants { public double operateOnTwoNumbers(double numberOne, double numberTwo, Operation operation) { // Code to do an operation } }

Argumen pertama menentang penggunaan antara muka tetap adalah bahawa ia bertentangan dengan tujuan antara muka. Kami bermaksud menggunakan antara muka untuk membuat kontrak untuk tingkah laku yang akan diberikan oleh kelas pelaksana kami. Apabila kita membuat antara muka yang penuh dengan pemalar, kita tidak menentukan tingkah laku.

Kedua, menggunakan antara muka yang berterusan membuka kita kepada masalah jangka masa yang disebabkan oleh bayangan lapangan. Mari lihat bagaimana perkara itu mungkin berlaku dengan menentukan pemalar UPPER_LIMIT dalam kelas GeometryCalculator kami :

public static final double UPPER_LIMIT = 100000000000000000000.0;

Sebaik sahaja kita menentukan pemalar itu di kelas GeometryCalculator , kita menyembunyikan nilainya di antara muka CalculatorConstants untuk kelas kita. Kami kemudian dapat memperoleh hasil yang tidak dijangka.

Hujah lain terhadap anti-corak ini adalah bahawa ia menyebabkan pencemaran ruang nama. CalculatorConstants kami sekarang akan berada di ruang nama untuk mana-mana kelas kami yang melaksanakan antara muka dan juga subkelas mereka.

4. Corak

Sebelumnya, kami melihat bentuk yang sesuai untuk menentukan pemalar. Mari kita lihat beberapa amalan baik lain untuk menentukan pemalar dalam aplikasi kita.

4.1. Amalan Am Am

Sekiranya pemalar berkaitan secara logik dengan kelas, kita boleh menentukannya di sana. Sekiranya kita melihat sekumpulan pemalar sebagai anggota jenis yang dihitung, kita boleh menggunakan enum untuk menentukannya.

Mari tentukan beberapa pemalar dalam kelas Kalkulator :

public class Calculator { public static final double PI = 3.14159265359; private static final double UPPER_LIMIT = 0x1.fffffffffffffP+1023; public enum Operation { ADD, SUBTRACT, DIVIDE, MULTIPLY } public double operateOnTwoNumbers(double numberOne, double numberTwo, Operation operation) { if (numberOne > UPPER_LIMIT) { throw new IllegalArgumentException("'numberOne' is too large"); } if (numberTwo > UPPER_LIMIT) { throw new IllegalArgumentException("'numberTwo' is too large"); } double answer = 0; switch(operation) { case ADD: answer = numberOne + numberTwo; break; case SUBTRACT: answer = numberOne - numberTwo; break; case DIVIDE: answer = numberOne / numberTwo; break; case MULTIPLY: answer = numberOne * numberTwo; break; } return answer; } }

Dalam contoh kami, kami telah menetapkan pemalar untuk UPPER_LIMIT yang hanya kami rancang untuk digunakan di kelas Kalkulator , jadi kami menetapkannya menjadi peribadi . Kami mahu kelas lain dapat menggunakan PI dan enum Operasi , jadi kami menetapkannya kepada umum .

Let's consider some of the advantages of using an enum for Operation. The first advantage is that it limits the possible values. Imagine that our method takes a string for the operation value with the expectation that one of four constant strings is supplied. We can easily foresee a scenario where a developer calling the method sends their own string value. With the enum, the values are limited to those we define. We can also see that enums are especially well suited to use in switch statements.

4.2. Constants Class

Now that we've looked at some general good practices, let's consider the case when a constants class might be a good idea. Let's imagine our application contains a package of classes that need to do various kinds of mathematical calculations. In this case, it probably makes sense for us to define a constants class in that package for constants that we'll use in our calculations classes.

Let's create a MathConstants class:

public final class MathConstants { public static final double PI = 3.14159265359; static final double GOLDEN_RATIO = 1.6180; static final double GRAVITATIONAL_ACCELERATION = 9.8; static final double EULERS_NUMBER = 2.7182818284590452353602874713527; public enum Operation { ADD, SUBTRACT, DIVIDE, MULTIPLY } private MathConstants() { } }

The first thing we should notice is that our class is final to prevent it from being extended. Additionally, we've defined a private constructor so it can't be instantiated. Finally, we can see that we've applied the other good practices we discussed earlier in the article. Our constant PI is public because we anticipate needing to access it outside of our package. The other constants we've left as package-private, so we can access them within our package. We've made all of our constants static and final and named them in a screaming snake case. The operations are a specific set of values, so we've used an enum untuk menentukan mereka.

Kita dapat melihat bahawa kelas pemalar tahap pakej khusus kita berbeza dengan kelas pemalar global yang besar kerana ia dilokalkan ke pakej kita dan mengandungi pemalar yang relevan dengan kelas pakej itu.

5. Kesimpulan

Dalam artikel ini, kami mempertimbangkan kebaikan dan keburukan dari beberapa corak dan anti-corak paling popular yang dilihat ketika menggunakan pemalar di Jawa. Kami memulakan dengan beberapa peraturan pemformatan asas, sebelum merangkumi anti-corak. Setelah mengetahui beberapa pola anti-biasa, kami melihat corak yang sering kami lihat berlaku pada pemalar.

Seperti biasa kodnya tersedia di GitHub.