Open Closed Principle

1.open_closed_principle.MD

This is an example of the open closed principle. The first file (2.non_ocp.dart) shows an example not using the principle and the second (3.using_ocp.dart) shows a refactor of it using the principle.

2.non_ocp.dart

// ---------------------------------------------------------------------
// example NOT using the Open-Closed Principle:

class Shape {
  Shape(this.type, this.value, this.height);
  final String type;
  final double value;
  final double? height;
}

class AreaCalculator {
  double calculateArea(Shape shape) {
    if (shape.type == 'circle') {
      // in this case the value is the radius
      return pi * shape.value * shape.value;
    } else if (shape.type == 'square') {
      // in this case the value is the side of the square
      return shape.value * shape.value;
    } else if (shape.type == 'triangle') {
      // in this case the value is the base of the triangle
      return shape.value * shape.height! / 2;
    } else {
      return 0;
    }
  }
}

3.using_ocp.dart

// ---------------------------------------------------------------------
// example USING the Open-Closed Principle:


abstract class Shape {
  double calculateArea();
}

class Circle implements Shape {
  Circle(this.radius);
  final double radius;
  @override
  double calculateArea() {
    return pi * radius * radius;
  }
}

class Square implements Shape {
  Square(this.side);
  final double side;
  @override
  double calculateArea() {
    return side * side;
  }
}

class Triangle implements Shape {
  Triangle(this.base, this.height);
  final double base;
  final double height;
  @override
  double calculateArea() {
    return base * height / 2;
  }
}

class AreaCalculator {
  double calculateArea(Shape shape) {
    return shape.calculateArea();
  }
}

@MOPineyro
good observation! The way switch works now in Dart can be helpful, it's a good approach too. But, in this case, it would break the open-closed principle, considering that for OCP we shouldn't be applying changes to the existing code by adding new statements. the principle states that we should prioritize the extension rather than the modification of the classes we already have in the code.