The wonderful use of design patterns in avoiding code duplication

Design patterns reduce code duplication by providing reusable solutions, thereby making code more maintainable and readable. These patterns include: Factory Pattern: Used to create objects without specifying their concrete class. Strategy pattern: Allows an algorithm or behavior to change independently of how it is used. Singleton pattern: ensures that there is only one instance of a specific class. Observer pattern: allows objects to subscribe to events and be notified of them when they occur. Decoration mode: Dynamically extend the functionality of an object.

The wonderful use of design patterns in avoiding code duplication

Design patterns are reusable solutions to common software design problems. They can help keep code maintainable and readable by reducing code duplication.

Common design patterns to avoid code duplication

• Factory pattern: Used to create objects without specifying their concrete classes. This helps couple your code, allowing you to easily change the logic of creating objects.
• Strategy Mode: Allows an algorithm or behavior to change independently of how it is used. It allows you to create flexible applications by combining different policy objects.
• Singleton pattern: Ensures that there is only one instance of a specific class. This helps avoid the overhead of creating multiple identical objects.
• Observer Pattern: Allows objects to subscribe to events and then notify them when an event occurs. It is used to create loose coupling between objects.
• Decoration mode: Dynamicly extend the functionality of the object. It allows adding new functionality without modifying the original class.

Practical Case: Factory Pattern

Consider creating an application for creating various shapes. Without using design mode, you would need to write separate code for each shape.

public class Square {
    public void draw() {
        // ...
    }
}

public class Circle {
    public void draw() {
        // ...
    }
}

public class Rectangle {
    public void draw() {
        // ...
    }
}

Using the factory pattern, you can separate the creation logic from the created object:

public interface Shape {
    void draw();
}

public class ShapeFactory {
    public static Shape createShape(String type) {
        switch (type) {
            case "square":
                return new Square();
            case "circle":
                return new Circle();
            case "rectangle":
                return new Rectangle();
        }
        return null;
    }
}

Now you can do this by simply calling ShapeFactory.createShape("square") to easily create different types of shape objects.

The above is the detailed content of The wonderful use of design patterns in avoiding code duplication. For more information, please follow other related articles on the PHP Chinese website!