Kaffeepause Nr. 90. 4 Säulen der objektorientierten Programmierung

Quelle: The Geek Asian Werfen wir einen Blick auf die vier Grundlagen der objektorientierten Programmierung und versuchen zu verstehen, wie sie funktionieren. Die objektorientierte Programmierung (OOP) ist eines der wichtigsten Programmierparadigmen. Es kann einfach und unkompliziert oder im Gegenteil sehr komplex sein. Es hängt alles davon ab, wie Sie sich für die Entwicklung Ihrer Anwendung entscheiden. Es gibt 4 Säulen von OOP:

1. Verkapselung.
2. Nachlass.
3. Abstraktion.
4. Polymorphismus.

Wir werden nun jeden von ihnen mit einer kurzen Erklärung und einem echten Codebeispiel besprechen.

1. Kapselung

Wir alle haben Kapselung als das Verstecken von Datenelementen und das Ermöglichen, dass Benutzer mit öffentlichen Methoden auf Daten zugreifen, untersucht. Wir nennen diese Getter und Setter. Vergessen wir das jetzt und finden wir eine einfachere Definition. Bei der Kapselung handelt es sich um eine Methode, mit der der Benutzer daran gehindert wird, Datenelemente oder Klassenvariablen direkt zu ändern, um die Datenintegrität aufrechtzuerhalten. Wie machen wir das? Wir beschränken den Zugriff auf Variablen, indem wir den Zugriffsmodifikator auf „ privat“ setzen und öffentliche Methoden offenlegen, die für den Zugriff auf Daten verwendet werden können. Schauen wir uns unten konkrete Beispiele an. Dies wird uns helfen zu verstehen, wie wir die Kapselung nutzen können, um die Datenintegrität aufrechtzuerhalten. Ohne Kapselung:

/**
 * @author thegeekyasian.com
 */
public class Account {

  public double balance;

  public static void main(String[] args) {

  	Account theGeekyAsianAccount = new Account();

  	theGeekyAsianAccount.balance = -54;
  }
}

Im obigen Codeausschnitt greift die main()- Methode direkt auf die Balance- Variable zu . Dadurch kann der Benutzer einen beliebigen Double-Wert für die Saldovariable der Account- Klasse festlegen . Wir können die Datenintegrität verlieren, wenn wir jedem erlauben, den Kontostand auf eine ungültige Zahl einzustellen , wie in diesem Fall -54. Mit Kapselung:

/**
 * @author thegeekyasian.com
 */
public class Account {

  private double balance;

  public void setBalance(double balance) {

    if(balance >= 0) { // Validating input data in order to maintain data integrity
	  this.balance = balance;
    }

    throw new IllegalArgumentException("Balance cannot be less than zero (0)");
  }

  public static void main(String[] args) {

  	Account theGeekyAsianAccount = new Account();

  	theGeekyAsianAccount.setBalance(1); // Valid input - Allowed
  	theGeekyAsianAccount.setBalance(-55); // Stops user and throws exception
  }
}

In diesem Code haben wir den Zugriff auf die Balance- Variable eingeschränkt und eine setBalance()- Methode hinzugefügt, mit der Benutzer den Balance- Wert für Account festlegen können . Der Setter prüft den bereitgestellten Wert, bevor er ihn der Variablen zuweist. Wenn der Wert kleiner als Null ist, wird eine Ausnahme ausgelöst. Dadurch wird sichergestellt, dass die Integrität der Daten nicht beeinträchtigt wird. Nach der Erläuterung der obigen Beispiele hoffe ich, dass der Wert der Kapselung als eine der vier Säulen von OOP klar wird.

2. Vererbung

Vererbung ist eine Methode zum Erhalten von Eigenschaften einer anderen Klasse, die gemeinsame Merkmale aufweisen. Dadurch können wir die Wiederverwendbarkeit erhöhen und die Codeduplizierung reduzieren. Die Methode verfügt außerdem über das Prinzip der Kind-Eltern-Interaktion, bei der ein untergeordnetes Element die Eigenschaften seines übergeordneten Elements erbt. Schauen wir uns zwei kurze Beispiele an und sehen, wie Vererbung Code einfacher und wiederverwendbar macht. Ohne Vererbung:

/**
 * @author thegeekyasian
 */
public class Rectangle {

  private int width;
  private int height;

  public Rectangle(int width, int height) {
	this.width = width;
	this.height = height;
  }

  public int getArea() {
	return width * height;
  }
}

public class Square {

  private int width; // Duplicate property, also used in class Rectangle

  public Square(int width) {
	this.width = width;
  }

  public int getArea() { // Duplicate method, similar to the class Rectangle
	return this.width * this.width;
  }
}

Die beiden ähnlichen Klassen teilen sich die width- Eigenschaften und die getArea()- Methode . Wir können die Wiederverwendung von Code erhöhen, indem wir ein kleines Refactoring durchführen, bei dem die Square- Klasse letztendlich von der Rechteck- Klasse erbt . Mit Vererbung:

/**
 * @author thegeekyasian
 */
public class Rectangle {

  private int width;
  private int height;

  public Rectangle(int width, int height) {
	this.width = width;
	this.height = height;
  }

  public int getArea() {
	return width * height;
  }
}

public class Square extends Rectangle {

  public Square(int width) {
	super(width, width); // A rectangle with the same height as width is a square
  }
}

Durch einfaches Erweitern der Klasse „Rechteck“ erhalten wir die Klasse „Quadrat“ als Typ „Rechteck“ . Das bedeutet, dass es alle Eigenschaften erbt, die Square und Rechteck gemeinsam haben . In den obigen Beispielen sehen wir, wie Vererbung eine wichtige Rolle dabei spielt, Code wiederverwendbar zu machen. Es ermöglicht einer Klasse außerdem, das Verhalten ihrer übergeordneten Klasse zu erben.

3. Abstraktion

Abstraktion ist eine Technik, die dem Benutzer nur wesentliche Details präsentiert, indem unnötige oder irrelevante Details eines Objekts ausgeblendet werden. Es trägt dazu bei, die betriebliche Komplexität auf Benutzerseite zu reduzieren. Durch die Abstraktion können wir dem Benutzer eine einfache Schnittstelle bereitstellen, ohne nach komplexen Details für die Ausführung einer Aktion zu fragen. Einfach ausgedrückt gibt es dem Benutzer die Möglichkeit, ein Auto zu fahren, ohne dass er genau verstehen muss, wie der Motor funktioniert. Schauen wir uns zunächst ein Beispiel an und diskutieren dann, wie uns die Abstraktion hilft.

/**
* @author thegeekyasian.com
*/
public class Car {

  public void lock() {}
  public void unlock() {}

  public void startCar() {

	checkFuel();
	checkBattery();
	whatHappensWhenTheCarStarts();
  }

  private void checkFuel() {
	// Check fuel level
  }

  private void checkBattery() {
	// Check car battery
  }

  private void whatHappensWhenTheCarStarts() {
	// Magic happens here
  }
}

Im obigen Code sind die Methoden lock() , unlock() und startCar() öffentlich und der Rest ist privat für die Klasse. Wir haben es dem Benutzer einfacher gemacht, „das Auto zu fahren“. Natürlich könnte er checkFuel() und checkBattery() manuell überprüfen , bevor er das Auto mit startCar() startet , aber das würde den Vorgang nur verkomplizieren. Mit dem obigen Code muss der Benutzer lediglich startCar() verwenden und die Klasse kümmert sich um den Rest. Das nennen wir Abstraktion.

4. Polymorphismus

Die letzte und wichtigste der vier Säulen von OOP ist der Polymorphismus. Polymorphismus bedeutet „viele Formen“. Wie der Name schon sagt, handelt es sich um eine Funktion, mit der Sie eine Aktion auf mehrere oder unterschiedliche Arten ausführen können. Wenn wir über Polymorphismus sprechen, gibt es nicht viel zu besprechen, es sei denn, wir sprechen über seine Typen. Es gibt zwei Arten von Polymorphismus:

1. Methodenüberladung – statischer Polymorphismus (statische Bindung).
2. Methodenüberschreibung – dynamischer Polymorphismus (dynamische Bindung).

Lassen Sie uns jeden dieser Typen besprechen und sehen, was der Unterschied zwischen ihnen ist.

Methodenüberladung – statischer Polymorphismus:

Methodenüberladung oder statischer Polymorphismus, auch bekannt als statische Bindung oder Bindung zur Kompilierungszeit, ist ein Typ, bei dem Methodenaufrufe zur Kompilierzeit bestimmt werden. Durch das Überladen von Methoden können wir mehrere Methoden mit demselben Namen, unterschiedlichen Parameterdatentypen oder unterschiedlicher Anzahl von Parametern oder beidem verwenden. Aber die Frage ist, warum ist Methodenüberladung (oder statischer Polymorphismus) sinnvoll? Schauen wir uns die folgenden Beispiele an, um das Überladen von Methoden besser zu verstehen. Ohne Methodenüberladung:

/**
* @author thegeekyasian.com
*/
public class Number {

  public void sumInt(int a, int b) {
	System.out.println("Sum: " + (a + b));
  }

  public void sumDouble(double a, double b) {
	System.out.println("Sum: " + (a + b));
  }

  public static void main(String[] args) {

	Number number = new Number();

	number.sumInt(1, 2);
	number.sumDouble(1.8, 2.5);
  }
}

Im obigen Beispiel haben wir zwei Methoden mit unterschiedlichen Namen erstellt, nur um zwei verschiedene Arten von Zahlen hinzuzufügen. Wenn wir mit einer ähnlichen Implementierung fortfahren, werden wir mehrere Methoden mit unterschiedlichen Namen haben. Dies verringert die Qualität und Verfügbarkeit des Codes. Um dies zu verbessern, können wir Methodenüberladung verwenden, indem wir denselben Namen für verschiedene Methoden verwenden. Dadurch steht dem Benutzer eine Option als Einstiegspunkt für die Summierung verschiedener Zahlentypen zur Verfügung. Das Überladen von Methoden funktioniert, wenn zwei oder mehr Methoden denselben Namen, aber unterschiedliche Parameter haben. Der Rückgabetyp kann gleich oder unterschiedlich sein. Wenn jedoch zwei Methoden denselben Namen, dieselben Parameter, aber unterschiedliche Rückgabetypen haben, führt dies zu einer Überladung und einem Kompilierungsfehler! Mit Methodenüberladung:

/**
* @author thegeekyasian.com
*/
public class Number {

  public void sum(int a, int b) {
	System.out.println("Sum: " + (a + b));
  }

  public void sum(double a, double b) {
	System.out.println("Sum: " + (a + b));
  }

  public static void main(String[] args) {

	Number number = new Number();

	number.sum(1, 2);
	number.sum(1.8, 2.5);
  }
}

Im selben Code konnten wir mit ein paar geringfügigen Änderungen beide Methoden überladen, sodass die Namen für beide gleich waren. Der Benutzer kann nun seine spezifischen Datentypen als Methodenparameter angeben. Anschließend wird eine Aktion basierend auf dem bereitgestellten Datentyp ausgeführt. Diese Methodenbindung erfolgt zur Kompilierungszeit, da der Compiler weiß, welche Methode mit dem angegebenen Parametertyp aufgerufen wird. Aus diesem Grund nennen wir es Kompilierzeitbindung.

Methodenüberschreibung – dynamischer Polymorphismus:

Im Gegensatz zum Überladen von Methoden können Sie beim Überschreiben von Methoden genau dieselbe Signatur wie mehrere Methoden verwenden, diese müssen sich jedoch in mehreren verschiedenen Klassen befinden. Die Frage ist, was ist das Besondere daran? Diese Klassen haben eine IS-A-Beziehung, das heißt, sie müssen voneinander erben. Mit anderen Worten: Beim Methodenüberschreiben oder dynamischen Polymorphismus werden Methoden zur Laufzeit dynamisch verarbeitet, wenn die Methode aufgerufen wird. Dies erfolgt anhand der Referenz auf das Objekt, mit dem es initialisiert wird. Hier ist ein kleines Beispiel für das Überschreiben einer Methode:

/**
* @author thegeekyasian.com
*/
public class Animal {

  public void walk() {
	System.out.println("Animal walks");
  }
}

public class Cat extends Animal {

  @Override
  public void walk() {
	System.out.println("Cat walks");
  }
}

public class Dog extends Animal {

  @Override
  public void walk() {
	System.out.println("Dog walks");
  }
}

public class Main {

  public static void main(String[] args) {

	Animal animal = new Animal();
	animal.walk(); // Animal walks

	Cat cat = new Cat();
	cat.walk(); // Cat walks

	Dog dog = new Dog();
	dog.walk(); // Dog walks

	Animal animalCat = new Cat(); // Dynamic Polymorphism
	animalCat.walk(); // Cat walks

	Animal animalDog = new Dog(); // Dynamic Polymorphism
	animalDog.walk(); //Dog walks
  }
}

In diesem übergeordneten Beispiel haben wir Objekte vom Typ „Hund“ und „Katze“ dynamisch dem Typ „Tier“ zugewiesen. Dadurch können wir die walk()- Methode für referenzierte Instanzen dynamisch zur Laufzeit aufrufen . Wir können dies durch Methodenüberschreibung (oder dynamischen Polymorphismus) erreichen. Damit ist unsere kurze Diskussion über die vier Säulen von OOP abgeschlossen und ich hoffe, dass Sie sie nützlich finden.