SOLID /

2. Otwarte – Zamknięte

Otwarte – Zamknięte (Open-Closed Principle, OCP)

Zasada ta mówi, że klasa powinna być otwarta na rozszerzenia, ale zamknięta dla modyfikacji. Oznacza to, że można rozszerzyć zachowanie klasy, ale nie powinno się zmieniać już istniejącego kodu.

Poniżej znajdziesz przykład zasady OCP w języku Java.
Załóżmy, że mamy klasę Shape reprezentującą różne kształty, a my chcemy obliczyć pole powierzchni dla różnych kształtów.
Java
// Klasa łamiąca zasadę OCP
class Shape {
    private String type;

    public Shape(String type) {
        this.type = type;
    }

    public double calculateArea() {
        double area = 0.0;

        if (type.equals("Circle")) {
            // logika obliczania pola powierzchni dla koła
            area = /*...*/;
        } else if (type.equals("Square")) {
            // logika obliczania pola powierzchni dla kwadratu
            area = /*...*/;
        }

        return area;
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie klasy łamiącej zasadę OCP
        Shape circle = new Shape("Circle");
        double circleArea = circle.calculateArea();
        System.out.println("Circle area: " + circleArea);

        Shape square = new Shape("Square");
        double squareArea = square.calculateArea();
        System.out.println("Square area: " + squareArea);
    }
}

W powyższym przykładzie klasa Shape łamie zasadę OCP, ponieważ każda nowa forma wymaga modyfikacji istniejącej klasy.

Aby poprawić to naruszenie, możemy użyć dziedziczenia i polimorfizmu, aby umożliwić łatwe rozszerzanie funkcjonalności dla nowych kształtów, bez modyfikacji istniejącego kodu.

Java
// Klasa spełniająca zasadę OCP
abstract class Shape {
    public abstract double calculateArea();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Square extends Shape {
    private double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double calculateArea() {
        return side * side;
    }
}

public class Main {
    public static void main(String[] args) {
        // Użycie klas spełniających zasadę OCP
        Shape circle = new Circle(5.0);
        double circleArea = circle.calculateArea();
        System.out.println("Circle area: " + circleArea);

        Shape square = new Square(4.0);
        double squareArea = square.calculateArea();
        System.out.println("Square area: " + squareArea);
    }
}

W poprawionym przykładzie mamy abstrakcyjną klasę Shape, a każdy nowy kształt dziedziczy po niej.

Dzięki temu możemy łatwo dodawać nowe kształty, nie modyfikując istniejącego kodu klasy Shape.

To spełnia zasadę OCP.

Scroll to Top