Développement Java : comment refactoriser le code et appliquer des modèles de conception

Développement Java : Comment effectuer une refactorisation de code et l'application de modèles de conception

Dans le développement de logiciels, la refactorisation de code et l'application de modèles de conception sont des moyens importants pour améliorer la qualité et la maintenabilité du code. La refactorisation du code fait référence à l'amélioration de la structure, de la conception et des performances du code existant, tandis que les modèles de conception sont des modèles éprouvés pour résoudre les problèmes. Cet article expliquera comment refactoriser le code et appliquer des modèles de conception, et donnera des exemples de code spécifiques.

1. Refactorisation de code

1. Méthode d'extraction

La méthode d'extraction consiste à extraire un code répétitif dans une méthode indépendante pour augmenter la lisibilité et la maintenabilité du code. Par exemple, le code suivant a une logique répétée à plusieurs endroits :

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());
}

Nous pouvons extraire ce code répété dans une méthode indépendante :

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;
    }
}

En extrayant les méthodes, nous pouvons réduire la duplication du code et l'améliorer. Encapsuler et réutiliser la logique.

2. Consolider l'expression conditionnelle

Lorsque nous constatons qu'il existe une logique répétée dans plusieurs expressions conditionnelles, nous pouvons les fusionner en une expression plus simple et plus lisible. Par exemple, le code suivant a une logique de jugement répété :

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;
}

Nous pouvons fusionner cette condition répétée en une expression plus simple :

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;
}

En fusionnant des conditions répétées, nous pouvons améliorer la lisibilité et la maintenance du code sexe.

2. Application de modèle de conception

1. Modèle Singleton (Singleton)

Le modèle singleton est un modèle de conception qui garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global. Dans le développement réel, le mode singleton est souvent utilisé pour gérer les ressources partagées, les informations de configuration, etc. Voici un exemple simple du modèle singleton :

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;
    }
}

En utilisant le mécanisme de verrouillage à double vérification, nous pouvons garantir la création d'une instance unique dans un environnement multithread.

2. Factory

Le modèle d'usine est un modèle de conception qui crée différents objets en fonction de différents paramètres. Dans le développement réel, le modèle d'usine est souvent utilisé pour masquer la logique de création d'objets et fournir une interface cohérente pour créer des objets. Voici un exemple simple de modèle d'usine :

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;
    }
}

En utilisant le modèle d'usine, nous pouvons découpler la création et l'utilisation d'objets, augmentant ainsi la flexibilité et la maintenabilité du code.

Résumé :

La refactorisation du code et l'application de modèles de conception sont des moyens importants pour améliorer la qualité et la maintenabilité du code. En refactorisant correctement le code et en appliquant des modèles de conception, nous pouvons réduire la duplication de code et améliorer la lisibilité et la maintenabilité du code. Dans le développement réel, nous devons également choisir des techniques de refactorisation et des modèles de conception appropriés pour optimiser le code en fonction de la situation réelle et des exigences de conception du projet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!