English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
In der objektorientierten Programmierung (Englisch: Object-Programmierung (OOP), Abkürzung: OOP) ist, dass ein Objekt ein Ganzes ist, das aus Informationen und Beschreibungen thereof besteht, die Informationen verarbeiten, und es ist eine Abstraktion der realen Welt.
In der realen Welt sind die Dinge, mit denen wir konfrontiert sind, alle Objekte, wie Computer, Fernseher, Fahrräder usw.
Die Hauptmerkmale von Objekten sind drei:
Verhalten des Objekts: Welche Operationen können auf das Objekt angewendet werden, z.B. Anschalten und Ausschalten sind Verhaltensweisen.
Form des Objekts: Wie reagiert das Objekt auf angewendete Methoden, Farbe, Größe, Form.
Darstellung des Objekts: Die Darstellung eines Objekts ist相当于eine Identitätskarte, und die spezifische Unterscheidung liegt in den Unterschieden in den gleichen Verhaltens- und Zustandsmerkmalen.
Zum Beispiel ist Animal (Tier) eine abstrakte Klasse, und wir können spezifisch auf einen Hund und ein Schaf eingehen, und der Hund und das Schaf sind spezifische Objekte, die Farbbezeichnungen haben und Verhaltenszustände wie Schreiben und Laufen aufweisen können.
Klasse − Definiert die abstrakten Merkmale einer Sache. Die Definition der Klasse umfasst die Form der Daten und die Operationen auf die Daten.
Objekt − ist ein Beispiel für eine Klasse.
Membervariable − Definierte Variablen im Klassenumfeld. Der Wert dieser Variablen ist für Außenstehende unsichtbar, aber er kann über Memberfunktionen erreicht werden. Nachdem die Klasse in ein Objekt konvertiert wurde, kann diese Variable als Eigenschaft des Objekts bezeichnet werden.
Memberfunktion − Definiert im Klassenumfeld, kann es zum Zugriff auf die Daten des Objekts verwendet werden.
Vererbung − Vererbbarkeit ist das Mechanismus, durch den Unterklassen automatisch die Datenstruktur und Methoden der Elterklasse teilen, was eine Beziehung zwischen Klassen ist. Beim Definieren und Implementieren einer Klasse kann auf der Grundlage einer bereits existierenden Klasse gearbeitet werden, indem die definierten Inhalte der bereits existierenden Klasse als eigene Inhalte übernommen und einige neue Inhalte hinzugefügt werden.
Elterklasse − Eine Klasse, die von einer anderen Klasse geerbt wird, kann als Elterklasse, Basisklasse oder Überklasse bezeichnet werden.
Unterklasse − Eine Klasse, die von einer anderen Klasse abgeleitet wird, wird als Unterklasse oder Ableitungsklasse bezeichnet.
Polymorphie − Polymorphie bezieht sich darauf, dass gleiche Funktionen oder Methoden auf verschiedene Arten von Objekten angewendet werden können und unterschiedliche Ergebnisse erzielen. Verschiedene Objekte können auf die gleiche Nachricht unterschiedlich reagieren, und dieses Phänomen wird Polymorphie genannt.
Überladung − Kurz gesagt, ist dies der Fall, dass Funktionen oder Methoden denselben Namen haben, aber unterschiedliche Parameterlisten, und solche Funktionen oder Methoden mit gleichem Namen und unterschiedlichen Parametern nennen sich gegenseitig überladene Funktionen oder Methoden.
Abstraktion − Abstraktion bezieht sich darauf, Objekte mit einheitlicher Datenstruktur (Eigenschaften) und Verhalten (Operationen) in Klassen abstrahieren. Eine Klasse ist so eine Abstraktion, die wichtige Eigenschaften, die mit der Anwendung zusammenhängen, widerspiegelt, und andere unwichtige Inhalte ignoriert. Die Klassifizierung jeder Klasse ist subjektiv, muss aber mit der spezifischen Anwendung zusammenhängen.
Verkapselung − Verkapselung bezieht sich darauf, die Eigenschaften und Verhaltensweisen eines bestimmten Objekts in der realen Welt miteinander zu verknüpfen und in einer logischen Einheit zu platzieren.
Konstruktor − Hauptsächlich zum Initialisieren von Objekten bei der Erstellung von Objekten verwendet, d.h. zur Zuweisung von Initialwerten an die Objektmitglieder, wird immer zusammen mit dem new-Operator in der Erstellungsanweisung für Objekte verwendet.
Destructormethode − Der Destruktor (destructor) ist dem Konstruktor entgegengesetzt, der Destruktor wird automatisch ausgeführt, wenn das Objekt sein Lebenszyklus beendet hat (z.B. wenn die Funktion, in der sich das Objekt befindet, aufgerufen wurde). Der Destruktor wird oft verwendet, um "Aufräumen" zu tun (z.B. wenn beim Erstellen des Objekts mit new ein Speicherplatz bereitgestellt wurde, sollte dieser im Destruktor vor dem Verlassen freigegeben werden).
In dem folgenden Bild haben wir drei Objekte durch die Klasse Car erstellt: Mercedes, Bmw und Audi.
$mercedes = new Car(); $bmw = new Car(); $audi = new Car();
PHP-Klasse definieren wird normalerweise in folgendem Syntaxformat durchgeführt:
<?php
class phpClass {
var $var1;
var $var2 = 'constant string';
function myfunc ($arg1, $arg2) {
[..]
}
[..]
}
?>wie folgt analysiert werden:
Klasse verwenden class nach dem Schlüsselwort und der Klassennamen definiert.
in Paaren von geschweiften Klammern ({}) nach dem Klassennamen Variablen und Methoden definiert werden können.
Die Variablen der Klasse verwenden var um zu deklarieren, Variablen können auch initialisierte Werte haben.
Die Definition der Funktionen ähnelt der Definition der PHP-Funktionen, aber die Funktionen können nur durch die Klasse und die instanzierten Objekte aufgerufen werden.
<?php
class Site {
/* Membervariable */
var $url;
var $title;
/* Memberfunktion */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url . PHP_EOL;
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . PHP_EOL;
}
}
?>Variable $this stellt das Objekt selbst dar.
PHP_EOL als Zeilenumbruch.
Nach der Erstellung der Klasse können wir new Operator, um das Objekt der Klasse zu instanziieren:
$w3codebox = new Site; $taobao = new Site; $google = new Site;
Die obige Codezeile erstellen wir drei Objekte, drei Objekte sind alle unabhängig voneinander, nun schauen wir uns an, wie wir auf die Membermethoden und Membervariable zugreifen können.
Nach dem Instanziieren des Objekts können wir die Membermethoden des Objekts aufrufen, die Membermethoden können nur die Membervariable des Objekts verändern:
// Aufruf der Memberfunktion, Titel und URL festlegen
$w3codebox->setTitle( "Grundlagen-Tutorial-Website" );
$taobao->setTitle('淘宝');
$google->setTitle( "Google Suche" );
$w3codebox->setUrl( 'www.w3>setUrl( 'www.codebox.com' );
$taobao->setUrl('www.taobao.com');
$google->setUrl( 'www.google.com' );
// Aufruf von Memberfunktionen, um Titel und URL zu erhalten
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();Vollständiger Code wie folgt:
<?php
class Site {
/* Membervariable */
var $url;
var $title;
/* Memberfunktion */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url . PHP_EOL;
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . PHP_EOL;
}
}
$w3codebox = new Site;
$taobao = new Site;
$google = new Site;
// Aufruf der Memberfunktion, Titel und URL festlegen
$w3codebox->setTitle( "Grundlagen-Tutorial-Website" );
$taobao->setTitle( "Tianmao Einkaufszentrum" );
$google->setTitle( "Google Suche" );
$w3codebox->setUrl( 'www.w3>setUrl( 'www.codebox.com' );
$taobao->setUrl( 'www.tmall.com' );
$google->setUrl( 'www.google.com' );
// Aufruf von Memberfunktionen, um Titel und URL zu erhalten
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Führt man den obigen Code aus, so ergibt sich als Ausgabe:
Grundlagen-Tutorial-Website Tianmao Einkaufszentrum Google Suche de.oldtoolbag.com www.tmall.com www.google.com
Der Konstruktor ist eine spezielle Methode. Hauptzweck ist die Initialisierung des Objekts beim Erstellen des Objekts, d.h. die Zuweisung von Initialwerten an die Objektmitglieder, und wird zusammen mit dem new-Operator im Erstellungsaufruf des Objekts verwendet.
PHP 5 Ermöglicht es dem Entwickler, eine Methode in einer Klasse als Konstruktor zu definieren, und die Syntax ist wie folgt:
void __construct ([ mixed $args [, $... ]]]
In dem obigen Beispiel können wir die Konstruktormethode verwenden, um die Variablen $url und $title zu initialisieren:
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}Jetzt müssen wir nicht mehr setTitle und setUrl Methoden aufrufen:
$w3codebox = new Site('de.oldtoolbag.com', 'Grundlagen-Tutorial-Website');
$tmall = new Site('www.tmall.com', 'Tianmao Einkaufszentrum');
$google = new Site('www.google.com', 'Google Suche');
// Aufruf von Memberfunktionen, um Titel und URL zu erhalten
$w3codebox->getTitle();
$tmall->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$tmall->getUrl();
$google->getUrl();Der Destructor (Destructeur) ist dem Konstruktor entgegengesetzt. Wenn ein Objekt sein Lebenszyklus endet (z.B. wenn die Funktion, in der sich das Objekt befindet, aufgerufen wurde), führt das System den Destructormethode automatisch aus.
PHP 5 Der Konzept des Destructors wurde eingeführt, das ähnlich anderen objektorientierten Sprachen ist, und die Syntax ist wie folgt:
void __destruct ( void )
<?php
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "Zerstörung " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>Führt man den obigen Code aus, so ergibt sich als Ausgabe:
Konstruktor Zerstörung von MyDestructableClass
PHP verwendet den Schlüsselwort extends Um eine Klasse zu erben, unterstützt PHP keine Mehrvererbung, und das Format ist wie folgt:
class Child extends Parent {
// Code-Teil
}Im Beispiel erbt die Klasse Child_Site die Klasse Site und erweitert die Funktionen:
<?php
// Klassextension der Site-Kategorie
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . PHP_EOL;
}
}Wenn Methoden von der Elternklasse den Anforderungen der Unterklasse nicht gerecht werden, können sie geändert werden, was den Prozess der Methodenüberschreibung (override) oder Methodenüberschreibung nennt.
Im Beispiel wurden die Methoden getUrl und getTitle überschrieben:
function getUrl() {
echo $this->url . PHP_EOL;
return $this->url;
}
function getTitle(){
echo $this->title . PHP_EOL;
return $this->title;
}PHP erreicht die Zugriffssteuerung von Attributen oder Methoden, indem die Schlüsselwörter public (öffentlich), protected (geschützt) oder private (privat) vorangestellt werden.
public (öffentlich):Öffentliche Klasselemente können überall aufgerufen werden.
protected (geschützt):Geschützte Klasselemente können von sich selbst sowie von Unterklassen und Oberklassen aufgerufen werden.
private (privat):Private Klasselemente können nur von der Klasse, in der sie definiert sind, aufgerufen werden.
Klassische Attribute müssen als öffentlich, geschützt oder privat definiert werden. Wird var verwendet, wird es als öffentlich betrachtet.
<?php
/**
* Definiere MyClass
*/
class MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // Diese Zeile kann normal ausgeführt werden
echo $obj->protected; // Diese Zeile verursacht einen fatalen Fehler
echo $obj->private; // Diese Zeile verursacht auch einen tödlichen Fehler
$obj->printHello(); // Output Public, Protected und Private
/**
*Definiere MyClass2
*/
class MyClass2 extends MyClass
{
// Public und protected können neu definiert werden, aber nicht private.
protected $protected = 'Protected'2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // Diese Zeile kann normal ausgeführt werden
echo $obj2->private; // Undefined private
echo $obj2->protected; // Diese Zeile verursacht einen fatalen Fehler
$obj2->printHello(); // Ausgabe Public, Protected2 und Undefined
?>Methoden in der Klasse können als öffentlich, privat oder geschützt definiert werden. Wird kein solcher Schlüsselwort verwendet, ist die Methode standardmäßig öffentlich.
<?php
/**
* Definiere MyClass
*/
class MyClass
{
// Eine öffentliche Konstruktorfunktion wird deklariert
public function __construct() { }
// Eine öffentliche Methode wird deklariert
public function MyPublic() { }
// Eine geschützte Methode wird deklariert
protected function MyProtected() { }
// Eine private Methode wird deklariert
private function MyPrivate() { }
// Diese Methode ist öffentlich
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // Diese Zeile kann normal ausgeführt werden
$myclass->MyProtected(); // Diese Zeile verursacht einen fatalen Fehler
$myclass->MyPrivate(); // Diese Zeile verursacht einen fatalen Fehler
$myclass->Foo(); // Öffentliche, geschützte und private Methoden können aufgerufen werden
/**
* Definiere MyClass2
*/
class MyClass2 extends MyClass
{
// Diese Methode ist öffentlich
function Foo2();
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // Diese Zeile verursacht einen fatalen Fehler
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Diese Zeile kann normal ausgeführt werden
$myclass2->Foo2(); // Öffentliche und geschützte Methoden können aufgerufen werden, aber nicht private.
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublic\n";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>Mit dem Interface (interface) kann angegeben werden, welche Methoden eine Klasse implementieren muss, ohne die spezifischen Inhalte dieser Methoden zu definieren.
Eine Schnittstelle wird durch interface Mit Schlüsselwörtern definiert, genau wie eine Standardschnittstelle, aber alle Methoden sind leer definiert.
Alle in der Schnittstelle definierten Methoden müssen öffentlich sein, das ist eine Eigenschaft der Schnittstelle.
Um eine Schnittstelle zu implementieren, verwenden Sie implements Die Klasse muss alle in der Schnittstelle definierten Methoden implementieren,否则会引发一个致命错误。Klassen können mehrere Schnittstellen implementieren, die Namen der Schnittstellen werden durch Kommas getrennt.
<?php
// Eine 'iTemplate'-Schnittstelle deklarieren
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// Implementierung des Interfaces
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}Werte, die in der Klasse stets konstant bleiben, können als Konstanten definiert werden. Beim Definieren und Verwenden von Konstanten ist das Dollar-Symbol ($) nicht erforderlich.
Der Wert der Konstante muss ein festwert sein und darf keine Variable, Klassenattribute, Ergebnisse von mathematischen Operationen oder Funktionsaufrufe sein.
seit PHP 5.3.0 ab, kann eine Variable zur dynamischen Aufruf der Klasse verwendet werden. Der Wert der Variable darf jedoch keine Schlüsselwörter (wie self, parent oder static) sein.
<?php
class MyClass
{
const constant = '常量值';
function showConstant() {
echo self::constant . PHP_EOL;
}
}
echo MyClass::constant . PHP_EOL;
$classname = "MyClass";
echo $classname::constant . PHP_EOL; // von 5.3.0 beginnend
$class = new MyClass();
$class->showConstant();
echo $class::constant . PHP_EOL; // von PHP 5.3.0 beginnend
?>Jegliche Klasse, die mindestens eine Methode als abstrakt deklariert, muss selbst als abstrakt deklariert werden.
Klassen, die als abstrakt definiert sind, können nicht instantiiert werden.
Abstrakte Methoden definieren nur den Aufrufmodus (Parameter), nicht die spezifische Funktionalität.
Wenn eine Unterklasse eine abstrakte Klasse vererbt, muss sie alle abstrakten Methoden der Oberklasse definieren; außerdem müssen die Zugriffsrechte dieser Methoden mit denen in der Oberklasse übereinstimmen (oder dürfen weiter gelockert werden). Zum Beispiel, wenn eine abstrakte Methode als geschützt deklariert ist, dann sollte die im Unterklassen realisierte Methode ebenfalls als geschützt oder öffentlich deklariert werden und nicht als privat.
<?php
abstract class AbstractClass
{
// Es wird vorgeschrieben, dass die Unterklasse diese Methoden definiert
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// Regelmäßige Methoden (nicht abstrakte Methoden)
public function printOut() {
print $this->getValue() . PHP_EOL;
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
class ConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>Führt man den obigen Code aus, so ergibt sich als Ausgabe:
ConcreteClass1 FOO_ConcreteClass1 ConcreteClass2 FOO_ConcreteClass2
Darüber hinaus können Methoden der Unterklasse optionale Parameter enthalten, die in den abstrakten Methoden der Oberklasse nicht vorhanden sind.
Beispielsweise definiert eine Unterklasse einen optionalen Parameter, während die Deklaration des abstrakten Methods in der Oberklasse ihn nicht enthält, kann dies ebenfalls normal funktionieren.
<?php
abstract class AbstractClass
{
// Unsere abstrakte Methode muss nur die erforderlichen Parameter definieren
abstract protected function prefixName($name);
}
class ConcreteClass extends AbstractClass
{
// Unsere Unterklassen können optionale Parameter definieren, die in der Signatur der übergeordneten Klasse nicht existieren
public function prefixName($name, $separator = ".") {
if ($name == "Pacman") {
$prefix = "Mr";
} elseif ($name == "Pacwoman") {
$prefix = "Mrs";
} else {
$prefix = "";
}
return "{$prefix}{$separator} {$name}";
}
}
$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>Die Ausgabe ist:
Mr. Pacman Mrs. Pacwoman
Durch die Deklaration von Klassenattributen oder -methoden als static (statisch) kann auf die Klasse ohne Instanziierung zugegriffen werden.
Statische Attribute können nicht über ein bereits durch eine Klasse instanziertes Objekt aufgerufen werden (aber statische Methoden können).
Da statische Methoden ohne Objektaufruf aufgerufen werden können, ist der Pseudo-Variable $this in statischen Methoden nicht verfügbar.
Statische Attribute können nicht durch ein Objekt aufgerufen werden -> Operator, um darauf zuzugreifen.
seit PHP 5.3.0 ab, kann man eine Variable verwenden, um die Klasse dynamisch aufzurufen. Der Wert der Variable darf jedoch nicht die Schlüsselwörter self, parent oder static sein.
<?php
class Foo {
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
print Foo::$my_static . PHP_EOL;
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
?>Führen Sie den obigen Code aus, und das Ausgaberesultat ist:
foo foo
PHP 5 Wurde ein final-Schlüsselwort hinzugefügt. Wenn eine Methode in der übergeordneten Klasse als final deklariert wird, kann sie von der untergeordneten Klasse nicht überschrieben werden. Wenn eine Klasse als final deklariert wird, kann sie nicht vererbt werden.
Der folgende Code führt zu einem Fehler: }}
<?php
class BaseClass {
public function test() {
echo "BaseClass::test() called" . PHP_EOL;
}
final public function moreTesting() {
echo "BaseClass::moreTesting() called" . PHP_EOL;
}
}
class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called" . PHP_EOL;
}
}
// Fehlermeldung Fatal error: Cannot override final method BaseClass::moreTesting()
?>PHP ruft die Konstruktormethoden der Unterklassen nicht automatisch auf. Um die Konstruktormethoden der Oberklasse aufzurufen, müssen Sie dies in der Konstruktormethode der Unterklasse ausführen parent::__construct(); .
<?php
class BaseClass {
function __construct() {
print "BaseClass-Klasse - Konstruktormethode" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // Die Konstruktormethoden der Unterklassen können nicht automatisch die Konstruktormethoden der Oberklasse aufrufen
print "SubClass-Klasse - Konstruktormethode" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// Vererbung der Konstruktormethoden von BaseClass
}
// Aufruf der BaseClass-Konstruktormethode
$obj = new BaseClass();
// Aufruf der Konstruktormethoden von BaseClass und SubClass
$obj = new SubClass();
// Aufruf der BaseClass-Konstruktormethode
$obj = new OtherSubClass();
?>Führen Sie den obigen Code aus, und das Ausgaberesultat ist:
BaseClass-Klasse - Konstruktormethode BaseClass-Klasse - Konstruktormethode SubClass-Klasse - Konstruktormethode BaseClass-Klasse - Konstruktormethode