Hoi! Laten we de les van vandaag wijden aan inkapseling en meteen beginnen met voorbeelden :) Principes van inkapseling - 1Hier heb je een gewone frisdrankautomaat . Ik heb een vraag voor jullie: hoe werkt het? Probeer een gedetailleerd antwoord te geven: waar komt het kopje vandaan, hoe wordt de interne temperatuur gehandhaafd, waar wordt het ijs opgeslagen, hoe weet de machine welke siroop moet worden toegevoegd, enz.? Op deze vragen heb je waarschijnlijk geen antwoord. Eerlijk genoeg, aangezien niet iedereen dergelijke machines gebruikt. Tegenwoordig zijn ze niet zo populair. Laten we proberen een ander voorbeeld te geven. Iets dat je zeker elke dag vele malen gebruikt. Oh, hier is een idee! Principes van inkapseling - 2Vertel ons hoe de Google-zoekmachinewerken. Hoe zoekt het precies naar informatie met betrekking tot de woorden die u invoert? Waarom zijn bepaalde resultaten hoog gerangschikt en andere niet? Ook al gebruikt u Google elke dag, de kans is groot dat u het niet weet. Maar het maakt niet uit. U hoeft dit niet te weten. U kunt zoekopdrachten in een zoekmachine invoeren zonder na te denken over hoe het werkt. Je kunt frisdrank uit een automaat kopen zonder te weten hoe het werkt. Je kunt autorijden zonder te begrijpen hoe een verbrandingsmotor werkt, en zonder enige kennis van natuurkunde, zelfs op het niveau van de basisschool. Dit alles is mogelijk dankzij een van de belangrijkste principes van objectgeoriënteerd programmeren: inkapseling. Bij het lezen van verschillende artikelen over objectgeoriënteerd programmeren (OOP), moet u zijn tegengekomen dat programmeren twee algemene concepten inhoudt: inkapseling en verbergen . En auteurs gebruiken het woord "inkapseling" om het ene en dan het andere te betekenen. We zullen beide termen onderzoeken, zodat u een volledig begrip krijgt. Bij het programmeren is de oorspronkelijke betekenis van inkapseling het bundelen van gegevens, samen met de methoden die op die gegevens werken, in een enkele eenheid (dwz een "capsule"). In Java is de klasse de eenheid van inkapseling. Een klasse bevat zowel gegevens (velden) als methoden om met deze gegevens te werken.Principes van inkapseling - 3Dit lijkt misschien de overduidelijk juiste benadering voor jou, maar in andere programmeerparadigma's is alles anders geregeld. Bij functioneel programmeren worden gegevens bijvoorbeeld strikt gescheiden van bewerkingen erop. In OOP bestaan ​​programma's uit capsules of klassen, die bestaan ​​uit zowel gegevens als functies om met die gegevens te werken. Laten we het nu hebben over verbergen . Hoe komt het dat we allerlei complexe apparaten gebruiken zonder te begrijpen hoe ze zijn georganiseerd of hoe ze werken? Het is eenvoudig: hun makers hebben ons een eenvoudige en handige interface gegeven. Op een frisdrankautomaat is de interface de knoppen op het paneel. Met één druk op de knop kies je de cupmaat. Door op een andere te drukken, kies je de smaak. Een derde is verantwoordelijk voor het toevoegen van ijs. En dat is alles wat u hoeft te doen. De interne organisatie van de machine doet er niet toe. Waar het om gaat is dat het zo is ontworpen dat de gebruiker drie knoppen moet indrukken om frisdrank te krijgen . Hetzelfde geldt voor auto's. Het maakt niet uit wat er binnen gebeurt. Waar het om gaat is dat wanneer je het rechterpedaal indrukt, de auto vooruit gaat, en wanneer je het linkerpedaal indrukt, hij vertraagt. Dat is wat verbergen inhoudt. Alle "insides" van een programma zijn verborgen voor de gebruiker. Voor de gebruiker is dit overbodige, onnodige informatie. De gebruiker heeft het eindresultaat nodig, niet het interne proces. Laten we Autoals voorbeeld naar de klas kijken:
Java webinar 
public class Auto {

   public void go() {

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

   public void brake() {

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

   public static void main(String[] args) {

       Auto auto = new Auto();

       // From the user's perspective,

       // one pedal is pressed and the car accelerates.
       auto.gas();

       // The other is pressed, and the car slows down.
       auto.brake();
   }
}
Zo ziet het verbergen van de implementatie eruit in een Java-programma. Het is net als in het echte leven: de gebruiker krijgt een interface (methodes) ter beschikking. Als de gebruiker een auto in een programma nodig heeft om een ​​actie uit te voeren, roept hij of zij 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 over implementatie verbergen . Daarnaast heeft Java ook gegevens verbergen . We schreven daarover in de les over getters en setters , maar het concept herzien kan geen kwaad. We hebben bijvoorbeeld een Catklas: 
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 herinner je je het probleem met deze klas nog van de vorige les? Zo niet, laten we het dan nu onthouden. Het probleem is dat de gegevens (velden) voor iedereen toegankelijk zijn - een andere programmeur kan gemakkelijk een naamloze kat 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;

}
Misschien kunt u goed in de gaten houden of een van uw collega's objecten met een ongeldige status heeft gemaakt, maar het zou veel beter zijn om zelfs de mogelijkheid van het maken van dergelijke "ongeldige objecten" uit te sluiten. Principes van inkapseling - 4De volgende mechanismen helpen ons om gegevens te verbergen:
  1. toegangsmodificaties ( privé , beschermd , pakketstandaard )
  2. getters en setters
We kunnen daar bijvoorbeeld een vinkje plaatsen om te zien of iemand probeert een negatief getal toe te kennen aan de leeftijd van de kat. Zoals we eerder zeiden, bedoelen de auteurs van verschillende artikelen over inkapseling soms het combineren van gegevens en methoden, of ze verbergen, of beide (combineren en verbergen). Java heeft beide mechanismen (dit geldt niet noodzakelijkerwijs voor andere OOP-talen), dus de laatste betekenis is het meest correct. Inkapseling geeft ons een aantal belangrijke voordelen:
  1. Controle over de juiste staat van een object. Daar stonden hierboven voorbeelden van. Een setter en de private modifier zorgen ervoor dat ons programma geen katten heeft met een gewicht van 0.

  2. Gebruiksvriendelijkheid door een interface. Alleen methoden worden aan de buitenwereld "blootgesteld". Methoden aanroepen is voldoende om resultaat te krijgen — het is absoluut niet nodig om in de details te duiken van hoe ze werken.

  3. Codewijzigingen hebben geen invloed op gebruikers. We brengen alle wijzigingen aan in de methoden. Dit heeft geen invloed op de gebruiker van de methode: als de juiste code voorheen "auto.gas()" was om het gaspedaal toe te passen, dan blijft dat zo. Het feit dat we iets hebben veranderd in de methode gas() blijft onzichtbaar voor de gebruiker: net als voorheen krijgt de beller gewoon het gewenste resultaat.