SOLIDE - De zéro à la pomme de terre 2

À propos du principe ouvert/fermé (OCP)

Cet article explique 'SOLID' en termes d'exemple, si vous n'avez pas encore lu la partie 1 ou si vous ne savez pas ce qu'est le principe de responsabilité unique , veuillez lire la partie 1 .

Aujourd'hui, je vais vous expliquer le principe ouvert/fermé (OCP). Dans OCP, la classe doit être ouverte à l'extension mais fermée à la modification. Ce principe nous encourage à écrire du code d'une manière qui permet une extension facile sans modifier le code existant.

Dans le contexte d'une Studentclasse, nous devons concevoir la classe de manière à nous permettre d'ajouter de nouvelles fonctionnalités ou comportements à un objet étudiant sans avoir à modifier le code de classe existant. Par exemple, nous pourrions utiliser l'héritage pour créer différents types d'étudiants (tels que des étudiants en ligne ou des étudiants internationaux) qui héritent d'une Studentclasse de base.

Êtes-vous confus quant à la façon dont sera le cas d'utilisation en temps réel ?, Ne vous inquiétez pas, vous comprendrez après avoir lu l'article.

Disons que nous avons une Studentclasse avec une méthode qui calcule la moyenne pondérée cumulative (GPA) de l'élève en fonction de ses notes :

class Student(val name: String, val grades: List<Double>) {
    fun calculateGPA(): Double {
        var sum = 0.0
        for (grade in grades) {
            sum += grade
        }
        return sum / grades.size
    }
}

class Student(val name: String, val grades: List<Pair<Double, Int>>) {
    fun calculateGPA(): Double {
        var sum = 0.0
        var creditSum = 0
        for ((grade, credits) in grades) {
            sum += grade * credits
            creditSum += credits
        }
        return sum / creditSum
    }
}

Alors, laissez-nous trouver le meilleur moyen en termes d' OCP, donc je refactorise la classe ci-dessus en utilisant l'héritage et crée une nouvelle sous-classe qui ajoute la nouvelle fonctionnalité :

open class Student(val name: String, val grades: List<Double>) {
    open fun calculateGPA(): Double {
        var sum = 0.0
        for (grade in grades) {
            sum += grade
        }
        return sum / grades.size
    }
}

class WeightedGPAStudent(name: String, grades: List<Pair<Double, Int>>) : Student(name, grades) {
    override fun calculateGPA(): Double {
        var sum = 0.0
        var creditSum = 0
        for ((grade, credits) in grades) {
            sum += grade * credits
            creditSum += credits
        }
        return sum / creditSum
    }
}

Cette approche adhère au principe ouvert/fermé car elle nous permet d'étendre les fonctionnalités de la Studentclasse sans modifier le code existant. La classe de base est fermée pour modification, mais ouverte pour extension par héritage.

J'espère que vous comprendrez mieux le principe ouvert / fermé et cet article vous sera utile.