Zoals de naam al doet vermoeden, verwijst Object-Oriented Programming of Java OOPs naar talen die objecten gebruiken bij het programmeren. Ze gebruiken objecten als primaire bron om te implementeren wat er in de code moet gebeuren. Objecten worden gezien door de kijker of gebruiker en voeren taken uit die u toewijst.

Objectgeoriënteerd programmeren heeft tot doel entiteiten uit de echte wereld, zoals overerving, verbergen, polymorfisme, enz. Bij het programmeren te implementeren. Het belangrijkste doel van OOP is om de gegevens en de functies die erop werken samen te binden, zodat geen enkel ander deel van de code toegang heeft tot deze gegevens, behalve die functie.

aaneenschakeling van Java-tekenreeksen

Laten we de vereisten bespreken door de concepten van methodedeclaratie en het doorgeven van berichten te verfijnen. Beginnend met de methodedeclaratie, bestaat deze uit zes componenten:

• Toegangsmodificator : definieert de Toegangstype van de methode, dat wil zeggen vanaf waar deze toegankelijk is in uw toepassing. In Java zijn er 4 soorten toegangsspecificaties:
  
  • openbaar: Toegankelijk in alle klassen in uw applicatie.
  • beschermd: Toegankelijk binnen het pakket waarin het is gedefinieerd en in zijn subklasse(n) (inclusief subklassen die buiten het pakket zijn gedeclareerd) .
  • privaat: Alleen toegankelijk binnen de klasse waarin het is gedefinieerd.
  • standaard (gedeclareerd/gedefinieerd zonder gebruik van een modifier): Toegankelijk binnen dezelfde klasse en hetzelfde pakket waarin de klasse is gedefinieerd.
• Het retourtype : het gegevenstype van de waarde die door de methode wordt geretourneerd, of ongeldig als deze geen waarde retourneert.
• Methodenaam : De regels voor veldnamen zijn ook van toepassing op methodenamen, maar de conventie is iets anders.
• Parameterlijst : Door komma's gescheiden lijst van de invoerparameters die zijn gedefinieerd, voorafgegaan door hun gegevenstype, tussen de omsloten haakjes. Als er geen parameters zijn, moet u lege haakjes () gebruiken.
• Uitzonderingslijst : De uitzonderingen waarvan u verwacht dat de methode deze genereert. Deze uitzondering(en) kunt u specificeren.
• Methode lichaam : Het is het codeblok, tussen accolades, dat u moet uitvoeren om de beoogde bewerkingen uit te voeren.

Bericht overslaan : Objecten communiceren met elkaar door informatie naar elkaar te verzenden en te ontvangen. Een bericht voor een object is een verzoek om uitvoering van een procedure en zal daarom een ​​functie in het ontvangende object aanroepen die de gewenste resultaten genereert. Bij het doorgeven van berichten wordt de naam van het object, de naam van de functie en de te verzenden informatie opgegeven.

Beheers OOP in Java Schrijf schonere, meer modulaire en herbruikbare Java-code door een basis te leggen in objectgeoriënteerd programmeren met de interactieve cursus van Educative Objectgeoriënteerd programmeren in Java . Meld je aan op Educative.io met de code GEEKS10 om 10% te besparen op uw abonnement.

Nu we de basisvereisten hebben behandeld, gaan we verder met de vier pijlers van OOP's, die als volgt zijn. Maar laten we beginnen met het leren over de verschillende kenmerken van een objectgeoriënteerde programmeertaal.

OOPS-concepten zijn als volgt:

1. Klas
2. Voorwerp
3. Methode En methode passeren
4. Pijlers van OOP's
   • Abstractie
   • Inkapseling
   • Erfenis
   • Polymorfisme
     • Compile-time polymorfisme
     • Runtime-polymorfisme

converteren van tekenreeks naar Java met gehele getallen

A klas is een door de gebruiker gedefinieerde blauwdruk of prototype waaruit objecten worden gemaakt. Het vertegenwoordigt de reeks eigenschappen of methoden die gemeenschappelijk zijn voor alle objecten van één type. Met behulp van klassen kunt u meerdere objecten maken met hetzelfde gedrag, in plaats van de code meerdere keren te schrijven. Dit omvat klassen voor objecten die meer dan één keer voorkomen in uw code. Over het algemeen kunnen klassedeclaraties deze componenten in de volgende volgorde bevatten:

1. Modificatoren : Een klasse kan openbaar zijn of standaardtoegang hebben (zie dit voor details).
2. Naam van de klasse: De klassenaam moet volgens afspraak beginnen met de beginletter, met een hoofdletter.
3. Superklasse (indien aanwezig): De naam van de ouder van de klasse (superklasse), indien aanwezig, voorafgegaan door het trefwoord extends. Een klasse kan slechts één ouder uitbreiden (subklasse).
4. Interfaces (indien aanwezig): Een door komma's gescheiden lijst met interfaces die door de klasse zijn geïmplementeerd, indien aanwezig, voorafgegaan door het trefwoord implements. Een klasse kan meer dan één interface implementeren.
5. Lichaam: De hoofdtekst van de klasse wordt omgeven door accolades, { }.

Een voorwerp is een basiseenheid van objectgeoriënteerd programmeren die entiteiten uit het echte leven vertegenwoordigt. Een typisch Java-programma maakt veel objecten, die, zoals u weet, op elkaar inwerken door methoden aan te roepen. De objecten voeren uw code uit, zij zijn het deel van uw code dat zichtbaar is voor de kijker/gebruiker. Een object bestaat hoofdzakelijk uit:

1. Staat : Het wordt weergegeven door de attributen van een object. Het weerspiegelt ook de eigenschappen van een object.
2. Gedrag : Het wordt weergegeven door de methoden van een object. Het weerspiegelt ook de reactie van een object op andere objecten.
3. Identiteit : Het is een unieke naam die aan een object wordt gegeven, waardoor het met andere objecten kan communiceren.
4. Methode : Een methode is een verzameling instructies die een specifieke taak uitvoeren en het resultaat terugsturen naar de aanroeper. Een methode kan een specifieke taak uitvoeren zonder iets terug te geven. Methoden maken het ons mogelijk hergebruiken de code zonder deze opnieuw te typen, daarom worden ze in overweging genomen tijdbesparingen . In Java moet elke methode deel uitmaken van een klasse, die verschilt van talen zoals C , C++ , En Python .

klasse en objecten één eenvoudig Java-programma:

public class GFG {    static String Employee_name;  static float Employee_salary;  static void set(String n, float p) {  Employee_name = n;  Employee_salary = p;  }  static void get() {  System.out.println('Employee name is: ' +Employee_name );  System.out.println('Employee CTC is: ' + Employee_salary);  }  public static void main(String args[]) {  GFG.set('Rathod Avinash', 10000.0f);  GFG.get();  } }>

Employee name is: Rathod Avinash Employee CTC is: 10000.0>

Laten we nu de vier pijlers van OOP’s bespreken:

Pijler 1: Abstractie

Gegevens Abstractie is het eigendom op grond waarvan alleen de essentiële gegevens aan de gebruiker worden getoond. De triviale of niet-essentiële eenheden worden niet aan de gebruiker weergegeven. Bijvoorbeeld: een auto wordt gezien als een auto en niet als zijn afzonderlijke componenten.
Data-abstractie kan ook worden gedefinieerd als het proces waarbij alleen de vereiste kenmerken van een object worden geïdentificeerd, waarbij de irrelevante details worden genegeerd. De eigenschappen en het gedrag van een object onderscheiden het van andere objecten van een vergelijkbaar type en helpen ook bij het classificeren/groeperen van het object.

java-bool naar string

Beschouw eens een voorbeeld uit de praktijk van een man die een auto bestuurt. De man weet alleen dat het indrukken van het gaspedaal de snelheid van de auto zal verhogen en dat het remmen de auto tot stilstand zal brengen, maar hij weet niet hoe de snelheid daadwerkelijk toeneemt als hij het gaspedaal indrukt. Hij weet niets van het innerlijke mechanisme van de auto of de implementatie van het gaspedaal, de remmen etc. in de auto. Dit is wat abstractie is.

In Java wordt abstractie bereikt door interfaces En abstracte klassen . Met behulp van interfaces kunnen we 100% abstractie bereiken.

De abstracte methode bevat alleen de methodedeclaratie, maar geen implementatie.

Demonstratie van abstracte klasse

//abstract class abstract class GFG{  //abstract methods declaration  abstract void add();  abstract void mul();  abstract void div(); }>

Pijler 2: Inkapseling

Het wordt gedefinieerd als het samenbrengen van gegevens onder één enkele eenheid. Het is het mechanisme dat de code en de gegevens die het manipuleert met elkaar verbindt. Een andere manier om over inkapseling na te denken is dat het een beschermend schild is dat voorkomt dat de gegevens toegankelijk zijn voor de code buiten dit schild.

• Technisch gezien, binnen inkapseling , zijn de variabelen of de gegevens in een klasse verborgen voor elke andere klasse en zijn ze alleen toegankelijk via elke lidfunctie van de klasse waarin ze zijn gedeclareerd.
• Bij inkapseling worden de gegevens in een klasse verborgen voor andere klassen, wat vergelijkbaar is met wat gegevens verbergen doet. De termen inkapseling en gegevensverberging worden dus door elkaar gebruikt.
• Inkapseling kan worden bereikt door alle variabelen in een klasse als privé te declareren en openbare methoden in de klasse te schrijven om de waarden van de variabelen in te stellen en te verkrijgen.

Demonstratie van inkapseling:

//Encapsulation using private modifier  //Employee class contains private data called employee id and employee name class Employee {  private int empid;  private String ename; }>

Pijler 3: Erfenis

Erfenis is een belangrijke pijler van OOP (Object Oriented Programming). Het is het mechanisme in Java waarmee een klasse de kenmerken (velden en methoden) van een andere klasse mag erven. We bereiken overerving door te gebruiken strekt zich uit trefwoord. Erfenis wordt ook wel genoemd is een relatie.

array sorteert java

Laten we enkele veelgebruikte belangrijke terminologieën bespreken:

• Superklasse: De klasse waarvan de kenmerken worden geërfd, staat bekend als superklasse (ook bekend als basis- of bovenliggende klasse).
• Subklasse: De klasse die de andere klasse erft, staat bekend als subklasse (ook bekend als afgeleide of uitgebreide of onderliggende klasse). De subklasse kan naast de velden en methoden van de superklasse zijn eigen velden en methoden toevoegen.
• Herbruikbaarheid: Overerving ondersteunt het concept van herbruikbaarheid, dat wil zeggen dat wanneer we een nieuwe klasse willen maken en er al een klasse is die een deel van de code bevat die we willen, we onze nieuwe klasse kunnen afleiden uit de bestaande klasse. Door dit te doen, hergebruiken we de velden en methoden van de bestaande klasse.

Bewijs van erfenis:

//base class or parent class or super class class A{  //parent class methods  void method1(){}  void method2(){} } //derived class or child class or base class class B extends A{ //Inherits parent class methods  //child class methods  void method3(){}  void method4(){} }>

Pijler 4: Polymorfisme

Het verwijst naar het vermogen van objectgeoriënteerde programmeertalen om efficiënt onderscheid te maken tussen entiteiten met dezelfde naam. Dit gebeurt door Java met behulp van de handtekening en declaratie van deze entiteiten. Het vermogen om in vele vormen te verschijnen wordt genoemd polymorfisme .

Bijvoorbeeld

sleep(1000) //millis sleep(1000,2000) //millis,nanos>

Opmerking: Polymorfisme op Java bestaat hoofdzakelijk uit 2 typen:

1. Overbelasting
2. Overschrijven

Voorbeeld

// Java program to Demonstrate Polymorphism // This class will contain // 3 methods with same name, // yet the program will // compile & run successfully public class Sum {  // Overloaded sum().  // This sum takes two int parameters  public int sum(int x, int y)  {  return (x + y);  }  // Overloaded sum().  // This sum takes three int parameters  public int sum(int x, int y, int z)  {  return (x + y + z);  }  // Overloaded sum().  // This sum takes two double parameters  public double sum(double x, double y)  {  return (x + y);  }  // Driver code  public static void main(String args[])  {  Sum s = new Sum();  System.out.println(s.sum(10, 20));  System.out.println(s.sum(10, 20, 30));  System.out.println(s.sum(10.5, 20.5));  } }>

30 60 31.0>

Conclusie

Het Object Oriented Programming (OOPs)-concept in Java is een krachtige manier om code te organiseren en te schrijven. Het maakt gebruik van sleutelideeën zoals klassen, objecten, overerving, polymorfisme, inkapseling en abstractie om flexibele en herbruikbare code te creëren. Door het Java OOPs-concept te gebruiken, kunnen programmeurs complexe applicaties efficiënter bouwen, waardoor de code gemakkelijker te beheren, te begrijpen en aan te passen is. Over het algemeen helpen de OOPs-concepten van Java bij het creëren van robuuste en schaalbare softwareoplossingen.

hoeveel miljoenen zitten er in een miljard

Objectgeoriënteerd programmeren (OOPs)-concept in Java – Veelgestelde vragen

Wat is het OOPs-concept in Java?

OOPs (Object-Oriented Programming) is een programmeerparadigma gebaseerd op het concept van objecten, die gegevens kunnen bevatten in de vorm van velden (attributen of eigenschappen) en code in de vorm van procedures (methoden of functies). In Java omvatten de OOP-concepten inkapseling, overerving, polymorfisme en abstractie.

Waarom zijn OOP's belangrijk in Java?

OOP's helpen bij het organiseren en structureren van code op een beter beheersbare manier, waardoor het gemakkelijker wordt om Java-applicaties te onderhouden en te schalen. Het bevordert ook de herbruikbaarheid, modulariteit en flexibiliteit van code, wat leidt tot efficiënte en robuuste softwareontwikkeling.

Wat zijn de belangrijkste principes van OOP's in Java?

De belangrijkste principes van OOP's in Java zijn inkapseling, overerving, polymorfisme en abstractie. Inkapseling zorgt ervoor dat de interne toestand van een object verborgen blijft en alleen toegankelijk is via publieke methoden. Door overerving kan de ene klasse eigenschappen en gedrag van een andere klasse erven. Polymorfisme maakt het mogelijk objecten te behandelen als instanties van hun bovenliggende klasse. Abstractie richt zich op het verbergen van de implementatiedetails en het tonen van alleen de noodzakelijke informatie aan de buitenwereld.

Hoe worden OOP's geïmplementeerd in Java?

In Java worden OOP's geïmplementeerd via klassen en objecten. Een klasse dient als blauwdruk voor het maken van objecten, die instanties van die klasse zijn. Elk object heeft zijn eigen set attributen (variabelen) en methoden (functies). Door OOP-concepten als inkapseling, overerving, polymorfisme en abstractie te volgen, kunnen Java-ontwikkelaars goed gestructureerde en onderhoudbare code ontwerpen.

Wat zijn de voordelen van het gebruik van OOP's in Java?

Enkele voordelen van het gebruik van OOP's in Java zijn onder meer herbruikbaarheid van code, modulariteit, flexibiliteit, schaalbaarheid en eenvoudiger onderhoud. Met OOPs kunnen ontwikkelaars entiteiten uit de echte wereld als objecten modelleren, wat leidt tot meer intuïtieve en georganiseerde code. Het ondersteunt ook functies zoals overerving en polymorfisme, die de uitbreidbaarheid en leesbaarheid van Java-applicaties verbeteren.

Kunt u een voorbeeld geven van de implementatie van een OOP-concept in Java?

Zeker! Een voorbeeld van de implementatie van een OOP-concept in Java is het maken van een klasse 'Car' met attributen als 'make', 'model' en 'year', samen met methoden als 'start()', 'accelerate()' en 'stop'. ()'. Door objecten uit de klasse ‘Car’ te instantiëren en de methoden ervan aan te roepen, kunnen we het gedrag van verschillende auto-instanties op een gestructureerde en objectgeoriënteerde manier simuleren.