OOP's concepten in Java

Object-georiënteerd programmeringssysteem (OOP's) is een programmeerparadigma gebaseerd op het concept van "objecten" die gegevens en methoden bevatten. Het primaire doel van objectgeoriënteerd programmeren is het vergroten van de flexibiliteit en onderhoudbaarheid van programma's. Object-georiënteerd programmeren brengt gegevens en het gedrag (methoden) op één locatie (object) samen, waardoor het gemakkelijker te begrijpen is hoe een programma werkt. We zullen elke functie van OOP's in detail behandelen, zodat u geen moeilijk begrip krijgt van OOPs-concepten .

OOPs-concepten - inhoudsopgave

1. Wat is een object
2. Wat is een les
3. Constructor in Java
4. Objectgeoriënteerde programmeerfuncties
   • Abstractie
   • inkapseling
   • Erfenis
   • polymorfisme
5. Abstracte klasse en methoden
6. Interfaces in Java

Wat is een object

Object: is een gegevensbundel en het gedrag ervan (vaak methoden genoemd).

Objecten hebben twee kenmerken: ze hebben toestanden en gedragingen .

Voorbeelden van toestanden en gedragingen
Voorbeeld 1:
Object : huis
Staat : adres, kleur, gebied
Gedrag : deur openen, deur sluiten

Dus als ik een klas moest schrijven op basis van toestanden en gedrag van House. Ik kan het zo doen: staten kunnen worden weergegeven als instantievariabelen en gedragingen als methoden van de klas. In het volgende gedeelte van deze handleiding zullen we zien hoe klassen worden gemaakt.

  klas huis {String adres;String kleur;dubbel zijn;void openDoor () {   // Schrijf hier code}void closeDoor () {   // Schrijf hier code}  ...  ... } 

Voorbeeld 2:
Laten we nog een voorbeeld nemen.
Voorwerp : auto
Staat : Kleur, Merk, Gewicht, Model
Gedrag : breken, versnellen, vertragen, schakelen.

Opmerking: Zoals we hierboven hebben gezien, kunnen de statussen en het gedrag van een object worden vertegenwoordigd door respectievelijk variabelen en methoden in de klasse.

Kenmerken van objecten:

Als u het moeilijk vindt om abstractie en inkapseling te begrijpen, maakt u zich dan geen zorgen, want ik heb deze onderwerpen in detail behandeld met voorbeelden in het volgende gedeelte van deze handleiding.

1. Abstractie
2. inkapseling
3. Bericht overslaan

Abstractie : abstractie is een proces waarbij u alleen "relevante" gegevens toont en onnodige details van een object voor de gebruiker "verbergt".

Inkapseling : inkapseling betekent eenvoudigweg een bindende objectstatus (velden) en gedrag (methoden) samen. Als je klasse maakt, doe je inkapseling.

Bericht overslaan
Een enkel object op zichzelf is misschien niet erg handig. Een applicatie bevat veel objecten. Het ene object interageert met een ander object door methoden voor dat object aan te roepen. Dit wordt ook wel Method Invocation genoemd . Zie het onderstaande diagram.

Wat is een klasse in OOPs-concepten

Een klasse kan worden beschouwd als een blauwdruk waarmee u zoveel objecten kunt maken als u wilt. Hier hebben we bijvoorbeeld een klasse- Website met twee gegevensleden (ook bekend als velden, instantievariabelen en objectstatussen). Dit is slechts een blauwdruk, het vertegenwoordigt geen enkele website, maar hiermee kunnen we website-objecten (of instanties) maken die de websites vertegenwoordigen. We hebben twee objecten gemaakt, terwijl we objecten hebben gemaakt met afzonderlijke eigenschappen voor de objecten met behulp van de constructor.

  openbare klasse Website {// velden (of instantievariabele)String webName;int webAge;// constructeurWebsite (tekenreeksnaam, leeftijd) {   this.webName = naam;   this.webAge = leeftijd;}public static void main (String args []) {   // Objecten maken   Website obj1 = nieuwe website ("beginnersboek", 5);   Website obj2 = nieuwe website ("google", 18);  // Toegang tot objectgegevens via referentie  System.out.println (obj1.webName + "" + obj1.webAge);  System.out.println (obj2.webName + "" + obj2.webAge);} } 

Output:

  beginnersboek 5 google 18 

Wat is een constructor

Constructor ziet eruit als een methode, maar het is in feite geen methode. De naam is hetzelfde als de klassennaam en geeft geen waarde terug. Je moet deze verklaring hebben gezien in bijna alle programma's die ik hierboven heb gedeeld:

  MyClass obj = new MyClass (); 

Als u naar de rechterkant van deze verklaring kijkt, roepen we de standaardconstructor van klasse myClass aan om een ​​nieuw object (of exemplaar) te maken.

We kunnen ook parameters in de constructor hebben, dergelijke constructors staan ​​bekend als geparametriseerde constructors .

Voorbeeld van constructeur

  public class ConstructorExample {int leeftijd;String naam;// StandaardconstructorConstructorExample () { this.name = "Chaitanya"; this.age = 30;}// Geparametriseerde constructorConstructorExample (String n, int a) { this.name = n; this.age = a;}public static void main (String args []) { ConstructorExample obj1 = nieuw ConstructorExample (); ConstructorVoorbeeld obj2 = nieuw ConstructorExample ("Steve", 56); System.out.println (obj1.name + "" + obj1.age); System.out.println (obj2.name + "" + obj2.age);} } 

Output:

  Chaitanya 30 Steve 56 

Object Oriented Programming-functies

Deze vier functies zijn de be>

Abstractie

Abstractie is een proces waarbij u alleen 'relevante' gegevens toont en onnodige details van een object voor de gebruiker 'verbergt'. Wanneer u bijvoorbeeld online inlogt op uw bankrekening, voert u uw gebruikersnaam en wachtwoord in en drukt u op inloggen. Wat gebeurt er wanneer u op inloggen drukt, hoe de invoergegevens die naar de server worden verzonden, hoe deze worden geverifieerd, allemaal van u zijn verwijderd. Lees hier meer over: abstractie in Java .

inkapseling

Inkapseling betekent eenvoudigweg binding van objectstatus (velden) en gedrag (methoden) aan elkaar. Als je klasse maakt, doe je inkapseling.

Voorbeeld van inkapseling in Java

Hoe
1) Maak de instantievariabelen privé zodat ze niet rechtstreeks van buiten de klasse toegankelijk zijn. U kunt alleen waarden van deze variabelen instellen en ophalen via de methoden van de klasse.
2) Laat getter- en setter-methoden in de klasse instellen en de waarden van de velden ophalen.

  klasse EmployeeCount {private int numOfEmployees = 0;public void setNoOfEmployees (int count){numOfEmployees = count;}openbare dubbele getNoOfEmployees () {retour aantal werknemers;} } Public class EncapsulationExample {public static void main (String args []){   EmployeeCount obj = new EmployeeCount ();   obj.setNoOfEmployees (5613);   System.out.println ("Aantal werknemers:" + (int) obj.getNoOfEmployees ()); } }

Output:

  Aantal werknemers: 5613 

De klasse EncapsulationExample die het Object of class EmployeeCount , kan de NoOfEmployees niet rechtstreeks ophalen. Het moet de setter en getter-methoden van dezelfde klasse gebruiken om de waarde in te stellen en te krijgen.
Dus wat is het voordeel van inkapseling bij het programmeren in Java
Welnu, als u op enig moment de implementatiegegevens van de klasse EmployeeCount wilt wijzigen, kunt u dit vrij doen zonder de klassen die het gebruiken te beïnvloeden.

Erfenis

Het proces waarbij de ene klasse de eigenschappen en functionaliteiten van een andere klasse verwerft, wordt overerving genoemd . Overerving biedt het idee van herbruikbaarheid van code en elke subklasse definieert alleen die functies die uniek zijn, de rest van de functies kan worden overgenomen van de bovenliggende klasse.

1. Overerving is een proces van het definiëren van een nieuwe klasse op basis van een bestaande klasse door de gemeenschappelijke gegevensleden en methoden uit te breiden.
2. Overerving laat ons toe om code opnieuw te gebruiken, het verbetert herbruikbaarheid in uw Java-applicatie.
3. De bovenliggende klasse wordt de basisklasse of superklasse genoemd . De onderliggende klasse die de basisklasse uitbreidt, wordt de afgeleide klasse of subklasse of onderliggende klasse genoemd .

Opmerking: het grootste voordeel van Overerving is dat de code in de basisklasse niet hoeft te worden herschreven in de onderliggende klasse.
De variabelen en methoden van de basisklasse kunnen ook in de onderliggende klasse worden gebruikt.

Syntaxis: erfenis in Java

Om een ​​klasse te erven gebruiken we uitgebreid sleutelwoord. Hier is klasse A kindklasse en klasse B is ouderklasse.

  klasse A verlengt B { } 

Voorbeeld van overerving

In dit voorbeeld hebben we een MathTeacher Teacher en een MathTeacher . In de MathTeacher klasse hoeven we niet dezelfde code te schrijven die al aanwezig is in de huidige klasse. Hier hebben we de naam van de universiteit, de aanduiding en de methode does () die gemeenschappelijk is voor alle docenten, dus de klasse MathTeacher hoeft deze code niet te schrijven, de gemeenschappelijke gegevensleden en methoden kunnen worden overgenomen van de klasse Teacher .

  klassen leraar {Tekenreeksaanduiding = "Teacher";String college = "Beginnersbook";void does () { System.out.println ( "Teaching");} } openbare klasse MathTeacher breidt leraar {String mainSubject = "Maths";public static void main (String args []) {   MathTeacher obj = new MathTeacher ();   System.out.println (obj.college);   System.out.println (obj.designation);   System.out.println (obj.mainSubject);   obj.does ();} }

Output:

  Beginnersbook Leraar Wiskunde Onderwijs 

Opmerking: overerving op meerdere niveaus is toegestaan ​​in Java, maar niet overerving op meerdere niveaus

Soorten overerving :
Single Inheritance : verwijst naar een kind- en ouderklasse-relatie waarbij een klasse de andere klasse uitbreidt.

Overerving op meerdere niveaus : verwijst naar een kind- en ouderklasse-relatie waarbij een klasse de kindklasse uitbreidt. Klasse A breidt bijvoorbeeld klasse B uit en klasse B breidt klasse C uit.

Hiërarchische overerving : verwijst naar een kind- en ouderklasse-relatie waarbij meerdere klassen dezelfde klasse uitbreiden. Klasse B breidt bijvoorbeeld klasse A uit en klasse C breidt klasse A uit.

Multiple Inheritance : verwijst naar het concept van één klasse die meerdere klassen uitbreidt, wat betekent dat een kindklasse twee bovenliggende klassen heeft. Java ondersteunt geen meervoudige overerving, lees hier meer over.

De meeste nieuwe OO- talen, zoals Small Talk, Java, C # ondersteunen geen meervoudige overerving. Multiple Inheritance wordt ondersteund in C ++.

polymorfisme

Polymorfisme is een objectgeoriënteerde programmeerfunctie waarmee we een enkele actie op verschillende manieren kunnen uitvoeren. animalSound() we bijvoorbeeld zeggen dat we een klasse Animal hebben met de methode animalSound() , hier kunnen we deze methode niet implementeren omdat we niet weten welke Animal-klasse de Animal-klasse zou uitbreiden. Dus maken we deze methode als volgt abstract:

  public abstract class Animal {...openbaar abstract void animalSound (); } 

Stel nu dat we twee dierklassen Dog en Lion die de dierklasse uitbreiden. We kunnen het implementatiedetail daar verstrekken.

  public class Lion breidt dier { ... @ Override public void animalSound () { System.out.println ( "Roar"); } } 

en

  public class Dog verlengt dier { ... @ Override public void animalSound () { System.out.println ( "Inslag"); } } 

Zoals je kunt zien, hoewel we de gemeenschappelijke actie hadden voor alle subklassen animalSound() maar er waren verschillende manieren om dezelfde actie uit te voeren. Dit is een perfect voorbeeld van polymorfisme (functie waarmee we een enkele actie op verschillende manieren kunnen uitvoeren).

Soorten polymorfisme
1) Statisch polymorfisme
2) Dynamisch polymorfisme

Statisch polymorfisme:

Polymorfisme dat wordt opgelost tijdens de compilertijd staat bekend als statisch polymorfisme. Overbelasting van de methode kan worden beschouwd als een voorbeeld van statisch polymorfisme.
Overbelasting van methode : hiermee kunnen we meer dan één methode met dezelfde naam in een klasse hebben die qua handtekening verschilt.

  klasse DisplayOverloading { public void disp (char c) {  System.out.println (c); } public void disp (char c, int num)   {  System.out.println (c + "" + num); } } public class ExampleOverloading {public static void main (String args []){DisplayOverloading obj = new DisplayOverloading ();obj.disp ( 'a');obj.disp ( 'a', 10);} } 

Output:

  een een 10 

Als ik methode-handtekening zeg, heb ik het niet over het retourtype van de methode, bijvoorbeeld als twee methoden dezelfde naam hebben, dezelfde parameters en een ander retourtype hebben, dan is dit geen geldig voorbeeld van overbelasting van de methode. Dit zal een compilatiefout veroorzaken.

Dynamisch polymorfisme

Het staat ook bekend als Dynamic Method Dispatch. Dynamisch polymorfisme is een proces waarbij een oproep tot een onderdrukte methode in runtime wordt opgelost, daarom wordt het runtime-polymorfisme genoemd.

Voorbeeld

  klasse dier {public void animalSound () { System.out.println ("Standaardgeluid");} } public class Dog verlengt dier {public void animalSound () { System.out.println ( "Inslag");}public static void main (String args []) { Animal obj = new Dog (); obj.animalSound ();} } 

Output:

  Inslag 

Omdat beide klassen, animalSound dezelfde methode animalSound . Welke van de methode wordt genoemd, wordt tijdens runtime bepaald door JVM.

Nog enkele doorslaggevende voorbeelden:

  Animal obj = new Animal (); obj.animalSound (); // Dit zou de methode Animal class noemen Dog obj = new Dog (); obj.animalSound (); // Dit zou de methode Dog class noemen Animal obj = new Dog (); obj.animalSound (); // Dit zou de methode Dog class noemen

IS-A HAS-A Relaties

Een auto IS-A voertuig en HAS-A licentie dan zou de code er als volgt uitzien:

  voertuig van openbare klasse {} Public Class Car verlengt voertuig {privélicentie myCarLicense; } 

Abstracte klasse en methoden in OOPs-concepten

Abstracte methode:
1) Een methode die is gedeclareerd maar niet gedefinieerd. Alleen methode handtekening geen body.
2) Aangegeven met het abstracte trefwoord
3) Voorbeeld:

  abstract openbaar ongeldig spelInstrument (); 

5) Gebruikt om een ​​soort dwang aan de klas op te leggen die de klas erft heeft abstracte methoden. De klasse die erft moet de implementatie van alle abstracte methoden van de bovenliggende klasse bieden, anders moet de subklasse als abstract worden aangemerkt.
6) Deze kunnen niet abstract zijn

• constructors
• Statische methoden
• Particuliere methoden
• Methoden die “definitief” worden verklaard

Abstracte klasse
Een abstracte klasse schetst de methoden, maar implementeert niet noodzakelijk alle methoden.

  abstracte klasse A {abstract void myMethod ();void anotherMethod () {   // doet iets} } 

Opmerking 1: Er kunnen enkele scenario's zijn waarbij het moeilijk is om alle methoden in de basisklasse te implementeren. In dergelijke scenario's kan men de basisklasse definiëren als een abstracte klasse die aangeeft dat deze basisklasse een speciaal soort klasse is die op zichzelf niet compleet is.

Een klasse afgeleid van de abstracte basisklasse moet die methoden implementeren die niet zijn geïmplementeerd (betekent dat ze abstract zijn) in de abstracte klasse.

Opmerking 2: Abstracte klasse kan niet worden geïnstantieerd, wat betekent dat u het object van abstracte klasse niet kunt maken. Als u deze klasse wilt gebruiken, moet u een andere klasse maken die deze abstracte klasse uitbreidt en de abstracte methoden implementeert. Vervolgens kunt u het object van die onderliggende klasse gebruiken om niet-abstracte methoden van de bovenliggende klasse en geïmplementeerde methoden aan te roepen (die abstract in ouder, maar geïmplementeerd in kindklasse).

Opmerking 3: Als een kind niet alle abstracte methoden van de ouderklasse (de abstracte klasse) implementeert, moet de kindklasse abstract worden verklaard.

Voorbeeld van abstracte klasse en methoden

Hier hebben we een abstracte klasse Animal met een abstracte methode animalSound (), omdat het geluid van dieren van dier tot dier verschilt, heeft het geen zin om de implementatie van deze methode te geven, omdat elke kindklasse deze methode moet overschrijven om zijn eigen te geven implementatiegegevens. Daarom hebben we het abstract gemaakt.
Nu moet elk dier een geluid hebben, door deze methode abstract te maken, hebben we het voor de kindklasse verplicht om implementatiedetails aan deze methode te geven. Op deze manier zorgen we ervoor dat elk dier een geluid heeft.

  // abstracte klasse abstracte klasse Animal {// abstracte methodeopenbaar abstract void animalSound (); } public class Dog verlengt dier {public void animalSound () { System.out.println ( "Inslag");}public static void main (String args []) { Animal obj = new Dog (); obj.animalSound ();} } 

Output:

  Inslag 

Interfaces in Java

Een interface is een blauwdruk van een klasse, die kan worden gedeclareerd met behulp van het interface- trefwoord. Interfaces kunnen alleen constanten en abstracte methoden bevatten (methoden met alleen handtekeningen zonder body). Net als abstracte klassen kunnen interfaces niet worden geïnstantieerd, ze kunnen alleen worden geïmplementeerd door klassen of worden uitgebreid met andere interfaces. Interface is een veelgebruikte manier om volledige abstractie in Java te bereiken.

Notitie:

1. Java biedt geen ondersteuning voor Multiple Inheritance, maar een klasse kan meerdere interfaces implementeren
2. Interface is vergelijkbaar met een abstracte klasse, maar bevat alleen abstracte methoden.
3. Interfaces worden gemaakt met behulp van het interface-trefwoord in plaats van de trefwoordklasse
4. We gebruiken implements sleutelwoord tijdens het implementeren van een interface (vergelijkbaar met het uitbreiden van een klasse met uitgebreid trefwoord)

Interface: syntaxis

  class ClassName breidt Superclass-werktuigen Interface1, Interface2, .... uit 

Voorbeeld van interface:

Opmerking :

1. Alle methoden in een interface zijn impliciet openbaar en abstract. Het gebruik van het trefwoord abstract vóór elke methode is optioneel.
2. Een interface kan definitieve variabelen bevatten.
3. Een klasse kan slechts één andere klasse uitbreiden , maar het kan een willekeurig aantal interfaces implementeren.
4. Wanneer een klasse een interface implementeert, moet deze de definitie geven van alle abstracte methoden van interface, anders kan deze als abstracte klasse worden verklaard
5. Een interfaceverwijzing kan verwijzen naar objecten van de implementatieklassen.

Generalisatie en Specialisatie:
Om het concept van overerving in een OOP te implementeren, moet men eerst de overeenkomsten tussen verschillende klassen identificeren om met de basisklasse te komen.

Dit proces om de overeenkomsten tussen verschillende klassen te identificeren, wordt generalisatie genoemd . Generalisatie is het proces van het extraheren van gedeelde kenmerken uit twee of meer klassen en deze combineren in een gegeneraliseerde superklasse. Gedeelde kenmerken kunnen attributen of methoden zijn.

In tegenstelling tot generalisatie betekent specialisatie het maken van nieuwe subklassen van een bestaande klasse. Als blijkt dat bepaalde attributen of methoden alleen van toepassing zijn op enkele objecten van de klasse, kan een subklasse worden gemaakt.

Toegangsspecificaties

Welnu, u moet in de voorbeelden die ik hierboven heb gedeeld, een openbaar privé-trefwoord hebben gezien. Ze worden toegangsspecificaties genoemd omdat ze de reikwijdte van een gegevenslid, methode of klasse bepalen.

Er zijn vier soorten toegangsspecificaties in Java:
publiek: toegankelijk voor iedereen. Andere objecten hebben ook toegang tot deze lidvariabele of functie.
privé: niet toegankelijk voor andere objecten. Privéleden zijn alleen toegankelijk via de methoden in dezelfde klasse. Object alleen toegankelijk in de klasse waarin ze zijn gedeclareerd.
beschermd: het bereik van een beveiligde variabele bevindt zich in de klasse die deze declareert en in de klasse die van de klasse erft (bereik is klasse en subklasse).
Standaard: Scope is pakketniveau. We hoeven de standaardwaarde niet expliciet te vermelden, omdat wanneer we geen toegangsspecificatie vermelden, deze als standaard wordt beschouwd.

Wat zullen we leren in de volgende tutorials over OOPs Concepts

Hoewel we bijna alle OOP's-concepten hier hebben behandeld, maar wat we in deze handleiding hebben geleerd, is kort gezegd, deze onderwerpen zijn breed en er is zoveel ruimte om deze onderwerpen in detail te leren met behulp van voorbeelden. Daarom heb ik elk onderwerp in detail behandeld, samen met voorbeelden en diagrammen in de volgende tutorials.
Hoe kun je de volgende tutorials op een opeenvolgende manier lezen? Er zijn een aantal manieren om dit te doen - 1) Links voor zelfstudie staan ​​in de linkerzijbalk, hoewel ze in de gegeven volgorde worden gebruikt.
2) Ga naar de hoofdpagina van Java-tutorials die alle links naar de tutorials op de opeenvolgende manier bevat.
Als u problemen ondervindt bij het begrijpen van deze OOP's-concepten, laat dan een reactie achter en ik neem zo snel mogelijk contact met u op.