PHP 面向对象程序设计(oop)学习笔记(一)
面向对象程序设计(OOP)是一种计算机编程架构。OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要
1、PHP中的抽象类
PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类,如果它里面至少有一个方法是被声明为抽象的,那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式(参数),不能定义其具体的功能实现。在类的声明中使用 abstract 修饰符可以将某个类声明为抽象的。
可以这样理解,抽象类作为一个基类,它把特定的细节留给继承者来实现。通过抽象概念,可以在开发项目中创建扩展性很好的架构。
复制代码 代码如下:
abstract class AbstractClass
{
code...
}
1.1、抽象方法
使用 abstract 关键字定义抽象方法。抽象方法只保留方法原型(方法的定义中剔除了方法体之后的签名),它包括存取级别、函数关键字、函数名称和参数。他不包含({})或者括号内部的任何代码。例如下面的代码就是一个抽象方法定义:
复制代码 代码如下:
abstract public function prototypeName($protoParam);
继承一个抽象类的时候,子类必须定义父类中的所有抽象方法;另外,这些方法的访问控制必须和父类中一样(或者更为宽松)。此外方法的调用方式必须匹配,即类型和所需参数数量必须一致。
1.2、关于抽象类
某个类只要包含至少一个抽象方法就必须声明为抽象类
声明为抽象的方法,在实现的时候必须包含相同的或者更低的访问级别。
不能使用 new 关键字创建抽象类的实例。
被声明为抽象的方法不能包含函数体。
如果将扩展的类也声明为抽象类,在扩展抽象类时,可以不用实现所有的抽象方法。(如果某个类从抽象类继承,当它没有实现基类中所声明的所有抽象方法时,它就必须也被声明为抽象的。)
1.3、使用抽象类
复制代码 代码如下:
abstract class Car
{
abstract function getMaxSpeend();
}
class Roadster extends Car
{
public $Speend;
public function SetSpeend($speend = 0)
{
$this->Speend = $speend;
}
public function getMaxSpeend()
{
return $this->Speend;
}
}
class Street
{
public $Cars ;
public $SpeendLimit ;
function __construct( $speendLimit = 200)
{
$this -> SpeendLimit = $speendLimit;
$this -> Cars = array();
}
protected function IsStreetLegal($car)
{
if ($car->getMaxSpeend() SpeendLimit)
{
return true;
}
else
{
return false;
}
}
public function AddCar($car)
{
if($this->IsStreetLegal($car))
{
echo 'The Car was allowed on the road.';
$this->Cars[] = $car;
}
else
{
echo 'The Car is too fast and was not allowed on the road.';
}
}
}
$Porsche911 = new Roadster();
$Porsche911->SetSpeend(340);
$FuWaiStreet = new Street(80);
$FuWaiStreet->AddCar($Porsche911);
/**
*
* @result
*
* The Car is too fast and was not allowed on the road.[Finished in 0.1s]
*
*/
?>
2.对象接口
使用接口(interface),,可以指定某个类必须实现哪些方法,但不需要定义这些方法的具体内容。
接口是通过 interface 关键字来定义的,就像定义一个标准的类一样,但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是公有,这是接口的特性。
接口是一种类似于类的结构,可用于声明实现类所必须声明的方法。例如,接口通常用来声明API,而不用定义如何实现这个API。
大多数开发人员选择在接口名称前加上大写字母I作为前缀,以便在代码和生成的文档中将其与类区别开来。
2.1接口实现(implements)
要实现一个接口,使用 implements 操作符(继承抽象类需要使用 extends 关键字不同),类中必须实现接口中定义的所有方法,否则会报一个致命错误。类可以实现多个接口,用逗号来分隔多个接口的名称。
实现多个接口时,接口中的方法不能有重名。
接口也可以继承,通过使用 extends 操作符。
类要实现接口,必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。
接口中也可以定义常量。接口常量和类常量的使用完全相同,但是不能被子类或子接口所覆盖。
2.2使用接口的案例
复制代码 代码如下:

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Golang hat keine abstrakten Klassen. Golang ist keine objektorientierte (OOP) Sprache. Es gibt keine Konzepte für Klassen, Vererbung und abstrakte Klassen. Es gibt jedoch Strukturen (Strukturen) und Schnittstellen (Schnittstellen), die indirekt durch die Kombination von implementiert werden können Struktur und Schnittstelle. Abstrakte Klassen in Objektsprachen.

Die Funktion von „instanceof“ besteht darin, zu bestimmen, ob ein Objekt eine Instanz einer bestimmten Klasse ist oder ob es eine Schnittstelle implementiert. Instanz von ist ein Operator, mit dem überprüft wird, ob ein Objekt von einem bestimmten Typ ist. Verwendungsszenarien des Instanzoperators: 1. Typprüfung: Kann verwendet werden, um den spezifischen Typ eines Objekts zu bestimmen, um je nach Typ unterschiedliche Logik auszuführen. 2. Schnittstellenbeurteilung: Kann verwendet werden, um festzustellen, ob ein Objekt eine Schnittstelle implementiert , um zu bestimmen, ob ein Objekt eine Schnittstelle implementiert. 3. Abwärtstransformation usw.

Java ermöglicht die Definition innerer Klassen innerhalb von Schnittstellen und abstrakten Klassen und bietet so Flexibilität für die Wiederverwendung und Modularisierung von Code. Innere Klassen in Schnittstellen können spezifische Funktionen implementieren, während innere Klassen in abstrakten Klassen allgemeine Funktionen definieren können und Unterklassen konkrete Implementierungen bereitstellen.

Schnittstellen und abstrakte Klassen werden in Entwurfsmustern zur Entkopplung und Erweiterbarkeit verwendet. Schnittstellen definieren Methodensignaturen, abstrakte Klassen stellen eine teilweise Implementierung bereit und Unterklassen müssen nicht implementierte Methoden implementieren. Im Strategiemuster wird die Schnittstelle zum Definieren des Algorithmus verwendet, und die abstrakte Klasse oder konkrete Klasse stellt die Implementierung bereit, wodurch ein dynamischer Wechsel von Algorithmen ermöglicht wird. Im Beobachtermuster werden Schnittstellen zum Definieren des Beobachterverhaltens verwendet, und abstrakte oder konkrete Klassen werden zum Abonnieren und Veröffentlichen von Benachrichtigungen verwendet. Im Adaptermuster werden Schnittstellen verwendet, um vorhandene Klassen anzupassen, oder konkrete Klassen können kompatible Schnittstellen implementieren und so eine Interaktion mit Originalcode ermöglichen.

Interface Interface definiert abstrakte Methoden und Konstanten in Java. Die Methoden in der Schnittstelle sind nicht implementiert, sondern werden von der Klasse bereitgestellt, die die Schnittstelle implementiert. Die Schnittstelle definiert einen Vertrag, der erfordert, dass die Implementierungsklasse bestimmte Methodenimplementierungen bereitstellt. Deklarieren Sie die Schnittstelle: publicinterfaceExampleInterface{voiddoSomething();intgetSomething();} Abstrakte Klasse Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann. Es enthält eine Mischung aus abstrakten und nicht-abstrakten Methoden. Ähnlich wie Schnittstellen werden abstrakte Methoden in abstrakten Klassen durch Unterklassen implementiert. Abstrakte Klassen können jedoch auch konkrete Methoden enthalten, die Standardimplementierungen bereitstellen. Deklarieren Sie die abstrakte Klasse: publicabstractcl

Für die Wiederverwendbarkeit von Code werden sowohl funktionale Schnittstellen als auch abstrakte Klassen verwendet, sie werden jedoch auf unterschiedliche Weise implementiert: funktionale Schnittstellen durch Referenzfunktionen, abstrakte Klassen durch Vererbung. Funktionale Schnittstellen können nicht instanziiert werden, abstrakte Klassen jedoch schon. Funktionale Schnittstellen müssen alle deklarierten Methoden implementieren, während abstrakte Klassen nur einige Methoden implementieren können.

Schnittstellen und abstrakte Klassen werden verwendet, um erweiterbaren PHP-Code zu erstellen, und es gibt den folgenden Hauptunterschied zwischen ihnen: Schnittstellen erzwingen durch Implementierung, während abstrakte Klassen durch Vererbung erzwungen werden. Schnittstellen können keine konkreten Methoden enthalten, abstrakte Klassen hingegen schon. Eine Klasse kann mehrere Schnittstellen implementieren, aber nur von einer abstrakten Klasse erben. Schnittstellen können nicht instanziiert werden, abstrakte Klassen jedoch schon.

Schnittstelle: Eine implementierte Vertragsschnittstelle definiert eine Reihe von Methodensignaturen in Java, stellt jedoch keine konkrete Implementierung bereit. Es fungiert als Vertrag, der Klassen, die die Schnittstelle implementieren, dazu zwingt, ihre angegebenen Methoden zu implementieren. Die Methoden in der Schnittstelle sind abstrakte Methoden und haben keinen Methodenkörper. Codebeispiel: publicinterfaceAnimal{voideat();voidsleep();} Abstrakte Klasse: Teilweise implementierter Entwurf Eine abstrakte Klasse ist eine übergeordnete Klasse, die eine teilweise Implementierung bereitstellt, die von ihren Unterklassen geerbt werden kann. Im Gegensatz zu Schnittstellen können abstrakte Klassen konkrete Implementierungen und abstrakte Methoden enthalten. Abstrakte Methoden werden mit dem Schlüsselwort abstract deklariert und müssen von Unterklassen überschrieben werden. Codebeispiel: publicabstractcla
