Open / gesloten principe in Java

1. Overzicht

In deze tutorial bespreken we het Open / Gesloten Principe (OCP) als een van de SOLID-principes van objectgeoriënteerd programmeren.

In het algemeen zullen we in detail ingaan op wat dit principe is en hoe het geïmplementeerd kan worden bij het ontwerpen van onze software.

2. Open / gesloten principe

Zoals de naam suggereert, stelt dit principe dat software-entiteiten open moeten staan ​​voor uitbreiding, maar gesloten voor wijziging. Als gevolg hiervan kan de entiteit worden uitgebreid, maar niet worden gewijzigd wanneer de bedrijfsvereisten veranderen.

Voor de onderstaande illustratie, we zullen ons concentreren op hoe interfaces een manier zijn om OCP te volgen.

2.1. Voldoet niet

Laten we eens kijken dat we een rekenmachine-app bouwen die verschillende bewerkingen kan hebben, zoals optellen en aftrekken.

Allereerst zullen we een interface op het hoogste niveau definiëren - CalculatorBediening:

openbare interface CalculatorOperation {}

Laten we een Toevoeging class, die twee getallen zou toevoegen en de C zou implementerenalculatorOperation:

public class Addition implementeert CalculatorOperation {private double left; privé dubbel recht; privé dubbel resultaat = 0,0; openbare toevoeging (dubbel links, dubbel rechts) {this.left = left; this.right = right; } // getters en setters}

Vanaf nu hebben we maar één klas Toevoeging, dus we moeten een andere klasse definiëren met de naam Aftrekken:

public class Subtraction implementeert CalculatorOperation {private double left; privé dubbel recht; privé dubbel resultaat = 0,0; publiek aftrekken (dubbel links, dubbel rechts) {this.left = left; this.right = right; } // getters en setters}

Laten we nu onze hoofdklasse definiëren, die onze rekenmachinebewerkingen zal uitvoeren:

openbare klasse Calculator {openbare leegte berekenen (bewerking CalculatorOperation) {if (bewerking == null) {nieuwe invoer InvalidParameterException ("Kan bewerking niet uitvoeren"); } if (bewerking instantie van Optellen) {Optellen optellen = (Optellen) bewerking; addition.setResult (addition.getLeft () + addition.getRight ()); } else if (bewerking instantie van Aftrekken) {Aftrekken aftrekken = (Aftrekken) bewerking; subtraction.setResult (subtraction.getLeft () - subtraction.getRight ()); }}}

Hoewel dit misschien goed lijkt, is het geen goed voorbeeld van de OCP. Wanneer een nieuwe vereiste voor het toevoegen van vermenigvuldigings- of deelfunctionaliteit binnenkomt, kunnen we niet anders dan de berekenen methode van de Rekenmachine klasse.

Daarom kunnen we zeggen dat deze code niet OCP-compatibel is.

2.2. OCP-compatibel

Zoals we hebben gezien, is onze rekenmachine-app nog niet OCP-compatibel. De code in het berekenen methode zal veranderen met elke inkomende nieuwe ondersteuningsverzoek. We moeten deze code dus extraheren en in een abstractielaag plaatsen.

Een oplossing is om elke bewerking in hun respectievelijke klasse te delegeren:

openbare interface CalculatorOperation {void perform (); }

Als gevolg hiervan is het Toevoeging class zou de logica van het toevoegen van twee getallen kunnen implementeren:

public class Addition implementeert CalculatorOperation {private double left; privé dubbel recht; persoonlijk dubbel resultaat; // constructor, getters en setters @Override public void perform () {resultaat = links + rechts; }}

Evenzo een bijgewerkt Aftrekken klasse zou een vergelijkbare logica hebben. En vergelijkbaar met Toevoeging en Aftrekken, als een nieuw wijzigingsverzoek, zouden we het divisie logica:

public class Division implementeert CalculatorOperation {private double left; privé dubbel recht; persoonlijk dubbel resultaat; // constructor, getters en setters @Override public void perform () {if (right! = 0) {result = left / right; }}}

En tot slot onze Rekenmachine class hoeft geen nieuwe logica te implementeren aangezien we nieuwe operators introduceren:

openbare klasse Calculator {openbare leegte berekenen (bewerking CalculatorOperation) {if (bewerking == null) {nieuwe invoer InvalidParameterException ("Kan bewerking niet uitvoeren"); } operation.perform (); }} 

Op die manier is de klas Gesloten voor wijziging maar Open voor een extensie.

3. Conclusie

In deze tutorial hebben we geleerd wat OCP per definitie is, en hebben we die definitie verder uitgewerkt. We zagen toen een voorbeeld van een eenvoudige rekenmachine-applicatie die gebrekkig was in het ontwerp. Ten slotte hebben we het ontwerp goed gemaakt door het aan de OCP te laten voldoen.

Zoals altijd is de code beschikbaar op GitHub.