자바 디자인 패턴.

JAVA Design Pattern

Design patterns are reusable solutions to common software design problems. They are templates that can be applied to different situations, helping developers to solve problems more efficiently. In this blog post, we will discuss some of the most important design patterns in Java.

Singleton Pattern

The Singleton pattern is used to ensure that only one instance of a class is created and that it is globally accessible. This pattern is useful when you need to ensure that there is only one instance of a class, such as a configuration manager or a database connection.

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
        // private constructor
    }

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

Factory Pattern

The Factory pattern is used to create objects without exposing the creation logic to the client. This pattern is useful when you need to create objects that are complex or have dependencies.

public interface Shape {
    void draw();
}

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

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

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

Observer Pattern

The Observer pattern is used when you need to notify multiple objects about changes to a single object. This pattern is useful when you need to decouple the subject from its observers.

public interface Observer {
    void update();
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Observer notified");
    }
}

Decorator Pattern

The Decorator pattern is used to add functionality to an object dynamically. This pattern is useful when you need to add functionality to an object without changing its interface.

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecorator operation");
    }
}

Conclusion

Design patterns are an important part of software development. They help developers to solve common problems more efficiently and to create more maintainable code. In this blog post, we discussed some of the most important design patterns in Java, including the Singleton pattern, the Factory pattern, the Observer pattern, and the Decorator pattern. By using these patterns, you can create more robust and flexible software that is easier to maintain and extend.