Ressources recommandées pour les didacticiels vidéo PHP, du début à la maîtrise

Dans le cours « PHP from Getting Started to Mastery Video Tutorial », PHP (nom étranger : PHP : Hypertext Preprocessor, nom chinois : « Hypertext Preprocessor ») est un langage de script open source général. La syntaxe absorbe les caractéristiques du langage C, Java et Perl, facile à apprendre et largement utilisée. Elle convient principalement au domaine du développement Web. La syntaxe unique de PHP mélange la syntaxe C, Java, Perl et PHP. Il peut exécuter des pages Web dynamiques plus rapidement que CGI ou Perl. Par rapport à d'autres langages de programmation, les pages dynamiques créées avec PHP intègrent des programmes dans un document HTML (une application sous le Standard Universal Markup Language) pour l'exécution, et l'efficacité d'exécution est bien supérieure à celle du CGI qui génère entièrement des balises HTML. PHP peut également exécuter du code compilé ; La compilation peut réaliser le cryptage et optimiser l'exécution du code, ce qui accélère l'exécution du code.

Adresse de lecture du cours : http://www.php.cn/course/351.html

Le style d'enseignement du professeur :

Les cours sont conviviaux et naturels, sans prétention, ni prétentieux ni délibérément exagérés, mais parlent avec éloquence et prudence, entre enseignants et étudiants Dans une atmosphère d'égalité, la collaboration et l'harmonie, des échanges émotionnels silencieux sont réalisés, et le désir et l'exploration des connaissances sont intégrés dans des situations d'enseignement simples et réelles. Les étudiants acquièrent des connaissances grâce à une réflexion calme et une approbation silencieuse

Les points les plus difficiles. dans cette vidéo se trouvent les trois fonctionnalités majeures de la programmation orientée objet :

1. Encapsulation

Encapsulation signifie littéralement emballage Le point professionnel est la dissimulation d'informations, qui fait référence à l'utilisation de. types de données abstraits pour encapsuler les données et les opérations basées sur les données pour former une entité indépendante indivisible. Les données sont protégées dans le type de données abstrait et les détails internes sont cachés autant que possible, ne conservant que certaines interfaces externes pour se connecter avec le monde extérieur. Les autres objets du système ne peuvent communiquer et interagir avec cet objet encapsulé que via des opérations autorisées en dehors des données. C'est-à-dire que l'utilisateur n'a pas besoin de connaître les détails internes de l'objet, mais peut accéder à l'objet via l'interface fournie par l'objet.

Pour l'encapsulation, un objet encapsule ses propres propriétés et méthodes, afin qu'il puisse effectuer ses propres opérations sans s'appuyer sur d'autres objets. L'utilisation de l'encapsulation présente trois avantages majeurs :

1. Une bonne encapsulation peut réduire le couplage.

2. La structure à l'intérieur de la classe peut être modifiée librement.

3. Vous pouvez contrôler les membres avec plus de précision.

4. Masquer les informations et mettre en œuvre les détails.

L'encapsulation privatise les propriétés d'un objet et fournit certaines méthodes pour les propriétés accessibles par le monde extérieur. Si nous ne voulons pas être accessibles par des méthodes extérieures, nous n'avons pas besoin de fournir de méthodes pour. accès extérieur. Mais si une classe ne fournit pas de méthodes d’accès externe, alors cette classe n’a aucun sens.

public class Husband {  
      
    /* 
     * 对属性的封装 
     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性 
     */  
    private String name ;  
    private String sex ;  
    private int age ;  
    private Wife wife;  
      
    /* 
     * setter()、getter()是该对象对外开发的接口 
     */  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getSex() {  
        return sex;  
    }  
  
    public void setSex(String sex) {  
        this.sex = sex;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    public void setWife(Wife wife) {  
        this.wife = wife;  
    }  
}

L'encapsulation nous permet de modifier facilement l'implémentation interne d'une classe sans modifier le code client qui utilise la classe. Vous pouvez avoir un contrôle plus précis sur les variables membres.

1. public void setAge(int age) {  
2.     if(age > 120){  
3.         System.out.println("ERROR：error age input....");    //提示错误信息  
4.     }else{  
5.         this.age = age;  
6.     }  
7. }

. public String getSexName() {  
2.         if("0".equals(sex)){  
3.             sexName = "女";  
4.         }  
5.         else if("1".equals(sex)){  
6.             sexName = "男";  
7.         }  
8.         else{  
9.             sexName = "人妖";  
10.         }  
11.         return sexName;  
12.     }

2. Héritage

2.1 Présentation de l'héritage

L'héritage est une technologie qui utilise la définition d'une classe existante comme base pour créer une nouvelle classe La définition peut ajouter de nouvelles données ou de nouvelles fonctions, ou utiliser les fonctions de la classe parent, mais ne peut pas hériter de manière sélective de la classe parent. En utilisant l'héritage, nous pouvons réutiliser le code précédent très facilement, ce qui peut grandement améliorer l'efficacité du développement.

L'héritage décrit la relation "est-un". S'il y a deux objets A et B, s'il peut être décrit comme "A est B", cela peut signifier que A hérite de B, où B est hérité de A. est appelée classe parent ou superclasse, et A est une sous-classe ou une classe dérivée.

En fait, le successeur est une spécialisation de l'héritier En plus d'avoir les caractéristiques de l'héritier, il a aussi ses propres caractéristiques uniques. Par exemple, les chats ont des caractéristiques que les autres animaux n’ont pas, comme attraper des souris et grimper aux arbres. En même temps, dans la relation successorale, l'héritier peut remplacer complètement l'héritage, mais pas l'inverse. Par exemple, on peut dire qu'un chat est un animal, mais on ne peut pas dire que l'animal est un chat. c'est la raison pour laquelle nous appelons cela « transformation vers le haut ».

Il est vrai que l'héritage définit la façon dont les classes se rapportent les unes aux autres et partagent des caractéristiques. Pour plusieurs classes identiques ou familières, nous pouvons résumer leurs comportements ou attributs communs et les définir comme une classe parent ou une super classe, puis utiliser ces classes pour hériter de la classe parent. Elles peuvent non seulement avoir les propriétés et les méthodes de la classe parent. Vous pouvez également définir vos propres propriétés ou méthodes uniques.

En même temps, vous devez vous souvenir de trois phrases lors de l'utilisation de l'héritage :

1 La sous-classe a les attributs et méthodes non privés de la classe parent.

2. Les sous-classes peuvent avoir leurs propres attributs et méthodes, c'est-à-dire que les sous-classes peuvent étendre les classes parentes.

3. Les sous-classes peuvent implémenter les méthodes de la classe parent à leur manière. (Introduit plus tard).

Ces trois choses sont indispensables lors de l'apprentissage de l'héritage : constructeur, mot-clé protégé, transformation ascendante

2.2 Constructeur

Grâce au précédent nous savons que les sous-classes peuvent hériter des classes parents De plus à ces propriétés et méthodes privées, il y en a une autre qui ne peut pas être héritée par les sous-classes --- le constructeur. Quant au constructeur, il ne peut être qu'appelé et ne peut pas être hérité. Pour appeler le constructeur de la classe parent, on peut utiliser super().

Le processus de construction s'étend "vers l'extérieur" à partir de la classe parent, c'est-à-dire en partant de la classe parent et en complétant la construction étape par étape jusqu'aux sous-classes. Et nous n'avons pas explicitement référencé le constructeur de la classe parent. C'est l'astuce de Java : le compilateur appellera par défaut le constructeur de la classe parent de la sous-classe.

Cependant, cet appel par défaut au constructeur de la classe parent est prédicat : la classe parent a un constructeur par défaut. Si la classe parent n'a pas de constructeur par défaut, nous devons explicitement utiliser super() pour appeler le constructeur de la classe parent, sinon le compilateur signalera une erreur : Un constructeur conforme à la forme de la classe parent est introuvable.

Pour les sous-classes, l'initialisation correcte de son constructeur est très importante, et si et seulement s'il n'existe qu'une seule méthode qui puisse garantir cela : appeler le constructeur de la classe parent dans le constructeur pour terminer l'initialisation, et le parent Le constructeur de classe possède toutes les connaissances et capacités nécessaires pour effectuer l’initialisation de la classe parent.

Pour l'héritage, la sous-classe appellera le constructeur de la classe parent par défaut. Cependant, s'il n'y a pas de constructeur par défaut de la classe parent, la sous-classe doit spécifier explicitement le constructeur de la classe parent, et elle doit le faire. être dans la classe enfant. La première chose faite dans le constructeur de classe (la première ligne de code).

2.3 mot-clé protégé

Le modificateur d'accès privé est le meilleur choix pour l'encapsulation, mais cela n'est basé que sur un monde idéal. Parfois, nous avons besoin d'une telle exigence : nous devons autant masquer certaines choses. autant que possible du monde, tout en permettant aux membres des sous-classes d'y accéder. À ce stade, vous devez utiliser protected.

Pour protected, cela indique qu'en ce qui concerne l'utilisateur de la classe, elle est privée, mais pour toute sous-classe qui hérite de cette classe ou de toute autre classe située dans le même package, elle est accessible.

2.4 Transformation vers le haut

Dans l'héritage ci-dessus, nous avons parlé de l'héritage comme d'une relation est-une, de l'héritage des chats et des animaux, nous pouvons donc dire que les chats sont des animaux, ou que les chats sont des animaux type de. Considérer les chats comme des animaux de cette manière, c'est se transformer vers le haut.

3. Polymorphisme

3.1 Présentation du polymorphisme

Le soi-disant polymorphisme fait référence au type spécifique pointé par la variable de référence définie dans le programme et les méthodes émises via la variable de référence L'appel n'est pas déterminé lors de la programmation, mais est déterminé lors de l'exécution du programme. C'est-à-dire sur quel objet d'instance de classe une variable de référence pointera. L'appel de méthode émis par la variable de référence doit être implémenté dans quelle classe. Cela peut être décidé pendant l'exécution du programme. Étant donné que la classe spécifique n'est déterminée que lorsque le programme est en cours d'exécution, la variable de référence peut être liée à diverses implémentations de classe sans modifier le code du programme source, ce qui entraîne la modification en conséquence de la méthode spécifique appelée par la référence, c'est-à-dire qu'elle n'a pas besoin de être modifié. Le code du programme peut changer le code spécifique lié au programme lors de son exécution, permettant au programme de sélectionner plusieurs états d'exécution. Il s'agit du polymorphisme.

Nous pouvons donc résumer le polymorphisme comme suit :

Puisque la référence de classe parent pointant vers la sous-classe est transformée vers le haut, elle ne peut accéder qu'aux méthodes et propriétés appartenant à la classe parent, tandis que pour la classe parent sous-classe Pour une méthode qui existe dans la classe parent mais qui n'existe pas dans la classe parent, la référence ne peut pas être utilisée, même si la méthode est surchargée. Si une sous-classe remplace certaines méthodes de la classe parent, lors de l'appel de ces méthodes, elle doit utiliser les méthodes définies dans la sous-classe (connexion dynamique, appel dynamique).

Pour l'orientation objet, le polymorphisme est divisé en polymorphisme au moment de la compilation et en polymorphisme au moment de l'exécution. Parmi eux, le polymorphisme au moment de l'édition est statique et fait principalement référence à la surcharge de méthode. Il distingue différentes fonctions en fonction de différentes listes de paramètres. Après l'édition, il n'y a pas de polymorphisme au moment de l'exécution. Le polymorphisme d'exécution est dynamique et est obtenu grâce à une liaison dynamique, ce que nous appelons le polymorphisme.

3.2 Conditions de mise en œuvre du polymorphisme

Au début, nous avons évoqué que l'héritage prépare à la mise en œuvre du polymorphisme. La sous-classe Child hérite de la classe parent Father. Nous pouvons écrire une référence de type de classe parent pointant vers la sous-classe. Cette référence peut gérer soit l'objet Father de la classe parent, soit l'objet Child de la sous-classe. classe Lorsqu'un objet est utilisé, l'objet aura des comportements différents en fonction de la référence à laquelle il appartient. C'est le polymorphisme. Autrement dit, le polymorphisme signifie que le même message amène différentes classes à répondre différemment.

Il y a trois conditions nécessaires pour que Java réalise le polymorphisme : l'héritage, la réécriture et la transformation ascendante.

Héritage : dans le polymorphisme, il doit y avoir des sous-classes et des classes parents avec des relations d'héritage.

Réécriture : La sous-classe redéfinit certaines méthodes de la classe parent, et lorsque ces méthodes seront appelées, les méthodes de la sous-classe seront appelées.

Transformation vers le haut : dans le polymorphisme, la référence de la sous-classe doit être affectée à l'objet de la classe parent. Ce n'est qu'ainsi que la référence peut avoir la capacité d'appeler les méthodes de la classe parent et les méthodes de la classe parent. sous-classe.

Ce n'est que lorsque les trois conditions ci-dessus sont remplies que nous pouvons utiliser une logique unifiée pour implémenter du code dans la même structure d'héritage afin de traiter différents objets, exécutant ainsi différents comportements.

Pour Java, son mécanisme d'implémentation polymorphe suit un principe : lorsqu'une variable de référence d'objet de superclasse fait référence à un objet de sous-classe, le type de l'objet référencé plutôt que le type de la variable de référence détermine quel membre est appelé. , mais la méthode appelée doit être définie dans la super classe, c'est-à-dire une méthode remplacée par la sous-classe.

3.3 Forme d'implémentation

Il existe deux formes pour réaliser le polymorphisme en Java : l'héritage et l'interface.

3.2.1. Polymorphisme implémenté basé sur l'héritage

Le mécanisme d'implémentation basé sur l'héritage se reflète principalement dans la réécriture de certaines méthodes par la classe parent et une ou plusieurs sous-classes qui héritent de la classe parent , plusieurs sous-classes remplaçant la même méthode peuvent présenter des comportements différents.

Le polymorphisme implémenté basé sur l'héritage peut être résumé comme suit : pour un type de classe parent qui fait référence à une sous-classe, lors du traitement de la référence, il s'applique à toutes les sous-classes qui héritent de la classe parent, pour les différents objets de la sous-classe. la mise en œuvre de la méthode est également différente, et le comportement produit en effectuant la même action est également différent.

Si la classe parent est une classe abstraite, alors la sous-classe doit implémenter toutes les méthodes abstraites de la classe parent. De cette façon, toutes les sous-classes de la classe parent doivent avoir une interface externe unifiée, mais leurs implémentations internes spécifiques. peut varier différemment. De cette façon, nous pouvons utiliser l'interface unifiée fournie par la classe de niveau supérieur pour gérer les méthodes à ce niveau.

3.2.2. Polymorphisme basé sur l'implémentation de l'interface

L'héritage se reflète en réécrivant plusieurs sous-classes différentes de la même méthode de la classe parent, puis il peut être réalisé en implémentant l'interface et c'est incarné par plusieurs classes différentes couvrant la même méthode dans l’interface.

Dans le polymorphisme de l'interface, la référence pointant vers l'interface doit être un programme d'instance qui spécifie une classe qui implémente l'interface au moment de l'exécution, la méthode correspondante est exécutée en fonction du type réel de la référence de l'objet. .

L'héritage est un héritage unique, qui ne peut fournir qu'une interface de service cohérente pour un groupe de classes liées. Cependant, les interfaces peuvent avoir plusieurs héritages et plusieurs implémentations. Elles peuvent être combinées et étendues à l'aide d'un ensemble d'interfaces liées ou non, et peuvent fournir des interfaces de service cohérentes avec le monde extérieur. Il offre donc une meilleure flexibilité que l’héritage.

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!