Introduction aux connaissances orientées objet pour les entretiens PHP

Le contenu de cet article est une introduction aux connaissances orientées objet sur les entretiens PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Les points de connaissances orientés objet courants dans les examens PHP comprennent les 7 points suivants. Je vais présenter les points suivants en détail pour vous aider à mieux gérer les points de connaissances orientés objet courants dans les entretiens PHP.

Recommandations associées : "Résumé des questions d'entretien PHP 2019 (collection) "

Les modules de contenu impliqués dans la structure de l'ensemble de l'article orienté objet sont :

1. Quelle est la différence entre orienté objet et orienté processus ?
2. Quelles sont les caractéristiques de l’orienté objet ?
3. Que sont les constructeurs et les destructeurs ?
4. Quelles sont les portées orientées objet ?
5. Quelles sont les méthodes magiques en PHP ?
6. Qu'est-ce que le clonage d'objets ?
7. Quelle est la différence entre cela, soi et parent ?
8. Quelles sont les différences et les connexions entre les classes abstraites et les interfaces ?
9. Explication des questions d'entretien PHP orientées objet courantes

Le contenu sur PHP orienté objet sera divisé en trois articles pour expliquer le contenu complet. explique principalement le contenu de un à quatre points, le deuxième article explique principalement le contenu de cinq à huit points et le troisième article se concentre sur le neuvième point.

Le contenu du texte suivant provient du livre "PHP Programmer Interview Written Test Guide" Si vous réimprimez, veuillez conserver la source :

1. Orienté objet et orienté processus Quelle est la différence ?

L'orientation objet est aujourd'hui l'une des méthodes courantes de développement de logiciels. Elle rassemble les données et les opérations sur les données dans un tout interdépendant, c'est-à-dire un objet. Résumez les caractéristiques communes d'objets similaires, c'est-à-dire de classes. La plupart des données d'une classe ne peuvent être traitées que par les méthodes de cette classe. La classe se connecte au monde extérieur via une simple interface externe et les objets communiquent via des messages. Le déroulement du programme est déterminé par l'utilisateur lors de son utilisation. Par exemple, d'un point de vue abstrait, les êtres humains ont des noms spéciaux tels que la taille, le poids, l'âge, le groupe sanguin, etc. Les êtres humains peuvent travailler, marcher debout, manger et utiliser leur propre esprit pour créer des outils. une abstraction. C'est une entité inexistante, mais tous les objets ayant les attributs et les méthodes du groupe humain sont appelés personnes. Cet objet personne est une entité qui existe réellement, et tout le monde est un objet du groupe humain.
Orienté processus est une méthode de développement centrée sur les événements, ce qui signifie une exécution séquentielle descendante et un raffinement progressif. Sa structure de programme est divisée en plusieurs modules de base selon les fonctions, et ces modules forment une structure arborescente. Le module est relativement simple et relativement indépendant dans sa fonction.Chaque module est généralement composé de trois structures de base : séquence, sélection et boucle. La méthode spécifique de mise en œuvre modulaire consiste à utiliser des sous-programmes, et le déroulement du programme est décidé lors de l'écriture du programme. Par exemple, dans le backgammon, l'idée de conception orientée processus consiste à analyser d'abord les étapes du problème : la première étape, démarrer le jeu ; la deuxième étape, la pierre noire bouge en premier ; la troisième étape, dessiner l'image ; étape, jugez le gagnant ou perdez ; la cinquième étape, c'est le tour des Blancs ; Étape 6, dessinez l'image ; déterminez le gagnant ou perdez ; Étape 8, revenez à l'étape 2, affichez le résultat final ; La mise en œuvre de chacune des étapes ci-dessus avec des fonctions distinctes est une méthode de développement orientée processus.

Plus précisément, les deux diffèrent principalement sur les aspects suivants.
1) Les points de départ sont différents. L'orientation objet consiste à utiliser des méthodes de pensée conventionnelles pour traiter les problèmes du monde objectif, en mettant l'accent sur la cartographie directe des points clés du domaine du problème avec les objets et les interfaces entre les objets. Ce n’est pas le cas de la méthode orientée processus. Elle met l’accent sur l’abstraction et la modularisation du processus. Elle construit ou traite des problèmes objectifs du monde avec le processus comme centre.
2) Les relations logiques hiérarchiques sont différentes. La méthode orientée objet utilise la logique informatique pour simuler l'existence physique dans le monde objectif, en utilisant la classe de collection d'objets comme unité de base pour le traitement des problèmes, et rend le monde informatique aussi proche que possible du monde objectif afin que Pour rendre le traitement du problème plus clair, la méthode orientée objet utilise la hiérarchie des classes pour refléter l'héritage et le développement entre les classes. L'unité de base de la méthode orientée processus pour traiter les problèmes est un module qui peut exprimer clairement et précisément le processus. La structure hiérarchique du module est utilisée pour résumer les relations et les fonctions entre les modules ou les modules, ainsi que les problèmes dans le monde objectif. sont résumés dans des processus qui peuvent être traités par des ordinateurs.
3) La méthode de traitement des données est différente de la méthode du programme de contrôle. La méthode orientée objet encapsule les données et le code correspondant dans un tout. En principe, les autres objets ne peuvent pas modifier directement leurs données, c'est-à-dire que la modification de l'objet ne peut être complétée que par ses propres fonctions membres. Le programme est "piloté par les événements" pour activer et exécuter le programme. La méthode orientée processus traite les données directement via le programme et les résultats du traitement peuvent être affichés une fois le traitement terminé. Dans la méthode du programme de contrôle, le programme est appelé ou renvoyé selon la conception et ne peut pas être parcouru librement. contrôles, contrôlés et appels entre chaque module avec appel.
4) Les méthodes de conception d'analyse et de conversion de codage sont différentes. La méthode orientée objet est un processus fluide tout au long du cycle de vie du logiciel entre l'analyse, la conception et le codage, de l'analyse à la conception en passant par le codage, une représentation de modèle cohérente est utilisée, c'est-à-dire qu'une connexion transparente est obtenue. La méthode orientée processus met l'accent sur la transformation entre l'analyse, la conception et le codage selon des règles, et réalise une connexion transparente entre l'analyse, la conception et le codage tout au long du cycle de vie du logiciel.

2. Quelles sont les caractéristiques de l'orienté objet ?

Les principales caractéristiques de l'orientation objet sont l'abstraction, l'héritage, l'encapsulation et le polymorphisme.

1) Abstraction. L'abstraction est le processus consistant à ignorer les aspects d'un sujet qui ne sont pas pertinents pour l'objectif actuel afin d'accorder plus d'attention aux aspects qui sont pertinents pour l'objectif actuel. L’abstraction n’a pas pour objectif de comprendre l’ensemble du problème, mais n’en sélectionne qu’une partie et laisse pour l’instant de côté certains détails. L'abstraction comprend deux aspects, l'un est l'abstraction des processus et l'autre est l'abstraction des données.

2) Héritage. L'héritage est un modèle hiérarchique qui relie les classes et permet et encourage la réutilisation des classes. Il fournit un moyen d'exprimer clairement les points communs. Une nouvelle classe d'un objet peut être dérivée d'une classe existante, un processus appelé héritage de classe. La nouvelle classe hérite des caractéristiques de la classe d'origine. La nouvelle classe est appelée classe dérivée (sous-classe) de la classe d'origine et la classe d'origine est appelée classe de base (classe parent) de la nouvelle classe. Une classe dérivée peut hériter des méthodes et des variables d'instance de sa classe de base, et les sous-classes peuvent modifier ou ajouter de nouvelles méthodes pour mieux répondre à des besoins particuliers.
3) Encapsulation. L'encapsulation fait référence à l'abstraction d'éléments objectifs en classes, et chaque classe protège ses propres données et méthodes. Les classes peuvent autoriser uniquement des classes ou des objets de confiance à exploiter leurs données et méthodes et masquer les informations non fiables.
4) Polymorphisme. Le polymorphisme fait référence au fait de permettre à des objets de différentes classes de répondre au même message. Le polymorphisme comprend le polymorphisme paramétré et le polymorphisme contenu. Les langages polymorphes présentent les avantages de la flexibilité, de l'abstraction, du partage de comportement et du partage de code, et peuvent bien résoudre le problème des fonctions d'application du même nom.

3. Que sont les constructeurs et les destructeurs ?

1. Constructeur

Dans les versions antérieures à PHP5, le nom du constructeur doit être le même que le nom de la classe À partir de PHP5, les développeurs peuvent définir une méthode nommée __construct comme constructeur. La fonction du constructeur doit être automatiquement appelée lorsque la classe est instanciée, le constructeur est donc principalement utilisé pour effectuer un travail d'initialisation. L'un des avantages de l'utilisation de __construct comme nom du constructeur est que lorsque le nom de la classe est modifié, le nom du constructeur n'a pas besoin d'être modifié. Sa forme de déclaration est
void __construct ([ Mixed $args [, $... ]] )

En langage C++, le constructeur de la sous-classe appellera implicitement la fonction sans paramètre de la classe parent constructeur. Cependant, en PHP, le constructeur d'une sous-classe n'appellera pas implicitement le constructeur de la classe parent. Les développeurs doivent appeler explicitement le constructeur de la classe parent via parent::__construct(). Lorsqu'une sous-classe ne définit pas de constructeur, elle héritera du constructeur de la classe parent, mais le principe est que le constructeur de la classe parent ne peut pas être défini comme privé. L'exemple d'utilisation est le suivant :

<?php    
    class BaseClass {
        function __construct() {
            print "Base constructor\n";
        }
    }
    class SubClass extends BaseClass {
        function __construct() {
            parent::__construct();
            print "Sub constructor\n";
        }
    }
    // 会调用父类构造函数
    $obj = new BaseClass();
    //调用子类构造函数，子类构造函数会去调用父类构造函数
    $obj = new SubClass();
?>

Le résultat d'exécution du programme est

Base constructor
Base constructor
Sub constructor

从上面的讲解中可以发现，从PHP5开始多了一种构造函数定义的方法。为了实现不同版本PHP代码的兼容，在PHP5的类中找不到 __construct() 函数并且也没有从父类继承一个的话，那么它就会尝试寻找旧式的构造函数（与类同名的函数）。这种兼容的方法存在一个风险：在PHP5之前的版本中开发的类中已有一个名为 __construct() 的方法却被用于其他用途时，PHP5的类会认为这是一个构造函数，从而当类实例化时自动执行这个方法。
从 PHP 5.3.3 开始，在命名空间中，与类名同名的方法不再作为构造函数。这一改变不影响不在命名空间中的类。

2．析构函数

析构函数是在PHP5引入的，它的作用与调用时机和构造函数刚好相反，它在对象被销毁时自动执行。析构函数__destruct()结构形式如下：

function __destruct(){
    /* 类的初始化代码*/
}

需要注意的是，析构函数是由系统自动调用的，因此，它不需要参数。
默认情况下，系统仅释放对象属性所占用的内存，并不销毁在对象内部申请的资源（例如，打开文件、创建数据库的连接等），而利用析构函数在使用一个对象之后执行代码来清除这些在对象内部申请的资源（关闭文件、断开与数据库的连接）。
与构造函数类似，如果想在子类中调用父类的析构函数，那么需要显式地调用：parent::__destruct()。如果子类没有定义析构函数，那么它会继承父类的析构函数。
当对象不再被引用时，将调用析构函数。如果要明确地销毁一个对象，那么可以给指向对象的变量不分配任何值，通常将变量赋值为NULL或者用unset()函数。示例代码如下：

<?php 
    class des{
        function __destruct(){
            echo "对象被销毁，执行析构函数<br>";
        }
    }
    $p=new des(); /* 实例化类 */
    echo "程序开始<br>";
    unset($p); /* 销毁变量$p */
    echo "程序结束";
?>

四、面向对象的作用域范围有哪几种？

在PHP5中，类的属性或者方法主要有public、protected和private三种类作用域，它们的区别如下：
1）public（公有类型）表示全局，类内部、外部和子类都可以访问。
默认的访问权限为public，也就是说，如果一个方法没有被public、protected或private修饰，那么它默认的作用域为public。
2）protected（受保护类型）表示受保护的，只有本类或子类可以访问。
在子类中，可以通过self::var或self::method访问，也可以通过parent::method来调用父类中的方法。
在类的实例化对象中，不能通过$obj->var来访问protected类型的方法或属性。
3）private（私有类型）表示私有的，只有本类内部可以使用。
该类型的属性或方法只能在该类中使用，在该类的实例、子类、子类的实例中都不能调用私有类型的属性和方法。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!