PHP-Konzept der objektorientierten Programmierung (OOP) mit Beispiel

Was sind OOPs?

Objektorientierte Programmierung ist ein Ansatz zur Softwareentwicklung, der Anwendungen anhand realer Objekte wie Mitarbeiter, Autos und Bankkonten modelliert. Eine Klasse definiert die Eigenschaften und Methoden eines realen Objekts. Ein Objekt ist eine Instanz einer Klasse.

Die drei grundlegenden Komponenten der Objektorientierung sind:

• Objektorientierte Analyse – Funktionalität des Systems
• Objektorientiertes Design – Architektur des Systems
• Objektorientierte Programmierung – Implementierung der Anwendung

Prinzipien der objektorientierten Programmierung

Die drei Hauptprinzipien der objektorientierten Programmierung sind:

• Kapselung Hierbei geht es darum, die Implementierungsdetails zu verbergen und nur die Methoden offenzulegen. Die Hauptzwecke der Kapselung sind:
  • Reduzieren Sie die Komplexität der Softwareentwicklung – indem Sie die Implementierungsdetails verbergen und nur die Vorgänge anzeigen, wird die Verwendung einer Klasse vereinfacht.
  • Der interne Zustand eines Objekts wird geschützt – der Zugriff auf die Klassenvariablen erfolgt über Methoden wie get und set. Dies macht die Klasse flexibel und wartungsfreundlich.
  • Ermöglichen Sie es, die interne Implementierung der Klasse zu ändern, ohne sich Sorgen machen zu müssen, dass der Code, der die Klasse verwendet, dadurch beeinträchtigt wird.
• Erbe – Hierbei geht es um die Beziehung zwischen Klassen. Diese Beziehung hat die Form einer Eltern-Kind-Beziehung. Die Kindklasse verwendet die in der Elternklasse definierten Methoden. Der Hauptzweck der Vererbung ist:
  • Wiederverwendbarkeit – mehrere Kindelemente können vom selben Elternelement erben. Dies ist besonders nützlich, wenn häufig genutzte Funktionen wie das Hinzufügen, Aktualisieren und Löschen von Daten in der Datenbank bereitgestellt werden müssen.
• Polymorphie Hierbei geht es um eine einzige Schnittstelle mit vielen verschiedenen Implementierungen. Der Hauptzweck von Polymorphismus ist:
  • Um die Wartung von Anwendungen zu vereinfachen und sie erweiterbarer zu machen.

Hoppla Concepts in PHP

PHP ist eine objektorientierte Skriptsprache; sie unterstützt alle oben genannten Prinzipien. Die oben genannten Prinzipien werden erreicht durch:

• Kapselung – durch die Verwendung von „get“- und „set“-Methoden sowie Zugriffsmodifikatoren.
• Erbe – durch Verwendung des Schlüsselworts „extends“.
• Polymorphie – durch die Verwendung des Schlüsselworts „implements“.

Jetzt verfügen wir über die Grundkenntnisse von OOP und wissen, wie es unterstützt wird PHPSchauen wir uns nun Beispiele an, die die oben genannten Prinzipien umsetzen.

Was ist UML?

Die Unified Modeling Language (UML) ist eine Technik, die zum Entwurf und zur Dokumentation objektorientierter Systeme verwendet wird.

UML erzeugt eine Reihe von Dokumenten, wir werden uns jedoch das Klassendiagramm ansehen, das für die objektorientierte PHP-Programmierung sehr wichtig ist.

Beispiel für ein Klassendiagramm

Klassendiagrammschlüssel

• Das oberer Kasten enthält den Klassennamen
• Das mittlere Box enthält die Klassenvariablen
• Das unterer Kasten enthält die Klassenmethoden
• Das minus (-) Das Zeichen bedeutet privater Geltungsbereich
• Das plus (+) Zeichen bedeutet öffentlichen Bereich
• Das Hash (#) Zeichen bedeutet geschützter Bereich

So erstellen Sie eine Klasse in PHP

Das Schlüsselwort class wird verwendet, um eine Klasse in PHP zu definieren. Nachfolgend finden Sie die Regeln zum Erstellen einer Klasse in PHP.

• Der Klassenname sollte mit einem Buchstaben beginnen
• Der Klassenname darf kein PHP-reserviertes Wort sein
• Der Klassenname darf keine Leerzeichen enthalten

Nehmen wir an, wir möchten eine Klasse zur Darstellung von Tieren erstellen. Wir beginnen damit, die Merkmale zu identifizieren, die allen Tieren gemeinsam sind.

• Alle Tiere gehören einer Familie an, wie zum Beispiel Pflanzenfresser, Fleischfresser usw.
• Alle Tiere fressen Nahrung

Das untenstehende Diagramm zeigt das Klassendiagramm für das Tier.

Nun lasst uns unsere Tierklasse programmieren.

<?php
class Animal
{
    private $family;
    private $food;
    public function __construct($family, $food)
    {
        $this->family = $family;
        $this->food = $food;
    }
    public function get_family()
    {
        return $this->family;
    }
    public function set_family($family)
    {
        $this->family = $family;
    }
    public function get_food()
    {
        return $this->food;
    }
    public function set_food($food)
    {
        $this->food = $food;
    }
}
?>

HIER,

• „private $family, $food“ bedeutet, dass auf die Variablen nicht direkt von außerhalb der Klasse zugegriffen werden kann (Kapselung).
• „public function __construct($family…)“ ist die Konstruktormethode in PHP. Diese Funktion wird immer dann aufgerufen, wenn eine Instanz der Klasse erstellt wird. In diesem Fall werden die Familie und das Essen festgelegt.
• „public function get…()“ ist die Methode, mit der auf den Familien- oder Lebensmittelwert zugegriffen wird (Kapselung).
• „public function set…()“ ist die Methode, mit der der Familien- oder Lebensmittelwert festgelegt wird (Kapselung).

Wie man Vererbung in PHP implementiert

Wir werden mit einer Kuh und einem Löwen arbeiten. Sowohl die Kuh als auch der Löwe erben von der Klasse „Animal“.

Das folgende Klassendiagramm zeigt die Beziehungen.

Beachten Sie, dass die Kuh von der Klasse Animal erbt und auch eigene Variablen und Methoden definiert.

Nun wollen wir die Klasse „Cow“ programmieren.

<?php
class Cow extends Animal
{
    private $owner;
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
    public function set_owner($owner)
    {
        $this->owner = $owner;
    }
    public function get_owner()
    {
        return $this->owner;
    }
}
?>

Nun lasst uns die Lion-Klasse programmieren.

<?php
class Lion extends Animal
{
    public function __construct($family, $food)
    {
        parent::__construct($family, $food);
    }
}
?>

HIER,

• „class … extends Animal“ bewirkt, dass die Klassen Cow und Lion Methoden der Klasse Animal verwenden (Vererbung).

Wie man ein Objekt der Klasse erstellt

Der Einfachheit halber sollten sich die Klassen Animal, Cow und Lion alle im selben Verzeichnis befinden.

Lasst uns nun die Anwendung erstellen, die unsere Klassen verwendet.

Beispiel einer PHP-Klasse

<?php
require 'Animal.php';
require 'Cow.php';
require 'Lion.php';
$cow = new Cow('Herbivore', 'Grass');
$lion = new Lion('Carnivore', 'Meat');
echo '<b>Cow Object</b> <br>';
echo 'The Cow belongs to the ' . $cow->get_family() . ' family and eats ' . $cow->get_food() . '<br><br>';
echo '<b>Lion Object</b> <br>';
echo 'The Lion belongs to the ' . $lion->get_family() . ' family and eats ' . $lion->get_food();
?>

Testen unserer Anwendung

Betrachten wir nun unsere Anwendung in einem Webbrowser.

Beide Objekte verwenden die von der Klasse Animal geerbten Methoden get_family und get_food wieder, was die Vererbung in der Praxis veranschaulicht.

Wie man Polymorphismus in PHP implementiert

Nehmen wir an, wir möchten eine Anwendung entwickeln, die Verbindungen zu verschiedenen Datenbank-Engines herstellt, wie zum Beispiel MySQL und SQL Der Server verwendet jedoch dieselbe einheitliche Schnittstelle. Wir können eine Schnittstelle erstellen, die die Standardmethoden und eine absolute Schnittstelle definiert.tract-Klasse, die die gemeinsamen Methoden implementiert.

• Interface – Es ähnelt einer Klasse. Es definiert lediglich die Methoden und Parameter.
• AbstracT-Klasse – Es handelt sich um eine Klasse, die nicht zum direkten Erstellen eines Objekts verwendet werden kann. Sein Zweck besteht darin, teilweise oder vollständige Implementierungen gängiger Methoden bereitzustellen.

Das untenstehende Klassendiagramm veranschaulicht die Beziehung zwischen unseren Abstract-Klasse, Schnittstelle und Implementierungsklassen.

Lasst uns nun unsere Bauchmuskeln trainieren.tract-Klasse.

<?php
abstract class DBCommonMethods
{
    private $host;
    private $db;
    private $uid;
    private $password;
    public function __construct($host, $db, $uid, $password)
    {
        $this->host = $host;
        $this->db = $db;
        $this->uid = $uid;
        $this->password = $password;
    }
}
?>

HIER,

• „Bauchmuskelntrac„t class“ bedeutet, dass die Klasse nicht direkt zur Erstellung eines Objekts verwendet werden kann.
• „$host, $db…“ sind Klassenvariablen, die allen Implementierungen gemeinsam sind.
• „function __construct(…)“ ist die Klassenkonstruktormethode, die bei der Initialisierung die Werte der gemeinsamen Variablen festlegt.

Nun erstellen wir die Schnittstelle, die die Standardmethoden enthält, welche je nach Datenbank-Engine unterschiedlich implementiert werden.

<?php
interface DBInterface
{
    public function db_connect();
    public function insert($data);
    public function read($where);
    public function update($where);
    public function delete($where);
}
?>

HIER,

• „Schnittstelle“ ist das Schlüsselwort für die Erstellung von Schnittstellen
• „public function…(…)“ sind die Standardmethoden, die implementiert werden sollten

Nun erstellen wir die konkreten Klassen, die die Klasse DBCommonMethods erweitern und die Schnittstelle DBInterface implementieren. Zuerst MySQLDriver.php:

<?php
class MySQLDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

Dann MSSQLServerDriver.php:

<?php
class MSSQLServerDriver extends DBCommonMethods implements DBInterface
{
    public function __construct($host, $db, $uid, $password)
    {
        parent::__construct($host, $db, $uid, $password);
    }
    public function db_connect() { /* connect code goes here */ }
    public function delete($where) { /* delete code goes here */ }
    public function insert($data)  { /* insert code goes here */ }
    public function read($where)   { /* read code goes here */ }
    public function update($where) { /* update code goes here */ }
}
?>

HIER,

• „class … extends DBCommonMethods“ verwendet die Methoden in DBCommonMethods
• „… implements DBInterface“ stellt sicher, dass die Klasse unabhängig vom verwendeten Datenbanktreiber die Standardmethoden bereitstellt.

Der Code, der die oben genannten Klassen verwendet, würde folgendermaßen aussehen:

<?php $db = new MySQLDriver($host, $db, $uid, $password); ?>

Oder:

<?php $db = new MSSQLServerDriver($host, $db, $uid, $password); ?>

Der restliche Code wäre für beide Treiber identisch, zum Beispiel:

<?php
$db->db_connect();
$db->insert($data);
?>

Das ist Polymorphismus in Aktion: Dieselben Methodenaufrufe funktionieren auf jedem Treiber, der die Schnittstelle implementiert, sodass sich der umgebende Code beim Wechsel der Datenbank-Engine nie ändert.

Häufig gestellte Fragen