Table des matières
PHP 面向对对象基础(接口,类),php面向
Maison développement back-end tutoriel php PHP 面向对对象基础(接口,类),php面向_PHP教程

PHP 面向对对象基础(接口,类),php面向_PHP教程

Jul 12, 2016 am 08:52 AM
抽象类

PHP 面向对对象基础(接口,类),php面向

介绍PHP面向对象的基础知识

1. 接口的定义interface ,类定义class,类支持abstract和final修饰符,abstract修饰为抽象类,抽象类

不支持直接实例化,final修饰的类/方法不能被继承/方法重写.
2. 接口的实现通过implements,类继承extends

  <span>interface</span><span> IShape{
    </span><span>function</span><span> draw_core();
  };

  </span><span>class</span> PathShape <span>implements</span><span> IShape{
    </span><span>public</span> <span>function</span><span> draw_core(){}
  }

  </span><span>class</span> Rectangle <span>extends</span><span> PathShape{
    </span><span>public</span> <span>function</span><span> draw_core(){
      </span><span>//</span><span>overide draw_core</span>
<span>    }
  }</span>
Copier après la connexion

3.静态变量和常量(static ,const )
a.常量声明变量名前面不需要加美元修饰符$,静态变量需要
b.两者都通过类访问,静态变量方法时候需要在变量名前加$美元修饰符好

   <span>class</span><span> MyClass{
     </span><span>const</span><span> M_CONST_VALUE;
     </span><span>static</span> <span>$M_STATIC_VALUE</span><span>;
   }

   MyClass</span>::<span>M_CONST_VALUE ;
   MyClass</span>::<span>$M_STATIC_VALUE</span>;
Copier après la connexion

c.常量声明时候不支持访问权限修饰符,不能在const前加public,常量默认就是public。

   <span>const</span> M_CONST  ; <span>//</span><span>OK</span>
   <span>public</span> <span>const</span> M_CONST ; <span>//</span><span> throw exception</span>
Copier après la connexion

4.类内部访问非静态/常量变量和方法通过$this,访问父类通过parent,在类内部访问静态变量和方法可以通过
self,self本质是指向该类也可以通过static访问

   parent::method(); <span>//</span><span>父类方法</span>
   <span>$this</span>->method() ; <span>//</span><span>方法实例方法</span>
   self::<span>$static_value</span> ;<span>//</span><span>访问静态变量</span>
   <span>static</span>::<span>$static_value</span>;<span>//</span><span>同上</span>
Copier après la connexion


5.static和self的区别在于self指的是解析上下文,也是是作用与当前类,static指的是被调用
的类而不是包含类,典型的例子就是单例

 <span>abstract</span> <span>class</span><span> ParentClass{
   </span><span>public</span> <span>static</span> <span>function</span><span> createInstance(){
     </span><span>return</span> <span>new</span> <span>static</span><span>(); 
     </span><span>//</span><span>这里不能使用self,因为self本意其实指向parentclass的
     //如果你使用了self,那么将抛出异常,提示抽象类无法实例化
     //而static并不直接指向parentclass而是作用与包含类
     //</span>
<span>   }
 }

 </span><span>class</span> ChildClass <span>extends</span><span> ParentClass{
   </span><span>//
</span> }
Copier après la connexion

7.类中使用拦截器,PHP拦截器有__get,__set,__inset,__unset,__call,这里只关注geth和set拦截器

 __get(<span>$property</span><span>) 当访问未定义的属性时候该方法被调用
 __set(</span><span>$property</span>,<span>$value</span><span>)当给未定义的属性赋值时被调用
 </span><span>class</span><span> MyClass{
    </span><span>public</span> <span>function</span> __get(<span>$property</span><span>){
       </span><span>echo</span> "Access __get"<span>;
       </span><span>if</span>(property_exists(<span>$this</span>,<span>$property</span><span>)){
          </span><span>return</span> <span>$this</span>-><span>$property</span><span>;
       }</span><span>else</span><span>{
         </span><span>return</span> "unknown"<span>;
       }
    }

    </span><span>public</span> <span>function</span> __set(<span>$property</span>,<span>$value</span><span>){
      </span><span>if</span>(!property_exists(<span>$this</span>,<span>$property</span><span>)){
       </span><span>$this</span>->Name = <span>$value</span>; <span>//</span><span>变量不存在就直接给$Name赋值</span>
<span>      }
    }
    
    </span><span>public</span> <span>$Name</span> = "visonme"<span>;
 };
 </span><span>//</span><span>访问</span>
 <span>$obj</span>  = <span>new</span><span> MyClass();
 </span><span>$obj</span>->Name ; <span>//</span><span>直接访问变量$Name</span>
 <span>$obj</span>->Password;<span>//</span><span>Password未定义,先访问__get最后输出unknown

 //-for __set</span>
 <span>$obj</span>->password = 'fz-visonme';<span>//</span><span>password不存在,那么将走__setz最后给$Name赋值</span>
 <span>echo</span> <span>$obj</span>->Name ; <span>//</span><span> output: fz-visonme</span>
Copier après la connexion

8.类构造函数和析构函数:__construct, __destruct ,构造函数实例化对象时候调用,多用于成员变量初始化工作,析构在类销毁时候调用,多用于收尾工作

<span>class</span><span> MyClass{
  </span><span>function</span><span> __construct(){}
  </span><span>function</span><span> __destruct(){}
}</span>
Copier après la connexion

9.对象的复制通过clone,clone关键字使用“值复制"方式来产生一个新的对象,对于对象复制本身还是走引用复制的。

a.简单类型赋值

<span>class</span><span> MyClass{
  </span><span>public</span> <span>$ID</span><span>;
};

</span><span>$a</span> = <span>new</span><span> MyClass;
</span><span>$a</span>->ID = 199<span>;
</span><span>$b</span> = <span>clone</span> <span>$a</span><span>;  
</span><span>echo</span> <span>$b</span>->ID;   <span>//</span><span> output: 199</span>
Copier après la connexion

b.包含对象的复制

<span>class</span><span> Account{
  </span><span>public</span> <span>$RMB</span><span>;
};
</span><span>class</span><span> MyClass{
  </span><span>public</span> <span>$ID</span><span>;
  </span><span>public</span> <span>$AccountObj</span><span>;

  </span><span>public</span> <span>function</span> __construct(<span>$c</span><span>){
    </span><span>$this</span>->AccountObj = <span>$c</span><span>;
  }
};

</span><span>$a</span> = <span>new</span> MyClass(<span>new</span><span> Account());
</span><span>$a</span>->AccountObj->RMB= 199<span>;
</span><span>$b</span> = <span>clone</span> <span>$a</span><span>;
</span><span>echo</span> <span>$b</span>->AccountObj->RMB;   <span>//</span><span>output: 199</span>
<span>$a</span>->AccountObj->RMB = 100<span>;
</span><span>echo</span> <span>$b</span>->AccountObj->RMB;  <span>//</span><span>output: 100</span>
<span>
在clone后,</span><span>$a的AccountObj改变时候</span>,同时会影响到<span>$b</span>
Copier après la connexion

这种结果显然不是我们所期望的,我们所期望的是ab是两个不存在任何关联的独立对象.

为了解决这个问题我么可以在类内部实现__clone,当我们在外面调用clone时候其内部会调用类的__clonef方法,所以我们可以通过重写__clone来达到对clone的控制.例如针对b例子的改造

<span>class</span><span> MyClass{
  </span><span>public</span> <span>$ID</span><span>;
  </span><span>public</span> <span>$AccountObj</span><span>;

  </span><span>public</span> <span>function</span> __construct(<span>$c</span><span>){
    </span><span>$this</span>->AccountObj = <span>$c</span><span>;
  }

  </span><span>//</span><span>__clone实现clone的控制
  //这里内部同时对Account实现一次clone,这里就可以避免b例子中出现的问题</span>
  <span>public</span> <span>function</span><span> __clone(){
    </span><span>$this</span>->ID = 0 ; <span>//</span><span>将ID置为0,如果你需要的话</span>
    <span>$this</span>->AccountObj = <span>clone</span> <span>$this</span>-><span>AccountObj;
  }
};</span>
Copier après la connexion

关于__clone方法我们需要知道,该方法是在被clone后的对象上调用,而不是在原始的对象上面运行的,例如上b例子中

  $b = clone $a ; //执行的过程: 基本复制对象$a ---> $b执行__clone() 

 


 

www.bkjia.comtruehttp://www.bkjia.com/PHPjc/1126840.htmlTechArticlePHP 面向对对象基础(接口,类),php面向 介绍PHP面向对象的基础知识 1. 接口的定义interface ,类定义class,类支持abstract和final修饰符,abstract修饰...
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

Video Face Swap

Video Face Swap

Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Outils chauds

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Golang a-t-il des classes abstraites ? Golang a-t-il des classes abstraites ? Jan 06, 2023 pm 07:04 PM

Golang n'a pas de classes abstraites. Golang n'est pas un langage orienté objet (POO). Il n'a pas de concepts de classes, d'héritage et de classes abstraites. Cependant, il existe des structures (structures) et des interfaces (interfaces) qui peuvent être indirectement implémentées via la combinaison de. struct et interface. Classes abstraites dans les langages objets.

Application d'interfaces et de classes abstraites dans les modèles de conception en Java Application d'interfaces et de classes abstraites dans les modèles de conception en Java May 01, 2024 pm 06:33 PM

Les interfaces et les classes abstraites sont utilisées dans les modèles de conception pour le découplage et l'extensibilité. Les interfaces définissent les signatures des méthodes, les classes abstraites fournissent une implémentation partielle et les sous-classes doivent implémenter des méthodes non implémentées. Dans le modèle de stratégie, l'interface est utilisée pour définir l'algorithme, et la classe abstraite ou la classe concrète assure l'implémentation, permettant une commutation dynamique des algorithmes. Dans le modèle d'observateur, les interfaces sont utilisées pour définir le comportement de l'observateur, et les classes abstraites ou concrètes sont utilisées pour s'abonner et publier des notifications. Dans le modèle d'adaptateur, les interfaces sont utilisées pour adapter les classes existantes ou les classes concrètes peuvent implémenter des interfaces compatibles, permettant une interaction avec le code d'origine.

Une discussion approfondie des similitudes et des différences entre les interfaces fonctionnelles Golang et les classes abstraites Une discussion approfondie des similitudes et des différences entre les interfaces fonctionnelles Golang et les classes abstraites Apr 20, 2024 am 09:21 AM

Les interfaces fonctionnelles et les classes abstraites sont utilisées pour la réutilisabilité du code, mais elles sont implémentées de différentes manières : interfaces fonctionnelles via des fonctions de référence, classes abstraites via l'héritage. Les interfaces fonctionnelles ne peuvent pas être instanciées, mais les classes abstraites le peuvent. Les interfaces fonctionnelles doivent implémenter toutes les méthodes déclarées, tandis que les classes abstraites ne peuvent implémenter que certaines méthodes.

Implémentation de classe interne d'interfaces et de classes abstraites en Java Implémentation de classe interne d'interfaces et de classes abstraites en Java Apr 30, 2024 pm 02:03 PM

Java permet de définir des classes internes au sein d'interfaces et de classes abstraites, offrant ainsi une flexibilité pour la réutilisation et la modularisation du code. Les classes internes des interfaces peuvent implémenter des fonctions spécifiques, tandis que les classes internes des classes abstraites peuvent définir des fonctions générales et les sous-classes fournissent des implémentations concrètes.

Interfaces Java et classes abstraites : la route vers le paradis de la programmation Interfaces Java et classes abstraites : la route vers le paradis de la programmation Mar 04, 2024 am 09:13 AM

Interface : une interface de contrat sans implémentation définit un ensemble de signatures de méthodes en Java mais ne fournit aucune implémentation concrète. Il agit comme un contrat qui oblige les classes qui implémentent l'interface à implémenter ses méthodes spécifiées. Les méthodes de l'interface sont des méthodes abstraites et n'ont pas de corps de méthode. Exemple de code : publicinterfaceAnimal{voideat();voidsleep();} Classe abstraite : plan partiellement implémenté Une classe abstraite est une classe parent qui fournit une implémentation partielle dont ses sous-classes peuvent hériter. Contrairement aux interfaces, les classes abstraites peuvent contenir des implémentations concrètes et des méthodes abstraites. Les méthodes abstraites sont déclarées avec le mot-clé abstract et doivent être remplacées par des sous-classes. Exemple de code : publicabstractcla

Interfaces Java et classes abstraites : révéler la connexion interne entre elles Interfaces Java et classes abstraites : révéler la connexion interne entre elles Mar 04, 2024 am 09:34 AM

Interface L'interface définit des méthodes abstraites et des constantes en Java. Les méthodes de l'interface ne sont pas implémentées, mais sont fournies par la classe qui implémente l'interface. L'interface définit un contrat qui exige que la classe d'implémentation fournisse des implémentations de méthodes spécifiées. Déclarez l'interface : publicinterfaceExampleInterface{voiddoSomething();intgetSomething();} Classe abstraite Une classe abstraite est une classe qui ne peut pas être instanciée. Il contient un mélange de méthodes abstraites et non abstraites. Semblables aux interfaces, les méthodes abstraites des classes abstraites sont implémentées par des sous-classes. Cependant, les classes abstraites peuvent également contenir des méthodes concrètes, qui fournissent des implémentations par défaut. Déclarer la classe abstraite : publicabstractcl

Quelle est la différence entre les interfaces et les classes abstraites en PHP ? Quelle est la différence entre les interfaces et les classes abstraites en PHP ? Jun 04, 2024 am 09:17 AM

Les interfaces et les classes abstraites sont utilisées pour créer du code PHP extensible, et il existe la différence clé suivante entre elles : les interfaces s'appliquent via l'implémentation, tandis que les classes abstraites s'appliquent via l'héritage. Les interfaces ne peuvent pas contenir de méthodes concrètes, contrairement aux classes abstraites. Une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d'une seule classe abstraite. Les interfaces ne peuvent pas être instanciées, mais les classes abstraites le peuvent.

Quelle est la différence entre une classe abstraite et une interface en PHP? Quelle est la différence entre une classe abstraite et une interface en PHP? Apr 08, 2025 am 12:08 AM

La principale différence entre une classe abstraite et une interface est qu'une classe abstraite peut contenir la mise en œuvre d'une méthode, tandis qu'une interface ne peut définir la signature d'une méthode. 1. La classe abstraite est définie à l'aide du mot-clé abstrait, qui peut contenir des méthodes abstraites et concrètes, adaptées pour fournir des implémentations par défaut et un code partagé. 2. L'interface est définie à l'aide du mot clé de l'interface, qui ne contient que des signatures de méthode, qui conviennent à la définition des normes comportementales et de l'héritage multiple.

See all articles