PHP orienté objet
En programmation orientée objet (anglais : Programmation orientée objet, abréviation : OOP), un objet est un tout composé d'informations et d'une description de la manière de traiter les informations, et est une abstraction du monde réel. La POO atteint trois objectifs du génie logiciel : la réutilisabilité, la flexibilité et l'extensibilité.
PHP a amélioré sa prise en charge de la POO après la version 4.0. Pour les petites applications, il peut être plus simple et plus efficace d'utiliser la programmation procédurale traditionnelle. Cependant, pour les applications volumineuses et complexes, la POO est un choix à considérer.
Classe
Une classe est une collection d'objets ayant les mêmes propriétés et services. Il fournit une description abstraite unifiée pour tous les objets appartenant à cette classe, qui comprend deux parties principales : les propriétés et les services. Dans les langages de programmation orientés objet, une classe est une unité de programme indépendante. Elle doit avoir un nom de classe et comprendre deux parties principales : la description d'attribut et la description de service.
Objet
Un objet est une entité utilisée pour décrire des choses objectives dans le système. C'est une unité de base qui constitue le système. Un objet est constitué d'un ensemble de propriétés et d'un ensemble de services qui opèrent sur l'ensemble de propriétés.
Dans le monde réel, les choses auxquelles nous sommes confrontés sont des objets, comme des ordinateurs, des téléviseurs, des vélos, etc.
Les trois principales caractéristiques de l'objet :
Le comportement de l'objet : quelles opérations peuvent être appliquées à l'objet, allumer et éteindre la lumière sont des comportements.
La forme de l'objet : comment l'objet réagit lorsque ces méthodes sont appliquées, couleur, taille, apparence.
Représentation des objets : La représentation des objets équivaut à une carte d'identité, distinguant spécifiquement les différences dans un même comportement et un même statut.
La relation entre les classes et les objets
La relation entre les classes et les objets est comme la relation entre les moules et les moulages. Le résultat de l'instanciation d'une classe est un objet, et l'abstraction d'un type de. l'objet est une classe.
Par exemple, Animal est une classe abstraite. Nous pouvons spécifier un chien et un mouton. Les chiens et les moutons sont des objets concrets. Ils ont des attributs de couleur, peuvent être écrits, peuvent courir et d'autres états comportementaux.
Contenu orienté objet
Classe − définit les caractéristiques abstraites d'une chose. La définition d'une classe inclut la forme des données et les opérations sur les données.
Object - est une instance d'une classe.
Variables membres - variables définies à l'intérieur de la classe. La valeur de cette variable est invisible pour le monde extérieur, mais est accessible via les fonctions membres. Une fois la classe instanciée en tant qu'objet, la variable peut être appelée un attribut de l'objet.
Fonction membre - est définie à l'intérieur de la classe et peut être utilisée pour accéder aux données de l'objet.
Héritage - L'héritage est un mécanisme permettant aux sous-classes de partager automatiquement les structures de données et les méthodes des classes parentes. Lors de la définition et de l'implémentation d'une classe, vous pouvez le faire sur la base d'une classe existante, prendre le contenu défini par la classe existante comme votre propre contenu et ajouter du nouveau contenu.
Classe parent - Une classe est héritée par d'autres classes. Cette classe peut être appelée une classe parent, une classe de base ou une super classe.
Sous-classe - Une classe qui hérite d'autres classes est appelée une sous-classe ou une classe dérivée.
Polymorphisme - Le polymorphisme signifie que la même opération, fonction ou processus peut être appliqué à plusieurs types d'objets et obtenir des résultats différents. Différents objets peuvent produire des résultats différents lorsqu'ils reçoivent le même message. Ce phénomène est appelé polymorphisme.
Surcharge - En termes simples, il s'agit d'une situation dans laquelle des fonctions ou des méthodes ont le même nom mais des listes de paramètres différentes. De telles fonctions ou méthodes avec le même nom et des paramètres différents sont appelées fonctions ou méthodes surchargées.
Abstraction - L'abstraction fait référence à l'abstraction d'objets avec des structures de données (attributs) et des comportements (opérations) cohérents en classes. Une classe est une abstraction qui reflète les propriétés importantes liées à une application tout en ignorant les autres contenus non pertinents. La division de toute classe est subjective, mais doit être liée à l'application spécifique.
Encapsulation - L'encapsulation fait référence à la liaison des propriétés et du comportement d'un objet qui existe dans le monde réel et à son placement dans une unité logique.
Constructeur - Principalement utilisé pour initialiser l'objet lors de la création de l'objet, c'est-à-dire attribuer des valeurs initiales aux variables membres de l'objet. Il est toujours utilisé avec l'opérateur new dans l'instruction pour créer l'objet.
Destructeur − Destructeur (destructeur) Contrairement au constructeur, lorsque l'objet termine son cycle de vie (par exemple, la fonction dans laquelle se trouve l'objet a été appelée), le système exécute automatiquement le destructeur. Les destructeurs sont souvent utilisés pour effectuer un travail de "nettoyage" (par exemple, lors de la création d'un objet, utilisez new pour ouvrir un espace mémoire, qui doit être libéré avec delete dans le destructeur avant de quitter).
Dans la figure ci-dessous, nous avons créé trois objets via la classe Car : Mercedes, Bmw et Audi.
$mercedes = nouvelle voiture ();
$bmw = nouvelle voiture ();
$audi = nouvelle voiture (); >
Syntaxe :
class class_name{
......}
La classe contient des attributs et méthodes.
En utilisant le mot clé var dans la définition de classe pour déclarer des variables, vous créez des attributs de la classe, également appelés attributs membres de la classe.
class class_name{
var $var_name;}
En déclarant la fonction dans la classe définition , c'est-à-dire que la méthode de la classe est créée.
Syntaxe :
class class_name{
function function_name(arg1,arg2,...)
{
Code de fonction
}
}
Une classe avec des attributs et des méthodes définis est une classe complète, et une logique de traitement complète peut être incluse dans une classe. Utilisez le nouveau mot-clé pour instancier un objet afin d'appliquer la logique au sein de la classe. Plusieurs objets peuvent être instanciés simultanément.
Syntaxe :
object = new class_name();
Après avoir instancié un objet, utilisez l'opérateur -> Propriétés et méthodes de l'objet.
Syntaxe :
object->var_name;
object->function_name;
Si vous souhaitez accéder aux membres dans le défini class Pour les attributs ou les méthodes, vous pouvez utiliser la pseudo variable $this. $this est utilisé pour représenter l'objet actuel ou l'objet lui-même.
<?php
class Person {
//人的成员属性
var $name; //人的名字
var $age; //人的年龄
//人的成员 say() 方法
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age;
}
} //类定义结束
//实例化一个对象
$p1 = new Person();
//给 $p1 对象属性赋值
$p1->name = "张三";
$p1->age = 20;
//调用对象中的 say()方法
$p1->say();
?>Exécutez cet exemple, obtenez :
Je m'appelle : Zhang San
Mon âge est : 20
Exemple
<?php
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
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;
}
}
$php = new Site;
$taobao = new Site;
$google = new Site;
// 调用成员函数，设置标题和URL
$php->setTitle( "php中文网" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );
$php->setUrl( 'm.sbmmt.com' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Exécuter l'instance»
Exécutez le code ci-dessus, le résultat de sortie est :
site Web chinois php
Taobao
Recherche Google
m.sbmmt.com
www.taobao.com
www.google.com
Constructeur PHP
Constructor est une méthode spéciale. Il est principalement utilisé pour initialiser l'objet lors de la création de l'objet, c'est-à-dire pour attribuer des valeurs initiales aux variables membres de l'objet. Il est toujours utilisé avec l'opérateur new dans l'instruction pour créer l'objet. Lors de l'utilisation de l'opérateur new pour créer une instance d'une classe, le constructeur sera appelé automatiquement et son nom doit être __construct()
Un seul constructeur peut être déclaré dans une classe, et seulement lorsqu'un objet est créé à chaque fois La méthode constructeur sera appelée une fois à chaque fois. Cette méthode ne peut pas être appelée activement, elle est donc généralement utilisée pour effectuer certaines tâches d'initialisation utiles. Cette méthode n'a aucune valeur de retour.
Syntaxe :
fonction __construct(arg1,arg2,...)
{
...
}
Dans l'exemple ci-dessus, nous pouvons initialiser les variables $url et $title via la méthode constructeur :
<?php
function __construct( $ par1, $par2 ) {
$this->url = $par1
$this->title = $par2;
?>
<?php
$php = new Site('m.sbmmt.com', 'php中文网');
$taobao = new Site('www.taobao.com', '淘宝');
$google = new Site('www.google.com', 'Google 搜索');
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Exécuter l'instance»Destructeur
La méthode destructeur correspond à la méthode constructeur. La méthode destructeur vous permet d'effectuer certaines opérations ou de compléter certaines fonctions avant de détruire une classe, comme la fermeture de fichiers, la publication d'ensembles de résultats, etc. Le destructeur ne peut prendre aucun paramètre et son nom doit être __destruct() . PHP 5 a introduit le concept de destructeur, qui est similaire à d'autres langages orientés objet. Son format de syntaxe est le suivant :function __destruct() { <🎜. > ......
}
Instance
<?php
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "销毁 " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>Exécutez le code ci-dessus, le résultat de sortie est :
Constructeur
Destroy MyDestructableClass
Le constructeur et le destructeur sont utilisés simultanément
<?php
class Person {
var $name;
var $age;
//定义一个构造方法初始化赋值
function __construct($name,$age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age." <br >";;
}
function __destruct()
{
echo "再见".$this->name;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>pour exécuter le code ci-dessus, le résultat de sortie est :
Je m'appelle : Zhang San
Mon âge est : 20 ans
Au revoir Zhang San
Hérité
L'héritage de classe PHP fait référence à créer une nouvelle classe dérivée qui hérite des données et des méthodes d'une ou plusieurs classes précédemment définies, et peut redéfinir ou ajouter de nouvelles données et méthodes, établissant ainsi une hiérarchie ou une hiérarchie de classes.
Nous appelons la classe existante utilisée pour dériver la nouvelle classe comme classe parent, et la nouvelle classe dérivée de la classe existante est appelée la sous-classe. L'héritage est l'une des trois caractéristiques majeures de l'orientation objet.
Grâce au mécanisme d'héritage, les types de données existants peuvent être utilisés pour définir de nouveaux types de données. Le nouveau type de données défini contient non seulement les membres nouvellement définis, mais également les anciens membres.
Remarque : contrairement aux langages tels que Java, en PHP, une classe ne peut hériter directement des données d'une seule classe, c'est-à-dire un héritage unique.
Utilisez le mot-clé extends pour définir l'héritage de classe :
class subclass extends parent class {
}
Instance
La classe Child_Site de l'instance hérite de la classe Site et étend les fonctions :
<?php
// 子类扩展站点类别
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . PHP_EOL;
}
}
?>Réécriture de méthode
Si la méthode héritée de la classe parent ne peut pas satisfaire aux exigences de la sous-classe Il peut être réécrit selon les besoins. Ce processus est appelé remplacement de méthode, également appelé réécriture de méthode.
Les méthodes getUrl et getTitle sont réécrites dans l'instance :
function getUrl() {
echo $this->url . - >url;
}
function getTitle(){
echo $this->title
return $this->title; >
Contrôle d'accès et encapsulation
Ceci est réalisé en PHP en ajoutant le modificateur d'accès public, protected ou private devant Contrôle d'accès aux propriétés ou aux méthodes. Les modificateurs d'accès de type
Astuce : Lorsqu'une sous-classe remplace une méthode de la classe parent, les droits d'accès de la méthode dans la sous-classe ne peuvent pas être inférieurs à les droits d'accès de la méthode surchargée de la classe parent.
Contrôle d'accès des attributs Les attributs de classe doivent être définis comme étant publics, protégés et privés. S'il est défini avec var, il est considéré comme public.
<?php
/**
* Define 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; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 可以对 public 和 protected 进行重定义，但 private 而不能
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
?>Contrôle d'accès aux méthodesLes méthodes d'une classe peuvent être définies comme publiques, privées ou protégées. Si ces mots-clés ne sont pas définis, la méthode est par défaut publique. <?php
/**
* Define MyClass
*/
class MyClass
{
// 声明一个公有的构造函数
public function __construct() { }
// 声明一个公有的方法
public function MyPublic() { }
// 声明一个受保护的方法
protected function MyProtected() { }
// 声明一个私有的方法
private function MyPrivate() { }
// 此方法为公有
function Foo() {
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 此方法为公有
function Foo2()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // 这行会产生一个致命错误
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行
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
?>EncapsulationL'encapsulation consiste à combiner les attributs et services d'une classe (objet) en une unité indépendante, et à masquer autant que possible les détails internes, en ne conservant que les interfaces nécessaires pour communiquer avec l'extérieur. Cette fonctionnalité d'encapsulation garantit efficacement l'indépendance des objets, permet la localisation des erreurs logicielles et réduit considérablement la difficulté de vérification des erreurs et de dépannage. Utilisez le mot-clé privé pour encapsuler les propriétés et les méthodes : <?php
class Person {
//将成员属性定义为 private
private $name;
private $age;
//定义一个构造方法初始化赋值
function __construct($name, $age) {
$this->name=$name;
$this->age=$age;
}
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age;
}
}
$p1=new Person("张三", 20);
$p1->say();
?>Interface
Les classes PHP sont à héritage unique, c'est-à-dire qu'elles ne sont pas prises en charge héritage multiple. Lorsqu'une classe nécessite les fonctions de plusieurs classes, l'héritage est impuissant. Pour cette raison, PHP introduit la technologie d'interface de classe.
Si toutes les méthodes d'une classe abstraite sont des méthodes abstraites et qu'aucune variable n'est déclarée et que tous les membres de l'interface ont des autorisations publiques, alors cette classe abstraite spéciale est appelée une interface.
À l'aide d'une interface, vous pouvez spécifier quelles méthodes une classe doit implémenter, mais vous n'avez pas besoin de définir le contenu spécifique de ces méthodes.
L'interface est définie via le mot-clé interface, tout comme la définition d'une classe standard, mais toutes les méthodes qui y sont définies sont vides. Toutes les méthodes définies dans l'interface doivent être publiques. C'est une caractéristique de l'interface.
<?php
//定义接口
interface User{
function getDiscount();
function getUserType();
}
//VIP用户 接口实现
class VipUser implements User{
// VIP 用户折扣系数
private $discount = 0.8;
function getDiscount() {
return $this->discount;
}
function getUserType() {
return "VIP用户";
}
}
class Goods{
var $price = 100;
var $vc;
//定义 User 接口类型参数，这时并不知道是什么用户
function run(User $vc){
$this->vc = $vc;
$discount = $this->vc->getDiscount();
$usertype = $this->vc->getUserType();
echo $usertype."商品价格：".$this->price*$discount;
}
}
$display = new Goods();
$display ->run(new VipUser);//可以是更多其他用户类型
?>Résultat :Prix du produit utilisateur VIP : 80 yuansPHP peut également implémenter plusieurs interfaces en même temps lors de l'héritage d'une classe :
la sous-classe de classe étend l'interface d'implémentation de la classe parent 1, l'interface 2, ...
{
......
}
La différence entre les classes abstraites et les interfaces
Les interfaces sont des classes abstraites spéciales et peuvent également être considérées comme la spécification d'un modèle. La différence générale entre une interface et une classe abstraite est la suivante :
Si une sous-classe implémente une interface, elle doit implémenter toutes les méthodes de l'interface (qu'elles soient nécessaires ou non) ; il suffit de mettre en œuvre les méthodes requises.
Si le nom de la méthode défini dans une interface change, alors toutes les sous-classes qui implémentent cette interface doivent mettre à jour le nom de la méthode de manière synchrone et si le nom de la méthode dans une classe abstraite change, le nom de la méthode correspondante de sa sous-classe le sera ; ne soit pas affecté. L'impact est simplement qu'il devient une nouvelle méthode (mise en œuvre par rapport à l'ancienne méthode).
Les classes abstraites ne peuvent être héritées que individuellement. Lorsqu'une sous-classe doit implémenter des fonctions qui doivent être héritées de plusieurs classes parents, des interfaces doivent être utilisées.
Constante
Définissez des constantes dans une classe en utilisant le mot-clé const au lieu de la fonction définie() habituelle.
Vous pouvez définir des valeurs qui restent inchangées dans une classe comme constantes. Il n'est pas nécessaire d'utiliser le symbole $ lors de la définition et de l'utilisation de constantes.
La valeur d'une constante doit être une valeur fixe et ne peut pas être une variable, un attribut de classe, le résultat d'une opération mathématique ou un appel de fonction.
Depuis PHP 5.3.0, vous pouvez utiliser une variable pour appeler dynamiquement une classe. Mais la valeur de cette variable ne peut pas être un mot-clé (comme self, parent ou static).
Syntaxe
const constant = "value";
Exemple :
<?php
Class Person{
// 定义常量
const country = "中国";
public function myCountry() {
//内部访问常量
echo "我是".self::country."人 <br >";
}
}
// 输出常量
echo Person::country." <br >";
// 访问方法
$p1 = new Person();
$p1 -> myCountry();
?>Exécuter la sortie :
Chine
Je suis Chinois
Classe abstraite
Toute classe, si au moins une méthode qu'elle contient est déclarée comme abstraite, alors cette classe doit être déclarée comme abstraite.
Une classe définie comme abstraite ne peut pas être instanciée.
Une méthode définie comme abstraite déclare uniquement sa méthode appelante (paramètres) et ne peut pas définir son implémentation de fonction spécifique.
Lors de l'héritage d'une classe abstraite, la sous-classe doit définir toutes les méthodes abstraites dans la classe parent ; de plus, le contrôle d'accès de ces méthodes doit être le même (ou plus détendu) que dans la classe parent. Par exemple, si une méthode abstraite est déclarée comme protégée, alors la méthode implémentée dans la sous-classe doit être déclarée comme protégée ou publique et ne peut pas être définie comme privée. De plus, les méthodes d'appel doivent correspondre, c'est-à-dire que le type et le nombre de paramètres requis doivent être cohérents. Par exemple, si une sous-classe définit un paramètre facultatif qui n'est pas inclus dans la déclaration d'une méthode abstraite de la classe parent, il n'y a pas de conflit entre les deux déclarations.
<?php
abstract class AbstractClass
{
// 强制要求子类定义这些方法
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// 普通方法（非抽象方法）
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;
?>exécute le code ci-dessus et le résultat de sortie est :
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Mot-clé statique
instruction Si un attribut ou une méthode de classe est statique, il est accessible directement sans instancier la classe.
Les propriétés statiques ne sont pas accessibles via un objet d'une classe qui a été instanciée (mais les méthodes statiques le peuvent).
Étant donné que les méthodes statiques ne nécessitent pas l'appel d'un objet, la pseudo variable $this n'est pas disponible dans les méthodes statiques.
Les propriétés statiques ne sont pas accessibles aux objets via l'opérateur ->
Depuis PHP 5.3.0, vous pouvez utiliser une variable pour appeler dynamiquement une classe. Mais la valeur de cette variable ne peut pas être les mots-clés self, parent ou static.
<?php
Class Person{
// 定义静态成员属性
public static $country = "中国";
// 定义静态成员方法
public static function myCountry() {
// 内部访问静态成员属性
echo "我是".self::$country."人<br >";
}
}
class Student extends Person {
function study() {
echo "我是". parent::$country."人<br >";
}
}
// 输出成员属性值
echo Person::$country."<br >";// 输出：中国
$p1 = new Person();
//echo $p1->country;// 错误写法
// 访问静态成员方法
Person::myCountry();// 输出：我是中国人
// 静态方法也可通过对象访问：
$p1->myCountry();
// 子类中输出成员属性值
echo Student::$country."<br >";// 输出：中国
$t1 = new Student();
$t1->study();// 输出：我是中国人
?>Exécuter la sortie :
Chine
Je suis chinois
Je suis chinois
Chine
Je suis chinois
Mots clés finaux
PHP 5 ajoute un nouveau mot-clé final. Si une méthode de la classe parent est déclarée finale, la classe enfant ne peut pas remplacer la méthode. Si une classe est déclarée finale, elle ne peut pas être héritée.
Personne de classe finale
{
...... <?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;
}
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>
Appeler le constructeur de la classe parent
<?php
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>Exécutez le programme ci-dessus, le résultat de sortie est : Méthode de construction dans la classe BaseClass Méthode de construction dans la classe BaseClass
Méthode de construction dans la classe SubClass
Méthode de construction dans Classe BaseClass
![Projet front-end-Shangyou [Pratique complète de la technologie HTML/CSS/JS]](https://img.php.cn/upload/course/000/000/068/63bfcb2974f91471.jpg)
![Cours frontal base zéro [Vue apprentissage avancé et application pratique]](https://img.php.cn/upload/course/000/000/068/63bbd15353895588.jpg)
![Tutoriel WEB front-end [HTML5+CSS3+JS]](https://img.php.cn/upload/course/000/000/068/63ba60c8da520536.jpg)
![Application pratique Apipost [api, interface, tests automatisés, mock]](https://img.php.cn/upload/course/000/000/068/63b3c967a20f4861.jpg)
