# Open/Closed Principle (OCP)

#### &#x20;Open/Closed Principle (OCP) dalam PHP:

Dalam PHP, OCP dapat diterapkan dengan menggunakan warisan (inheritance) dan antarmuka (interface). Dengan menerapkan OCP, kelas-kelas harus terbuka untuk perluasan (oleh berarti dapat diwarisi), tetapi tertutup untuk modifikasi (tidak boleh mengubah perilaku kelas yang ada).

Contoh PHP dengan OCP:

```php
interface Shape {
    public function area();
}

class Circle implements Shape {
    private $radius;

    public function __construct($radius) {
        $this->radius = $radius;
    }

    public function area() {
        return 3.14 * $this->radius * $this->radius;
    }
}

class Square implements Shape {
    private $side;

    public function __construct($side) {
        $this->side = $side;
    }

    public function area() {
        return $this->side * $this->side;
    }
}
```

Dalam contoh ini, interface `Shape` mendefinisikan metode `area()`. Kelas `Circle` dan `Square` mengimplementasikan antarmuka `Shape` dan menyediakan implementasi untuk metode `area()`. Jika Anda ingin menambahkan bentuk baru, Anda dapat membuat kelas baru yang mengimplementasikan `Shape` tanpa mengubah kelas-kelas yang sudah ada.

#### Open/Closed Principle (OCP) dalam JavaScript:

Dalam JavaScript, OCP dapat diterapkan dengan cara yang mirip dengan PHP, dengan menggunakan pewarisan dan antarmuka.

Contoh JavaScript (ES6) dengan OCP:

```javascript
class Shape {
    area() {
        throw new Error("Method 'area()' must be implemented");
    }
}

class Circle extends Shape {
    constructor(radius) {
        super();
        this.radius = radius;
    }

    area() {
        return Math.PI * this.radius * this.radius;
    }
}

class Square extends Shape {
    constructor(side) {
        super();
        this.side = side;
    }

    area() {
        return this.side * this.side;
    }
}
```

Dalam contoh ini, `Shape` adalah kelas dasar yang berisi metode `area()`. `Circle` dan `Square` adalah kelas-kelas turunan yang mewarisi `Shape` dan mengimplementasikan metode `area()`. Jika Anda ingin menambahkan bentuk baru, Anda hanya perlu membuat kelas baru yang mengimplementasikan `Shape`.

#### Open/Closed Principle (OCP) dalam Golang:

Dalam Golang, OCP dapat diterapkan dengan menggunakan interface dan implementasi interface yang dapat di-extend.

Contoh Golang dengan OCP:

```go
package main

import (
    "fmt"
    "math"
)

type Shape interface {
    Area() float64
}

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

type Square struct {
    Side float64
}

func (s Square) Area() float64 {
    return s.Side * s.Side
}

func main() {
    circle := Circle{Radius: 5}
    square := Square{Side: 4}

    fmt.Println("Circle area:", circle.Area())
    fmt.Println("Square area:", square.Area())
}
```

Dalam contoh ini, `Shape` adalah interface yang menyatakan metode `Area()`. `Circle` dan `Square` adalah implementasi dari `Shape`. Dengan menggunakan interface, kita dapat membuat bentuk baru yang mengimplementasikan `Shape` tanpa mengubah kode yang sudah ada.

Dengan menerapkan OCP, kita dapat menambahkan fungsionalitas baru ke dalam sistem tanpa mengubah kode yang sudah ada, memungkinkan perluasan fungsionalitas tanpa memengaruhi perilaku kelas yang ada.
