Inkapseling versus gegevens verbergen – Java

Interviewer:wat is inkapseling en hoe bereik je het in Java?

Ik:Encapsulation is een mechanisme om informatie voor de client te verbergen. De informatie kan data of implementatie of algoritme zijn. We
bereik dit met behulp van toegangsmodifiers.

Interviewer:dit is het verbergen van gegevens. Hoe bereiken we inkapseling in Java?

Ik: uummmm

Concrete vraag:Wat is de manier om inkapseling in Java te implementeren, behalve ‘Access Modifiers’?

Antwoord 1, autoriteit 100%

Meer in het algemeen verwijst inkapselingeenvoudigweg naar het bundelen van de gegevens (bijvoorbeeld van een object) met de bewerkingen op die gegevens. Je hebt dus een klasse die gegevens inkapselt – velden– samen met de methodenvoor het manipuleren van die gegevens.

Maar inkapseling wordt soms ook op dezelfde manier gebruikt als uw antwoord, en inderdaad, een van de punten van het bundelen van gegevens en methoden is om de implementatie te verbergen.

Ik veronderstel dat een beter antwoord dan gewoon methoden gebruiken en alle velden privé makenis: gebruik interfaces. Op deze manier zijn bewerkingen op een object puur gebaseerd op het interfacecontract en zijn ze op geen enkele manier gebonden aan de velden of helpermethoden die worden gebruikt om dat contract intern te implementeren.

Antwoord 2, autoriteit 55%

Inkapseling

In het algemeen betekent Encapsulationhet bundelen van vergelijkbare items, zo simpel is het.

Neem bijvoorbeeld een Student-les waar we de cursisten instantievariabelen en gedrag/methoden laten werken op die instantievariabelen @ één plaats.

Waarom is het belangrijk? We willen niet dat onze code overal in onze codebasis wordt verspreid.

Als laten we zeggen dat we wijzigingen moeten aanbrengen, dan moeten we de varianten (van die wijzigingen) op alle plaatsen vinden. Door vergelijkbare items te bundelen, vermijden we dergelijke scenario’s en het helpt ook om onze gebundelde code gerichter te maken.

Gegevens verbergen

Het biedt gewoon een manier om uw gegevens te beschermen tegen de buitenwereld. Wat het betekent is, laten we zeggen dat als ik mijn instantievariabele openbaar heb gemaakt, iedereen de status ervan kan wijzigen. Maar als we onze instantievariabele privé/beschermd maken, beperken we in feite externe entiteiten om er wijzigingen in aan te brengen.

Vergelijking/discussie

Nu rijst de vraag, in welk opzicht maken we onze variabelen beschermd?

Nogmaals, we moeten begrijpen dat Encapsulationslechts de container is die we nodig hebben om onze vergelijkbare items te plaatsen.

Het fungeert gewoon als een Black boxvoor de buitenwereld. Buitenwereld (ik bedoel te zeggen klanten/consumenten: die onze Student-klas gebruiken) kennen de interne details/implementatiedetails van de Student-klas niet en eigenlijk zou het ze niets kunnen schelen over de interne details/uitvoeringsdetails van de klas. Ze willen alleen wat methoden/API’s zodat ze deze in hun clienttoepassing kunnen gebruiken.

Mijn punt is dus dat alle leerlinggerelateerde gedragingen/variabelen in een zwarte doosworden geplaatst die we dit als klas noemen. Het is nu aan de ontwerper van de klas wat de elementen van de klas zijn die verborgen moeten worden en wat niet voor de buitenwereld.

Nu terugkomend op de vraag In Java: we maken onze variabelen privé, wat betekent dat ze klassebeveiligd zijn. Als we willen dat onze instantievariabelen in het hele pakket toegankelijk zijn, dan zijn ze pakketbeveiligd. Door ons project zijn ze openbaar. Dus wat ik bedoel te zeggen is om gegevens te verbergen, je hebt een soort container nodig waarin je je gegevens plaatst en verbergt met betrekking tot de container.

Dus wat ik denk dat Gegevens verbergenniet mogelijk is zonder Inkapseling. U kunt uw gegevens niet verbergen zonder ze in een of andere vorm van container te plaatsen. Nogmaals, ik herinner je eraan dat ik dit in de Object Oriented Language-context plaats.

Maar ja Inkapselingis mogelijk zonder uw gegevens te verbergen. Zet alle dingen openbaar en je kunt het effect zien.

Antwoord 3, autoriteit 23%

Inkapseling: neem het voorbeeld van een capsule. Als je hem opent, zitten er heel veel ingrediënten in. Encapsulation van objectgeoriënteerd programmeren is ook zo. Zoals de naam al doet vermoeden, betekent “Encapsulationhet inkapselen (een capsule maken van) alle dataleden, attributen en bijbehorende methoden in één enkele capsule.

Hoe doe je het:Laten we zeggen dat je een klasse hebt gemaakt met de naam “Auto”. Nu heeft auto een kleur prijs en model. Dit zijn attributen en het heeft een run-methode. Dus hier heb je al deze attributen en methoden van een voertuig met de naam “Auto” ingekapseld. Wanneer u zo’n instantie van auto maakt

Car myCar = new Car();

Je hebt toegang tot alle attributen van Car met behulp van de myCar-variabele.

“Gegevens verbergen“: het verbergen van gegevens wordt beheerd in Java met behulp van toegangsmodifiers. Om toegang te krijgen tot de gegevensleden gebruikt u ACCESSORSen voor het wijzigen van de gegevens gebruikt u “Mutators“. Java levert zelf geen accessors en mutators, die creëer je zelf (getters en setters). Terwijl C# EIGENSCHAPPEN biedt om dit te doen.

Antwoord 4, autoriteit 16%

Ik haat het om dit te doen, maar van Wikipedia:

In programmeertalen wordt inkapseling gebruikt om naar een van de twee te verwijzen
verwante maar verschillende begrippen, en soms aan de combinatie
daarvan:

1. Een taalmechanisme om de toegang tot sommige componenten van het object te beperken.
2. Een taalconstructie die het bundelen van gegevens met de methoden (of andere functies) die op die gegevens werken, vergemakkelijkt

Uw uitleg was meer in de trant van het eerste begrip, de interviewer zocht iets op het tweede.

Antwoord 5, autoriteit 7%

Data-inkapselingverwijst naar het mechanisme alle gerelateerde eigenschappen en methoden in één enkele entiteit te houden.

Voorbeeld: een auto. Het houdt stuurwielen, banden, motor en alle aanverwante zaken in één collectieve entiteit die bekend staat als Car.

In programmeertalen wordt de inkapselingbereikt met klassen. Een klasse bevat alle eigenschappen en gerelateerde methoden in one single entitydie is ontworpen om een ​​specifieke taak uit te voeren.

Gegevens verbergenverwijst naar het verbergen van de onbelangrijke details voor de gebruikeren hem alleen de relevante gegevens tonen.

Voorbeeld: wanneer we in een auto op het rem- of gaspedaal trappen, weten we niet wat er achter de schermen gebeurt (hoehet zijn snelheid verhoogt of hoe zijn remmen in banden). Alles wat we weten is dat we rem en gaspedaal hebben om het gewenste resultaat te bereiken.

Bij het programmeren gebeurt dit met behulp van access modifiers. Privéleden zijn niet toegankelijkvan buiten de klas en alleen publicleden zijn toegankelijk voor gebruikers. De privéleden zijn alleen toegankelijk voor leden van de klasen bieden zo de beveiligingvoor privéleden die direct van buiten de klas kunnen worden geëvalueerd.

Antwoord 6, autoriteit 7%

Gegevens verbergen betekent dat we gegevens binnen de klas beveiligen.

Abstractie betekent het verbergen van de code door lidfuncties te definiëren.

Inkapseling is de combinatie van abstractie en het verbergen van gegevens, wat betekent dat we dat zijn
het inpakken van gegevens en code die aan die gegevens zijn gekoppeld. Voor ex-bonenklasse

   class student {
private int age;  // Data Hiding 
public setAge(){} // Abstraction 
public getAge(){} // Abstraction 
}

leerlingenklas is ingekapseld.

inkapseling = gegevens verbergen + abstractie

Antwoord 7, autoriteit 5%

De vraag lijkt misleidend, ik betwijfel of iemand anders dan de interviewer hem kan beantwoorden en de kans is groot dat zijn/haar antwoord fout is. Het belangrijkste is dat het niet duidelijk is wat de vraag moet evalueren of ontdekken.

Toch heb ik er even over nagedacht en het volgende is wat ik denk dat mijn poging zou kunnen zijn om de vraag te beantwoorden.

Met toegangsmodificaties

In Java wordt inkapseling geïmplementeerd door details te verbergen met behulp van de toegankelijkheidsmodifiers (d.w.z. openbaar, beschermd, privé, enz.). Met deze niveaus van toegankelijkheid bepaalt u het niveau van informatie die wordt verborgen. Hoe minder beperkend het niveau, hoe duurder de verandering is wanneer deze plaatsvindt en hoe meer de klasse is gekoppeld aan andere afhankelijke klassen (d.w.z. gebruikersklassen, subklassen).

Het is duidelijk dat inkapseling meer is dan alleen een status verbergen. In Java kun je hele klassen en interfaces en hun status en gedrag verbergen, waardoor de implementatiedetails van een hele API worden verborgen.

Bijvoorbeeld, de methode Arrays.asList()retourneert een Listimplementatie, maar het maakt ons niet uit welke implementatie, zolang deze maar voldoet aan de Listopenbare interface, toch?. De implementatie kan in de toekomst worden gewijzigd zonder dat dit gevolgen heeft voor ons, de gebruikers van de methode, maar de daadwerkelijke implementatie blijft voor ons verborgen.

Tot nu toe lijkt het alsof inkapseling volledig afhangt van het vermogen van een programmeertaal om details te verbergen, en dat het daarom niet mogelijk zou zijn zonder toegangsmodifiers, toch?

Zonder toegangsmodificaties

Hoe bereikt een taal als Python echter inkapseling als het geen toegangsmodifiers heeft? Alles is openbaar in Python? Betekent dit dat inkapseling niet mogelijk is?

Wat als we volgens afspraak de openbare interface van onze componenten definiëren en vervolgens alleen toegang krijgen tot de status en het gedrag van de objecten via hun openbare interface? Hiervoor hebben we natuurlijk een duidelijk begrip nodig van de abstracties in ons probleemdomein en hoe deze door onze gebruikers zouden moeten worden geconsumeerd.

Voor mij lijkt het alsof de interviewvraag bedoeld was om inkapseling te evalueren als een breder concept, een concept dat afhankelijk is van de definitie van zeer duidelijke abstracties, en niet alleen als een bijproduct van een taalfunctie zoals toegangsmodifiers.

De rol van abstractie

Daarom moet, naar mijn mening, men, om inkapseling echt te begrijpen, eerst abstractie moeten begrijpen.

Denk bijvoorbeeld aan het abstractieniveau in het concept van een auto. Een auto is complex in zijn interne uitvoering. Ze hebben verschillende subsystemen, zoals een transmissiesysteem, een remsysteem, een brandstofsysteem, enz.

We hebben de abstractie ervan echter vereenvoudigd en we communiceren met alle auto’s ter wereld via de openbare interface van hun abstractie. We weten dat alle auto’s een stuur hebben waarmee we de richting bepalen, ze hebben een pedaal dat als je erop drukt, je de auto versnelt en de snelheid regelt, en een ander dat als je erop drukt, je het laat stoppen, en je hebt een versnellingspook waarmee u kunt bepalen of u vooruit of achteruit gaat. Deze functies vormen de publieke interfacevan de auto-abstractie. ‘S Morgens kun je een sedan besturen en dan uitstappen en’ s middags een SUV rijden alsof het hetzelfde is.

Het is niet zo dat je de motorkap niet kunt openen en zien hoe het allemaal werkt. Maar weinigen van ons kennen de details van hoe al deze onderliggende functies onder de motorkap zijn geïmplementeerd, en de waarheid is dat we de details niet hoeven te weten om een ​​auto te besturen. Al deze dingen zijn ingekapseld onder de auto-abstractie. We hoeven alleen de openbare interface van de abstractie te kennen.

Denk aan de tijd dat auto’s geen hydraulisch richtingssysteem hadden. Op een dag vonden de autofabrikanten het uit en ze besluiten het vanaf dat moment in auto’s te plaatsen. Toch veranderde dit niets aan de manier waarop gebruikers met hen omgingen. Gebruikers ervaren hoogstens een verbetering in het gebruik van het bewegwijzeringssysteem. Een verandering als deze was mogelijk doordat de interne uitvoeringvan een auto ingekapseld was.

Dit toont duidelijk aan dat door de details te verbergenvan hoe de richtingssystemen werden geïmplementeerd, ze deze veilig konden veranderenzonder de openbare interface van de auto te beïnvloeden en, dienovereenkomstig, zonder de manier waarop gebruikers ermee omgaan te beïnvloeden.

Stel je nu voor dat autofabrikanten besloten de tankdop onder de auto te plaatsen, en niet in een van de zijkanten. Je gaat een van deze nieuwe auto’s kopen en als je benzine op is, ga je naar het tankstation en vind je de tankdop niet. Plots besef je dat je onder de auto zit, maar je kunt er niet bij met de benzinepompslang. Nu hebben we het openbare interface-contract verbroken, en daarom breekt de hele wereld, het valt uit elkaar omdat de dingen niet werken zoals verwacht. Een verandering als deze zou miljoenen kosten. We zouden alle benzinepompen ter wereld moeten vervangen. Als we de inkapseling verbreken, moeten we een prijs betalen.

Dus, zoals je kunt zien, is het doel van inkapseling om de onderlinge afhankelijkheid te minimaliseren en verandering te vergemakkelijken. U maximaliseert de inkapseling door de blootstelling van implementatiedetails te minimaliseren. De status van een klasse zou alleen toegankelijk moeten zijn via de openbare interface.

Het mooie van inkapseling is de kracht om dingen te veranderen zonder de gebruikers te beïnvloeden.

We zouden kunnen zeggen dat dit uiteindelijke doel afhangt van een zorgvuldige planning en ontwerp. In Java zijn toegangsmodifiers een manier om deze ideeën tot leven te brengen, maar in taal waarin deze functie niet bestaat, is het evengoed mogelijk om inkapseling te bereiken.

Antwoord 8, autoriteit 5%

Zoals ik het zie, verwijst Encapsulationnaar het idee van het binden van gegevensen methodenaar een enkeleeenheid genaamd klasse. Er zijn echter twee hoofdcriteriaom gegevens en methoden te binden. Een daarvan is het verbergen van informatie, maar niet de enige. Om perfect beknoptte zijn, zou ik zeggen dat de twee belangrijkste criteria zijn

1. Lage koppeling (verzekeren door informatie te verbergen)
2. Hoge cohesie

Antwoord 9, autoriteit 2%

In de klas worden attributen en gedragingen bij elkaar geplaatst. Een inkapseling betekent dat wanneer u een klasse maakt, dit zelf betekent dat u het inkapselingsprincipe realiseert. Omdat gegevens en gedrag zijn ingekapseld in de klas. Dus het verbergen van gegevens is een belangrijk onderdeel van de term – inkapseling. En dit betekent toegangspunten van het object.

Antwoord 10, autoriteit 2%

Ik zag dat er al veel discussie is gevoerd, om het voor mij te vereenvoudigen:

Inkapseling
Zorgt ervoor dat het gedrag van een object alleen kan worden beïnvloed via de API.
Hiermee kunnen we bepalen hoeveel een wijziging aan een object van invloed is op andere delen van
het systeem door ervoor te zorgen dat er geen onverwachte afhankelijkheden zijn tussen:
niet-gerelateerde componenten. Toegangsmodifier kan worden gebruikt om inkapseling te bereiken.

Informatie verbergen
Verbergt hoe een object zijn functionaliteit achter de abstractie implementeert
van zijn API. Het laat ons werken met hogere abstracties door details op een lager niveau te negeren
die niets met de taak te maken hebben. Abstractie op ontwerpniveau kan worden gebruikt om gegevens te verbergen.

Antwoord 11, autoriteit 2%

De eenvoudigste definitie van inkapseling is “Het binden van gegevens en code die gegevens in een enkele eenheid verwerkt”, zodat de gegevens niet rechtstreeks toegankelijk zijn voor de buitenwereld.

In structuurtaal zoals c worden gegevens aan het begin van het blok gedeclareerd en direct gebruikt, openlijk toegankelijk (elke tom, lul en harry hebben toegang tot gegevens).
Het verbergen van gegevens is een concept om de toegang tot gegevens rechtstreeks en openlijk te beperken tot elke Tom Dick en Harry.
Inkapseling is een van de manieren om gegevens te verbergen.
U bereikt het verbergen van gegevens door gegevens en functie samen te voegen (Encapsulation).

Hoe u dit bereikt in JAVA, zie een willekeurig getter(), setter()-functievoorbeeld in JAVA.
Controleer dit

Hoe werken getters en setters?

Antwoord 12, autoriteit 2%

Inkapseling: inkapseling is een van de pijler van OOP’s, ook is superset voor de andere twee termen, gegevensverbreiding en abstractie. (Gegevensverdoven, zoals de term verwijst. Gegevens kunnen alleen in variabelen worden opgeslagen. Om de gegevens van de externe wereld te verbergen, gebruiken we gegevensverdedigingsconcept. Publiek, privé, beschermd dit zijn drie toegangsmodificatoren die aan ons worden verstrekt. Standaard is Beperkt tot pakket. Beschermde beperkte tot geërfde klasse.)
** Persoonlijke variabelen zijn alleen in de klasse toegankelijk, wat betekent dat er een innerlijke klasse is, er kunnen ook privévariabelen rechtstreeks worden gebeld. Alleen statische innerlijke klassen kunnen statische variabelen bellen.

Nu komen naar abstractie (wat immaterieel betekent). Abstractie wordt ook beschouwd als het proces om de implementatie van de gebruiker te verbergen en een eindresultaat te bieden. Voorbeeld: we hebben een persoonsklasse met “gewicht” -bezit. Deze eigenschap is heel lastig omdat we niet minder dan 0 gewicht voor een persoon kunnen accepteren. Ook kunnen we niet meer dan 500 kg accepteren. Dus verstoppen de implementatie hiervoor in de Setter-methode. Dit ding verbergen de implementatiedetails is abstractie.

** en het complete pakket d.w.z. het maken van het privé- en implementatie van logica in setter en getter wordt inkapseling genoemd.

Antwoord 13, Autoriteit 2%

1. Inkapseling is de bundeling van de gegevens (velden) en gedrag (methoden) samen in klassen.
2. Nu moet u toegangscontrole geven op de gegevens met behulp van toegangsmodificatoren (privé / beschermd / publiek of standaard), die gegevens verstopt zijn.
   Het beschermt gegevens van de buitenwereld waar u de toegang niet wilt verstrekken.
3. Ook, om de complexiteit van de bewerkingen te verbergen, moet u interfaces gebruiken om abstractie te bereiken.

Antwoord 14, Autoriteit 2%

Inkapseling betekent bindende gegevenselementen en -methode (gedrag) in een enkele eenheid en het verstrekken van zoveel mogelijk informatie die u zo veel gebruikt, kunt u zeggen [Inkapseling = gegevensverbiders + abstractie].

Klasse is volledig ingekapseld element in Java

Gegevens verbergen : Gegevensvariabelen als privécijfer om het te beveiligen van ongeoorloofde toegang, maar als u een openbare setter- en Getter-methode voor validatie geeft.

Antwoord 15, Autoriteit 2%

Het proces van het definiëren van een klas door haar gegevens te verbergen van directe toegang van het externe klasserelement en de toegang alleen te bieden door middel van openbaar toegankelijke setter- en Getter-methode door de juiste validatie wordt het inkapseling genoemd.

Antwoord 16, Autoriteit 2%

uit wikipedia

Inkapselingsinkapseling is een objectgeoriënteerd programmeerconcept
dat bindt de gegevens en functies die de gegevens manipuleren,
En dat houdt zowel veilig voor externe interferentie en misbruik. Gegevens
Inkapseling leidde tot het belangrijke OOP-concept van gegevens verstopt.

Als een klasse niet toestaat dat roepcode toegang heeft tot interne objectgegevens
en staat alleen toegang via methoden toe, dit is een sterke vorm van
abstractie of informatie die verbergen als inkapseling. Sommige
Talen (bijvoorbeeld Java) Laat klassen toegangsbeperkingen afdwingen
expliciet, bijvoorbeeld het aanduiden van interne gegevens met privé
trefwoord en aanwijzende methoden bedoeld voor gebruik per code buiten de
Klasse met het openbare sleutelwoord. Methoden kunnen ook openbaar worden gemaakt,
privé- of tussenliggende niveaus zoals beschermd (wat toegang biedt
van dezelfde klasse en zijn subklassen, maar geen objecten van een ander
klas). In andere talen (zoals Python) wordt dit alleen afgedwongen door
Conventie (bijvoorbeeld privémethoden kunnen namen hebben die beginnen
met een onderstrepingsteken). Inkapseling voorkomt dat de externe code is
bezig met de interne werking van een object. Dit vergemakkelijkt
Code Refactoring, bijvoorbeeld het toestaan ​​van de auteur van de klas aan
Wijzig hoe objecten van die klasse intern hun gegevens vertegenwoordigen
Zonder elke externe code (zolang “openbare” methode-oproepen te wijzigen
werk op dezelfde manier). Het moedigt ook programmeurs aan om alle code te plaatsen
die betrekking heeft op een bepaalde set gegevens in dezelfde klasse, die
organiseert het voor gemakkelijk begrip door andere programmeurs.
Inkapseling is een techniek die ontkoppeling bevordert.

Antwoord 17, autoriteit 2%

In principe is het inkapselen van gegevens een proces, terwijl het verbergen van gegevens een techniek is.
In inkapseling kunnen gegevens openbaar of privé zijn, maar in gegevens is het verbergen van gegevens alleen privé. Dus het verbergen van gegevens maakt gebruik van Encapsulation, maar het gebruikt ook verschillende technieken om ervoor te zorgen dat gegevens alleen worden toegestaan ​​voor geautoriseerde toegang.
Ik hoop dat het helpt!

Antwoord 18, autoriteit 2%

Abstractie zegt dat wat nodig is om met het object te communiceren.

Inkapseling betekent het inkapselen van objecteigenschappen, status en gedrag in een enkele logische eenheid die klasse wordt genoemd.

Het verbergen van gegevens zegt dat het verbergen van de innerlijke implementatie van objecten privémethoden en eigenschappen betekent, het object dat wordt gebruikt om hun status te behouden.

Antwoord 19

Het proces van het binden van gegevensleden en bijbehorende methoden in een enkele eenheid is niets anders dan inkapseling.

Inkapseling = gegevens verbergen + abstractie