Inkapseling op Java

Hoi! We zullen de les van vandaag wijden aan Encapsulation in Java en beginnen met voorbeelden direct uit de poort:) Hier heb je een gewone frisdrankautomaat . Ik heb een vraag voor je: hoe werkt het? Probeer een gedetailleerd antwoord te geven: waar komt de frisdrank vandaan? Hoe wordt de interne temperatuur gehandhaafd? Waar wordt het ijs opgeslagen? Hoe weet de machine welke siroop moet worden toegevoegd? Op deze vragen heb je waarschijnlijk geen antwoord. Oké, misschien gebruikt niet iedereen deze machines. Momenteel zijn ze niet zo populair. Laten we een ander voorbeeld proberen. Iets wat je zeker elke dag vele malen gebruikt. O, ik heb een idee! Vertel me hoe de Google-zoekmachinewerken. Hoe zoekt het precies naar informatie over de woorden die u invoert? Waarom staan ​​deze resultaten bovenaan en andere niet? Ook al gebruik je Google elke dag, je weet het waarschijnlijk niet. Maar dat maakt niet uit. Het is tenslotte niet iets dat je hoeft te weten. U kunt een zoekmachine gebruiken zonder na te denken over hoe het precies werkt. Je kunt frisdrank uit een automaat kopen zonder te weten hoe die is gebouwd. Je kunt autorijden zonder je te verdiepen in hoe de verbrandingsmotor werkt en zonder zelfs maar kennis te hebben van natuurkunde op de middelbare school. Dit is allemaal mogelijk dankzij een van de belangrijkste principes van objectgeoriënteerd programmeren: inkapseling. Bij het lezen van verschillende artikelen over dit onderwerp, moet u twee wijdverbreide programmeerconcepten zijn tegengekomen: inkapseling en informatie verbergen. Toevallig begrijpen verschillende mensen het woord ' inkapseling' om verschillende dingen te betekenen. We zullen beide termen ontcijferen, zodat u het volledig begrijpt. In de programmering, de oorspronkelijke betekenis vaninkapseling was het combineren van gegevens en methoden om met die gegevens te werken in één pakket ("capsule"). In Java is het inkapselende pakket de klasse . De klasse bevat zowel gegevens (velden) als methoden om met die gegevens te werken. Dit lijkt misschien voor de hand liggend, maar in andere programmeerparadigma's is alles anders geregeld. Bij functioneel programmeren worden gegevens bijvoorbeeld strikt gescheiden van gegevensbewerkingen. Bij objectgeoriënteerd programmeren (OOP) bestaan ​​programma's uit capsules (klassen) die bestaan ​​uit zowel gegevens als functies voor het werken met gegevens.

Laten we het nu hebben over het verbergen van informatie

Hoe gebruiken we allerlei complexe mechanismen zonder te begrijpen hoe ze zijn opgebouwd of hoe ze werken? Het is eenvoudig: hun makers zorgden voor eenvoudige en handige interfaces. Op een frisdrankautomaat is de interface de knoppen op het voorpaneel. Met één knop kun je de cupmaat kiezen. Je kiest de siroop met een tweede knop. Een derde is verantwoordelijk voor het toevoegen van ijs. En dat is alles wat u hoeft te doen. Het maakt niet uit hoe de machine er van binnen uitziet. Het belangrijkste is dat het zo is ontworpen dat de gebruiker frisdrank krijgt door op drie knoppen te drukken. Hetzelfde geldt voor een auto. Het maakt niet uit wat er binnen gebeurt. Het belangrijkste is dat wanneer je het rechterpedaal indrukt, de auto vooruit gaat en wanneer je het linkerpedaal indrukt, de auto vertraagt. Dit is de essentie van het verbergen van informatie. Een heel programma' s 'ingewanden' zijn verborgen voor de gebruiker. Dergelijke informatie is overbodig of onnodig voor de gebruiker. De gebruiker heeft een eindresultaat nodig, geen intern proces. Laten we bijvoorbeeld eens kijken naar deVoertuigklasse :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

Zo zit de implementatie verstopt in een Java-programma. Net als in het echte leven: de gebruiker krijgt een interface (methoden). Als je in een programma een auto nodig hebt om een ​​actie uit te voeren, roep je gewoon de gewenste methode aan. Wat er binnen deze methoden gebeurt, is overbodig. Waar het om gaat is dat alles werkt zoals het hoort. Hier hebben we het gehad over het verbergen van de implementatie. Java heeft ook gegevens verbergen. We schreven erover in de les over getters en setters, maar een herinnering kan geen kwaad. We hebben bijvoorbeeld een Cat- klasse:

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Misschien weet je nog van een vorige les wat het probleem is met deze klas? Zo niet, laten we het ons herinneren. Het probleem is dat de gegevens (velden) voor iedereen toegankelijk zijn. Een andere programmeur zou gemakkelijk een naamloze kat kunnen maken met een gewicht van 0 en een leeftijd van -1000 jaar:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

In deze situatie zou u zorgvuldig kunnen volgen of een van uw collega's objecten met een ongeldige status maakt, maar het zou veel beter zijn om zelfs de mogelijkheid van het maken van deze ongeldige objecten uit te sluiten. We realiseren gegevensverberging met behulp van:

1. toegangsmodificaties ( privé, beschermd, pakketstandaard );
2. getters en setters.

We gebruiken ze om te controleren of iemand de kat een negatieve leeftijd probeert te geven. Zoals we eerder zeiden, verwijzen de auteurs van verschillende artikelen over inkapseling eigenlijk naar inkapseling (het combineren van gegevens en methoden) of het verbergen van informatie, of beide. Java heeft beide mechanismen (dit is niet noodzakelijkerwijs het geval in andere OOP-talen), dus de laatste optie is het meest correct.

Inkapseling geeft ons een aantal belangrijke voordelen:

1. Bewaking van de juiste objectstatus. We hebben hierboven voorbeelden gegeven: dankzij de setter en private modifier hebben we ons programma beveiligd tegen katten met een gewicht van 0.


2. Gebruiksvriendelijke interface. We laten alleen methoden bloot aan de gebruiker. De gebruiker hoeft ze alleen maar te bellen om een ​​resultaat te krijgen. En het is helemaal niet nodig om je te verdiepen in de details van hoe ze werken.


3. Codewijzigingen hebben geen invloed op gebruikers. We brengen alle wijzigingen aan binnen methoden. Dit heeft geen invloed op gebruikers: ze schreven vehicle.gas() om het gas toe te passen, en dat is wat ze zullen blijven doen. Het feit dat we iets in de methode gas() hebben veranderd , blijft onzichtbaar: net als voorheen krijgen ze gewoon het vereiste resultaat.