Basisprincipes van object georiënteerd programmeren

23 oktober 2020 om 10:00 by ParTech Media - Post a comment

'Wat is objectgeoriënteerd programmeren' - Stel deze vraag aan elke ontwikkelaar en negen van de tien keer zullen ze de juiste definitie vertellen. Objected Oriented Programming (OOP) is het maken van objecten die zowel gegevens als functies hebben. Vraag dezelfde ontwikkelaar om het concept in een eenvoudige taal uit te leggen en hier kunnen ze moeite mee hebben.

De basisprincipes van OOP omvatten Abstractie, Encapsulation, Overerving en Polymorfisme. Er zijn ook objecten en classes. Samen vormen ze het werkingsprincipe van elke objectgeoriënteerde programmeertaal.

In dit bericht hebben we al deze basisprincipes van OOP behandeld in een indeling zonder jargon. Dit bericht heeft ook enkele praktijkvoorbeelden en voorbeeldprogramma's behandeld om je te helpen de verschillende OOP-concepten zonder problemen te begrijpen.

Inhoudsopgave

  1. Wat is een voorwerp?
  2. Wat zijn klassen?
  3. Wat is abstractie?
  4. Wat is inkapseling?
  5. Wat is Overerving?
  6. Wat is polymorfisme?
  7. Conclusie

Wat is een object?

Laten we dit met een voorbeeld begrijpen. Beschouw je mobiele telefoon als een object. Er kunnen verschillende eigenschappen voor uw mobiele telefoon zijn, zoals het model, de softwareversie en het geheugen. Dit object kan ook functies hebben zoals de camera inschakelen, Bluetooth uitschakelen, opnieuw opstarten, enz. In eenvoudige bewoordingen bevat elk object gegevens en instructies om op die gegevens te reageren.

Wat zijn ‘Classes‘?

Dit is een andere belangrijke term in object-georiënteerd programmeren. Een class is als een sjabloon van waaruit nieuwe objecten worden gemaakt. Elke class die je maakt, heeft altijd een head en een body. Een head bevat typisch modifiers en het trefwoord van de class, terwijl de body data members en data functies bevat.

Hier zijn de verschillende componenten van een class -

  1. Public - De class members zijn vanaf overal toegankelijk.
  2. Private - De class members zijn alleen toegankelijk voor de definiërende class
  3. Protected - de class members zijn alleen toegankelijk voor bovenliggende en inherited classes

Een enkel programma kan een willekeurig aantal class bevatten. Hier is een voorbeeld van een programma met een public class met de naam Smartphone.

public class Smartphone
 {
  String make;
  int memorysize;
  String color;
  String software_version;
 
  void restart()
{
    System.out.println("Shutting Down");
  }

  void Flash()
{
    System.out.println("turning on flashlight");
  }

  void charge()
{
    System.out.println("charging");
  }
}

Wat is Abstractie?

Drink jij wel eens koffie? Als je dat doet, is de kans groot dat je in je leven een koffiezetapparaat hebt gebruikt. Het concept van abstractie is nauw verwant aan het principe van een koffiemachine. Je weet dat een koffiezetapparaat koffie zet, maar je hoeft niet te weten hoe het koffie zet. Kortom, je hoeft alleen maar te weten welke knoppen je moet indrukken om koffie te zetten. Je kunt een door een knop gedefinieerde interface gebruiken om koffie te zetten, zonder dat je je zorgen hoeft te maken over de interne werking van een machine.

Hetzelfde principe gaat in het concept van een objectgeoriënteerde programmeertaal. In eenvoudige bewoordingen is het een concept dat niet is gekoppeld aan een bepaald exemplaar.

Beschouw jouw methode als de koffiemachine en jouw invoerparameter als de knoppen op de machine. Met abstractie kun je naadloze programma's maken door gewoon te weten welke methode je moet aanroepen en welke parameters je moet invoeren. Hier is een voorbeeldprogramma om abstractie te definiëren.

#include <iostream> 

class Abstraction 

{ 
  private: 

    int c, d; 

  public:  

    void set(int x, int y) 
    {  
      c = x; 
      d = y; 
    } 

    void display() 
    { 
      cout<<"a = " <<a << endl; 
      cout<<"b = " << b << endl; 
    } 
}; 


int main() 
{ 
  Abstraction obj; ( Defining )

  obj.set(10, 20); 

  obj.display(); 

  return 0; 
} 

**Output:**
c = 10
d = 20

Wat is Encapsulation?

Het is een groep eigenschappen en leden onder een enkele class of object. Programma's kunnen erg lang zijn en er kunnen gemakkelijk een heleboel bewegende delen in zitten. Na verloop van tijd wordt het echt moeilijk om al deze objecten te onderhouden zonder dat ze ingewikkeld worden.

Dit is waar een primair principe zoals encapsulation in het spel komt. Je kunt dit principe gebruiken om een set objecten in verschillende classes te verwerken. Met dit principe kun je herhaling van code voorkomen en ook de lengte van jouw code verkorten. Je kunt encapsulation zien als een medicinale pil. Alle medicijnen (Objecten) worden opgeslagen in een pil (class) en je kunt het consumeren wanneer dat nodig is.

Wat is overerving?

Het is het vermogen om de eigenschappen van bestaande classes te verwerven en nieuwe te creëren. Overerving stelt je in staat om een code opnieuw te gebruiken zonder deze in een programma te hoeven herschrijven. Een van de beste eigenschappen van overerving is de mogelijkheid om de code in een programma in te korten. Je kunt dit principe gebruiken om codes van een andere klasse te erven en deze opnieuw te gebruiken in een nieuwe class.

Wat is polymorfisme?

Polymorfisme verwijst naar één naam met vele vormen. Het is het vermogen van één functie om op verschillende manieren te presteren. Met andere woorden, het verwijst naar het vermogen van een object om meer dan één enkele vorm aan te nemen.

Polymorfisme kan op twee eenvoudige manieren worden toegepast:

  1. Methode overloading
  2. Methode overriding

Methode overbelasting

Wanneer een class meerdere methoden heeft met dezelfde namen maar een andere set parameters, wordt dit methode overloading genoemd. Je kunt alleen doorgaan met methode overloading als uw methoden voldoen aan een van de volgende regels:

  1. Heeft verschillende parameters
  2. Heeft verschillende return types
  3. Heeft verschillende toegangsmodifiers.

Hier is een voorbeeld van Methode Overloading:

class coding{

  public void code() 
  {
    System.out.println("Coding in C++");
  }

  public void code(String language) 
  {
    System.out.println("Coding in "+language);
  }
}

public class MethodOverloader 
{
  public static void main(String[] args) 
  {
    coding gorilla = new JavaProgrammer();

	gorilla.code();

    gorilla.code("Java");
  }
}

Output:

Coding in C++
Coding in Java

Method Overriding

De tweede manier om door te gaan met polymorfisme is methode overriding. Dit is alleen mogelijk als een subclass ( of ) zusterclass dezelfde methode heeft als de bovenliggende class. Net als bij overloading van de methode zijn er ook enkele regels voor het overriden van de methode.

* Heeft dezelfde parameterlijst * Heeft hetzelfde return type * En zou een toegangsmodifier moeten hebben die restrictiever is dan die van de bovenliggende class.

Hier is een voorbeeld van het overschrijven van methoden:

public class coding
{
  public void code() 
  {
    System.out.println("Coding in C++");
  }
}

public class JavaProgrammer extends coding
{
  public void code() 
  {
    System.out.println("Coding in Java");
  }
}

public class MethodOverridder 
{
  public static void main(String[] args) 
  {
    coding ben = new JavaProgrammer();

    ben.code();
  }
}
 
Output:

Coding in Java

Conclusie

Je zou nu een beter idee hebben over de basisprincipes van OOP en hoe je dit in eenvoudige taal aan anderen kunt uitleggen. Onthoud altijd - De 4 concepten die in dit bericht worden besproken, zullen altijd voorop staan in elke objectgeoriënteerde programmeertaal - hoe ingewikkeld ze ook zijn.