Petua Penting untuk Pengekodan dalam Java

1. Gunakan Corak Reka Bentuk dengan Berkesan

Corak reka bentuk terbukti penyelesaian kepada masalah biasa dalam reka bentuk perisian. Melaksanakannya dengan betul boleh menjadikan kod anda lebih boleh diselenggara, berskala dan mudah difahami.

1.1 Corak Singleton

Corak Singleton memastikan bahawa kelas hanya mempunyai satu tika dan menyediakan titik global akses kepadanya.

Contoh:

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Private constructor to prevent instantiation
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

Corak ini amat berguna untuk sumber seperti sambungan pangkalan data, di mana hanya satu kejadian yang harus wujud.

1.2 Corak Kilang

Corak Kilang menyediakan antara muka untuk mencipta objek dalam kelas super, tetapi membenarkan subkelas mengubah jenis objek yang akan dibuat.

Contoh:

public abstract class Animal {
    abstract void makeSound();
}

public class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof");
    }
}

public class AnimalFactory {
    public static Animal createAnimal(String type) {
        if ("Dog".equals(type)) {
            return new Dog();
        }
        // Additional logic for other animals
        return null;
    }
}

Corak ini sesuai untuk situasi di mana jenis objek yang tepat perlu ditentukan semasa masa jalan.

2. Manfaatkan Strim Java untuk Pemprosesan Data yang Lebih Baik

API Aliran Java yang diperkenalkan dalam Java 8 menyediakan cara yang berkuasa untuk memproses jujukan elemen dalam gaya berfungsi.

2.1 Penapisan dan Pemetaan

Penapisan dan pemetaan ialah operasi biasa yang dilakukan pada koleksi.

Contoh:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
List<String> result = names.stream()
                            .filter(name -> name.startsWith("A"))
                            .map(String::toUpperCase)
                            .collect(Collectors.toList());
System.out.println(result); // Output: [ALICE]

Kod ringkas dan boleh dibaca ini menapis nama yang bermula dengan 'A' dan menukarnya kepada huruf besar.

2.2 Mengurangkan

Kaedah kurangkan boleh mengagregatkan elemen aliran untuk menghasilkan satu hasil.

Contoh:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, Integer::sum);
System.out.println(sum); // Output: 15

Operasi kurangkan menjumlahkan semua elemen dalam senarai, mempamerkan kuasa strim untuk pengagregatan.

3. Tulis Kod Boleh Baca dan Boleh Diselenggara

Kod yang boleh dibaca lebih mudah untuk diselenggara, nyahpepijat dan dilanjutkan. Mengikuti beberapa prinsip asas boleh meningkatkan kualiti kod anda.

3.1 Ikuti Konvensyen Penamaan

Java telah mewujudkan konvensyen penamaan yang harus diikuti untuk meningkatkan kebolehbacaan kod.

Contoh:

• Nama kelas hendaklah kata nama dan bermula dengan huruf besar: Orang , Pengurus Akaun.
• Nama kaedah hendaklah kata kerja dan bermula dengan huruf kecil: getName(), calculateGaji().

3.2 Gunakan Komen dengan Berhemat

Komen harus digunakan untuk menjelaskan mengapa sesuatu dilakukan, bukan apa yang dilakukan. Kod yang ditulis dengan baik hendaklah jelas.

Contoh:

// Calculates the sum of an array of numbers
public int calculateSum(int[] numbers) {
    int sum = 0;
    for (int num : numbers) {
        sum += num;
    }
    return sum;
}

Nama kaedah yang jelas seperti calculateSum menjadikan kod itu boleh difahami tanpa ulasan yang berlebihan.

4. Menguasai Pengendalian Pengecualian

Pengendalian pengecualian yang betul adalah penting untuk membina aplikasi Java yang mantap.

4.1 Gunakan Pengecualian Khusus

Sentiasa dapatkan pengecualian paling spesifik yang mungkin dan bukannya pengecualian generik.

Contoh:

try {
    // Code that may throw an exception
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

Menangkap pengecualian khusus membolehkan pengendalian ralat yang lebih tepat dan penyahpepijatan yang lebih mudah.

4.2 Elakkan Pengecualian Menelan

Pengecualian menelan boleh menyembunyikan pepijat dan menyukarkan untuk memahami perkara yang salah.

Contoh:

try {
    // Code that may throw an exception
    int result = 10 / 0;
} catch (ArithmeticException e) {
    e.printStackTrace(); // Always log or handle exceptions properly
}

Pengecualian pengelogan memberikan maklumat berharga untuk penyahpepijatan dan mengekalkan kod.

5. Optimumkan Prestasi

Mengoptimumkan prestasi adalah penting, terutamanya dalam aplikasi berskala besar.

5.1 Gunakan StringBuilder untuk Penggabungan Rentetan

Menggunakan StringBuilder dan bukannya operator + untuk menggabungkan rentetan dalam gelung boleh meningkatkan prestasi dengan ketara.

Contoh:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("Hello");
}
System.out.println(sb.toString());

Pendekatan ini mengelakkan penciptaan berbilang objek rentetan, yang membawa kepada penggunaan dan prestasi memori yang lebih baik.

5.2 Optimumkan Gelung dan Koleksi

Berhati-hati dengan operasi gelung dan pengumpulan, kerana penggunaan yang tidak cekap boleh melambatkan aplikasi anda.

Contoh:

Sebaliknya:

for (int i = 0; i < list.size(); i++) {
    // Do something with list.get(i)
}

Gunakan:

for (String item : list) {
    // Do something with item
}

Gelung yang dioptimumkan ini mengelakkan panggilan saiz() beberapa kali, meningkatkan prestasi.

6. Meningkatkan Logik Pengekodan

6.1 Optimumkan jika Syarat

Apabila menulis pernyataan if, selalunya bermanfaat untuk:

Semak kes yang paling biasa dahulu:

Meletakkan keadaan yang paling biasa di bahagian atas boleh meningkatkan kebolehbacaan dan kecekapan. Dengan cara ini, kes biasa dikendalikan dengan cepat, dan kes yang kurang biasa diperiksa selepas itu.

Contoh:

if (user == null) {
    // Handle null user
} else if (user.isActive()) {
    // Handle active user
} else if (user.isSuspended()) {
    // Handle suspended user
}

6.2 Use Constants for Comparison:

When comparing values, especially with equals() method, use constants on the left side of the comparison to avoid potential NullPointerException issues. This makes your code more robust.

Example:

String status = "active";
if ("active".equals(status)) {
    // Status is active
}

6.3 Use Affirmative Conditions for Clarity

Writing conditions in an affirmative manner ( positive logic ) can make the code more readable and intuitive. For example, use if (isValid()) instead of if (!isInvalid()).

Example:

if (user.isValid()) {
    // Process valid user
} else {
    // Handle invalid user
}

7. Embrace Test-Driven Development (TDD)

Test-Driven Development (TDD) is a software development process where you write tests before writing the code that makes the tests pass. This approach ensures that your code is thoroughly tested and less prone to bugs.

7.1 Write Unit Tests First

In TDD, unit tests are written before the actual code. This helps in defining the expected behavior of the code clearly.

Example:

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result); // This test should pass
    }
}

By writing the test first, you define the expected behavior of the add method. This helps in writing focused and bug-free code.

7.2 Refactor with Confidence

TDD allows you to refactor your code with confidence, knowing that your tests will catch any regressions.

Example:

After writing the code to make the above test pass, you might want to refactor the add method. With a test in place, you can refactor freely, assured that if something breaks, the test will fail.

public int add(int a, int b) {
    return a + b; // Simple implementation
}

The test ensures that even after refactoring, the core functionality remains intact.

8. Use Immutable Objects for Data Integrity

8.1 Create Immutable Classes

To create an immutable class, declare all fields as final , do not provide setters, and initialize all fields via the constructor.

Example:

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Immutable objects like ImmutablePerson are thread-safe and prevent accidental modification, making them ideal for concurrent applications.

9. Conclusion

By following these tips, you can write more efficient, maintainable, and robust Java code. These practices not only help in developing better software but also in enhancing your skills as a Java developer. Always strive to write code that is clean, understandable, and optimized for performance.

Read posts more at : Essential Tips for Coding in Java

Atas ialah kandungan terperinci Petua Penting untuk Pengekodan dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!