Pembangunan Java: Bagaimana untuk memfaktorkan semula kod dan menggunakan corak reka bentuk

Pembangunan Java: Cara melakukan pemfaktoran semula kod dan aplikasi corak reka bentuk

Dalam pembangunan perisian, pemfaktoran semula kod dan penggunaan corak reka bentuk adalah cara penting untuk meningkatkan kualiti dan kebolehselenggaraan kod. Pemfaktoran semula kod merujuk kepada penambahbaikan struktur, reka bentuk dan prestasi kod sedia ada, manakala corak reka bentuk adalah templat yang terbukti untuk menyelesaikan masalah. Artikel ini akan memperkenalkan cara memfaktorkan semula kod dan menggunakan corak reka bentuk serta memberikan contoh kod khusus.

1. Pemfaktoran Semula Kod

1. Kaedah Ekstrak

Kaedah Ekstrak adalah untuk mengekstrak kod berulang ke dalam kaedah bebas untuk meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Sebagai contoh, kod berikut telah mengulangi logik di beberapa tempat:

public void printUserInfo(User user) {
    System.out.println("Name: " + user.getName());
    System.out.println("Age: " + user.getAge());
    System.out.println("Email: " + user.getEmail());
}

public void printOrderInfo(Order order) {
    System.out.println("Order ID: " + order.getId());
    System.out.println("Order Date: " + order.getDate());
    System.out.println("Order Total: " + order.getTotal());
}

Kita boleh mengekstrak kod berulang ini ke dalam kaedah bebas:

public void printInfo(String label, Printable printable) {
    System.out.println(label + printable.getInfo());
}

public interface Printable {
    String getInfo();
}

public class User implements Printable {
    // ...
    public String getInfo() {
        return "Name: " + name + "
Age: " + age + "
Email: " + email;
    }
}

public class Order implements Printable {
    // ...
    public String getInfo() {
        return "Order ID: " + id + "
Order Date: " + date + "
Order Total: " + total;
    }
}

Dengan mengekstrak kaedah, kita boleh mengurangkan pertindihan kod dan menjadikannya lebih baik Bungkus dan guna semula logik.

2. Menyatukan Ungkapan Bersyarat

Apabila kita mendapati bahawa terdapat logik berulang dalam berbilang ungkapan bersyarat, kita boleh menggabungkannya menjadi ungkapan yang lebih ringkas dan lebih mudah dibaca. Sebagai contoh, kod berikut mempunyai logik penghakiman berulang:

public double calculateDiscount(double price, int quantity) {
    double discount = 0.0;
    if (price > 100 && quantity > 5) {
        discount = price * 0.1;
    } else if (price > 200 && quantity > 10) {
        discount = price * 0.2;
    } else if (price > 300 && quantity > 15) {
        discount = price * 0.3;
    }
    return discount;
}

Kita boleh menggabungkan syarat berulang ini menjadi ungkapan yang lebih mudah:

public double calculateDiscount(double price, int quantity) {
    double discount = 0.0;
    if (price > 300 && quantity > 15) {
        discount = price * 0.3;
    } else if (price > 200 && quantity > 10) {
        discount = price * 0.2;
    } else if (price > 100 && quantity > 5) {
        discount = price * 0.1;
    }
    return discount;
}

Dengan menggabungkan syarat berulang, kita boleh meningkatkan kebolehbacaan dan penyelenggaraan jantina kod.

2. Aplikasi corak reka bentuk

1. Corak tunggal (Singleton)

Corak singleton ialah corak reka bentuk yang memastikan bahawa kelas hanya mempunyai satu contoh dan menyediakan titik akses global. Dalam pembangunan sebenar, mod tunggal sering digunakan untuk mengurus sumber yang dikongsi, maklumat konfigurasi, dsb. Berikut ialah contoh mudah corak tunggal:

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

Dengan menggunakan mekanisme penguncian yang disemak dua kali, kami boleh menjamin penciptaan contoh unik dalam persekitaran berbilang benang.

2. Corak Kilang (Kilang)

Corak kilang ialah corak reka bentuk yang mencipta objek berbeza berdasarkan parameter yang berbeza. Dalam pembangunan sebenar, corak kilang sering digunakan untuk menyembunyikan logik penciptaan objek dan menyediakan antara muka yang konsisten untuk mencipta objek. Berikut ialah contoh corak kilang yang mudah:

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class ShapeFactory {
    public static Shape createShape(String type) {
        if (type.equals("circle")) {
            return new Circle();
        } else if (type.equals("rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

Dengan menggunakan corak kilang, kita boleh memisahkan penciptaan dan penggunaan objek, meningkatkan fleksibiliti dan kebolehselenggaraan kod.

Ringkasan:

Pemfaktoran semula kod dan penerapan corak reka bentuk adalah cara penting untuk meningkatkan kualiti dan kebolehselenggaraan kod. Dengan memfaktorkan semula kod dengan betul dan menggunakan corak reka bentuk, kami boleh mengurangkan pertindihan kod dan meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Dalam pembangunan sebenar, kita juga perlu memilih teknik pemfaktoran semula dan corak reka bentuk yang sesuai untuk mengoptimumkan kod berdasarkan situasi sebenar dan keperluan reka bentuk projek.

Atas ialah kandungan terperinci Pembangunan Java: Bagaimana untuk memfaktorkan semula kod dan menggunakan corak reka bentuk. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!