Qu'est-ce que le PHP orienté objet ? Résumé orienté objet PHP

Le contenu de cet article est qu'est-ce que l'orientation objet en PHP ? Résumé orienté objet PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Fonctionnalités orientées objet :

* Réutilisabilité (chaque module peut être réutilisé dans le projet)

* Flexibilité (chaque module peut être facilement remplacé et modifié)

* Extensibilité (il est très pratique d'ajouter de nouvelles fonctions au module)

La relation entre les classes et les objets (les classes génèrent des objets)

Les oiseaux d'une plume s'assemblent : les objets ayant les mêmes caractéristiques sont regroupés dans une seule catégorie. Par exemple, les joueurs de la NBA ont tous des attributs qui leur viennent à l'esprit tels que le nom, la taille et le poids, le numéro d'équipe et des méthodes telles que la course, sauter, dribbler et tirer. Traitez-les comme une classe, et Jordan et James sont des instances de joueurs NBA, également appelés objets

L'objet a une cohésion interne élevée (fonctions spécifiques, tout le contenu associé est encapsulé à l'intérieur de l'objet) et une faible cohésion externe ; Couplage (quelques attributs visibles et quelques méthodes visibles de l'objet)

Utiliser la classe pour déclarer une classe Il ne peut y avoir que des attributs membres et des méthodes membres dans la classe ! ! ! ! Il ne peut y en avoir d'autres. Il ne peut pas y avoir deux classes avec le même nom dans un même script. La classe instanciée peut avoir plusieurs objets

class Computer{
    public $text = "用关键字new实例化一个类";
    public function output(){
    echo $this->text;
    }
}
$computer = new Computer();

$computer->output();//外部访问方法
$computer->text();//外部访问属性
$computer2 = new Computer();//可以实例化多个

Les attributs et méthodes de la classe

accessible Contrôle :

public Le public peut accéder
privé Le privé n'est accessible qu'au sein de la classe elle-même
protected Les sous-classes héritées protégées et la classe elle-même sont accessibles en interne, mais pas en externe, par exemple comme : $computer->output (); Si la méthode output() est définie sur protected, une erreur sera signalée.

Méthodes dans la classe :

La méthode appelle un attribut, et la classe doit être instanciée pour accéder à l'attribut, et $this peut être compris comme une instance de cette classe

class Computer{    
    public $text = "用$this调用我";   
    public function output(){    
         echo $this->text;
    }
}

Méthode constructeur (exécutée lors de l'instanciation)

La méthode constructeur peut transmettre des paramètres qui sont transmis lors de l'instanciation

via le constructeur Passez les paramètres et modifiez les propriétés à l'intérieur pour rendre chaque objet d'instance différent

class Computer{
   function __construct($arg){
       echo "我是构造方法，自动执行";　　　　
       echo $arg;
   } 
} 
$conputer = new Computer("我是构方法的参数");

Méthode de destruction : Exécuté une fois détruit, aucun paramètre n'est autorisé

Exécuté automatiquement une fois le programme terminé, la libération manuelle (lorsque toutes les références à l'objet sont détruites) entraînera l'exécution du destructeur à l'avance, et il n'est pas nécessaire d'attendre la fin du programme pour appeler

Lorsque vous supprimez une référence, cela rompt simplement le lien entre le nom de la variable et le contenu de la variable. Cela ne veut pas dire que le contenu de la variable est détruit

//对象引用  在PHP 中引用的意思是：不同的名字访问同一个变量内容.
class A
{
    
    function __destruct()
    {
        echo '====我是析构函数====';
    }
}


$a = new A();
//提前执行析构函数的两个方法 unset($a);$a=null;
echo "====正常执行我是先输出的=====";
//两种对象引种的区别
$a = $b;//这时$a和$b是两个独立的引用，unset($aa)只是删除了$a的引用，还有$b的引用，所以不会执行析构函数。改变其中一个为null,不会影响另外一个变量，也不会执行析构函数；
$c = &$a;//两个的变量使用同个引用，c是a的影子，改变其中一个变量为null，两个都为null,会执行析构函数。但是只是unset($a),$c还在使用引用，只要有引用在不会执行析构函数;
//对象的引用用于访问对象的属性和方法，所以$a $b $c都可以访问对象的属性方法； 
//当一个对象的所有引用被删除后，才会触发析构函数

//总结：如果程序大，对象引用尽量使用&，节省内存，清除也方便。设其中一个为Null，其他都为Null；

//变量引用 (默认变量赋值会独立开辟一个内存存放内容)
 //PHP 的引用允许你用两个变量来指向同一个内容
$a="AB"; 
$b =&$a;
echo $a;//这里输出:AB
echo $b;//这里输出:AB 
$b="EF"; 
echo $a;//这里$a的值变为EF 所以输出EF 
echo $b;//这里输出EF  <?php
$a = 1;
$b = $a;
echo $a;
//在此之前，b都是和a共用内存空间的。
xdebug_debug_zval(&#39;b&#39;);
$a = 2;//a作出了改变，此时b才会有自己的空间
xdebug_debug_zval(&#39;b&#39;);
?>


//函数引用
<?php
function test(&$a){ 
$a=$a+100; 
} 
$b=1; 
echo $b;//输出１ test($b); //这里$b传递给函数的其实是$b的变量内容所处的内存地址，通过在函数里改变$a的值　就可以改变$b的值了 echo "<br>"; echo $b;//输出101
?>//函数的引用返回
<?phpfunction &test(){     static $b=0;//申明一个静态变量     $b=$b+1;     echo $b;     return $b; }$a=test();//这条语句会输出　$b的值　为１ 相当于$a=$b$a=5; $a=test();//这条语句会输出　$b的值　为2 也是$a=$b$a=&test();//这条语句会输出　$b的值　为3 $a=&$b,所以b会随a变了$a=5; $a=test();//这条语句会输出　$b的值　为6?>

La différence entre affectation et clonage :

$a=$b (référence indépendante) et $a = La méthode d'affectation de &$b (même référence) pointe vers le même objet et le même espace mémoire ; la méthode d'affectation de

$a=clone $b pointe vers un autre nouvel objet. espace.

<?phpclass mm {

    public $name = &#39;Peter&#39;;

}
$a = new mm();
$b = $a; 
$c = &$a;
$d = clone $a; 
$b->name = "Anne";
echo $a->name,"\n",$b->name,"\n",$c->name,"\n",$d->name;//输出为：Anne Anne Anne Peter
?>

Constante de classe

Accès interne self::nom constant

L'accès externe ne nécessite pas d'instanciation : nom de classe ::nom constant

class Computer{    
    const yh = 12;    
    const yh2 = self::yh+1;
} 
var_dump (Computer::yh2);

La différence entre $this et self

L'un est l'objet $this, qui est équivalent à l'instanciation. On peut dire cela sauf pour static et const. constantes, pratiquement tout le reste peut être utilisé Utilisez ceci pour contacter;

self est la classe elle-même. Self peut accéder aux propriétés statiques et aux méthodes statiques de cette classe, et peut accéder aux propriétés statiques et aux méthodes statiques de la classe parent. Lorsque vous utilisez self, vous n'avez pas besoin d'instancier

l'héritage de classe

ce qui signifie : extraire les mêmes méthodes d'attribut et laisser les sous-classes hériter

extends, ce qui signifie qu'une seule classe parent peut être héritée. Héritage unique

La sous-classe peut également remplacer la méthode de la classe parent

class dad{     
     function eat(){         
          echo "我是父类的方法，子类可以继承我的方法";
     }
}
class boy extends dad{
} 
$boy = new boy();$boy->eat();

Lorsque la sous-classe a. pas de méthode constructeur, il appellera le constructeur de la classe parent, et parfois il appellera le sien

Utilisez le mot-clé parent:: __construct(); mot-clé final devant la classe, il ne sera pas hérité ; Ajouté devant la méthode, cette méthode ne sera pas remplacée

Namespace

(pour résoudre le problème de conflit de nom)

En utilisant le principe selon lequel le système de fichiers n'utilise pas de répertoires a été introduit. Ajoutez le sous-répertoire du répertoire d'espace de noms au fichier php Appelez lors de l'utilisation de : un nouveau nom de classe de sous-répertoire de répertoire (tel que new comsessioncomputer();
Sont affectés par l'espace de noms les classes (y compris les classes abstraites, les traits), les interfaces, les fonctions, les constantes (const et Defin sont tous deux utilisés pour déclarer des constantes (leurs différences ne sont pas détaillées), mais dans un espace de noms, définir des actes globalement, tandis que const agit sur l'espace actuel.)

Il convient de noter qu'il ne peut y avoir de code devant le premier espace de noms du fichier de script actuel. Les méthodes d'écriture suivantes sont erronées :

<.>Comme le chemin doit être écrit pour chaque appel, c'est très gênant, donc l'utilisation de use apparaît (use doit être introduite avec un nom de classe ou un nom de fonction)

Lors de l'appel, utilisez d'abord use pour introduire, utilisez le sous-répertoire du répertoire class ; vous pouvez également utiliser des alias pour les distinguer comme

//例一
//在脚本前面写了一些逻辑代码
 

<?php

$path = "/";

class Comment { }

namespace Article;

?>

 

//例二
//在脚本前面输出了一些字符

<html></html>
<?php

namespace Article;

?>为什么要说第一个命名空间呢？因为同一脚本文件中可以创建多个命名空间。<?php
//创建一个名为&#39;Article&#39;的命名空间namespace Article;
//此Comment属于Article空间的元素class Comment { }
//创建一个名为&#39;MessageBoard&#39;的命名空间namespace MessageBoard;
//此Comment属于MessageBoard空间的元素class Comment { }?>

Points clés : La différence entre l'appel de classes globales, de fonctions et de constantes dans l'espace de noms
Page a définit l'espace de noms venter après; en introduisant la page b (espace global), si vous souhaitez appeler la classe de la page b, vous devez :

New venter() Ajouter un

use venter\session\computer;
use venter\computer as computer2;
new computer();
new computer2();

函数的话记得带上function
use function venter\session\computer;
computer();

常量记得带上const 
use const venter\session\computer;
var_dump(computer);

pour représenter l'espace global. Mais lors de l'appel de fonctions et de constantes, il n'y en a pas. vous devez l'ajouter, car il effectuera automatiquement une recherche et une recherche globale.

类自动加载：
当你实例化一个类时，这个类不存在，就会自动执行我们写的 function __autoload($className){},在这个自动函数的内部去执行我们想要操作的代码，参数就是我们实例化的类名，因此可以根据参数去引入php文件。
__autoload将被淘汰，使用新的函数 spl_autoload_register();参数可以传函数名或者匿名函数

spl_autoload_register(function($a){
echo $a;
}
);
new Computer();
或者
function aaa($a){
echo $a;
}

spl_autoload_register('aaa');
new Computer();
或者类的调用方法
class momo
{
function aaa($a){
echo $a;
}
}
spl_autoload_register([new momo],'aaa');
new Computer();

利用命名空间和自动加载实现项目自动引用
1，文件目录就和命名空间名一样，文件名和类名一样 new models\imooc() 就是在models文件下的imooc.php文件，
2，然后利用spl_autoload_register(function($classname){
include str_replace("\\","/",$classname.".php");
});
这里的作用是models\imooc替换掉models/imooc.php 引入
而imooc.php文件中必须命名 namespace models；

static 静态

存在的价值，为了让对象公用一些数据，做到统一性

当属性和方法被定义为 static 时就变成类的属性和方法，不属于对象的，不需要实例化

外部访问  类名::$aa  内部访问 self::$aa 或者static::$aa; 子类访问父类 parent::$aa;

静态方法不能调用非静态属性
因为 $this代表实例化对象，而这里是类，不知道 $this 代表哪个对象

class person{
public static $aa ="a";
public static function eat(){
        echo self::$aa;
        echo static::$aa;
    }
}
class boy extends person{
    public function eat2(){
        echo parent::$aa;
    }
}
echo(boy::eat2());

后期静态绑定：

class A{
public static function who(){
echo "A类的who方法";
}
public static function test(){
self::who(); 
// static::who();
}

}
class B extends A{
public static function who(){
echo "B类的who方法";
}
}
B::test();

如果是self::who(); 输出的是A类的who方法，说明调用的是A自身，static::who();会根据上下文作处理，类B调用就使用B里面的who()

魔术方法
__set($var,$val) 设置私有属性，当外部调用设置一个私有属性时会自动执行这个方法，
__get($var)获取私有属性，原理是外部调用一个私有属性时会自动执行这个方法
例子：

class test{
private $abc = "";
private $ccc = "";
public function __set($var,$val){
$this->$var = $val;
}
public function __get($var){
return $this->$var;
}
}
$test = new test();
$test->abc = 'abc';
var_dump($test->abc);

__isset($var)方法，当外部调用isset($test-abc)访问一个不能访问的属性时，就会自动执行   isset()或者empty() 都会触发__isset()方法

__unset($var)，当外部想删除一个私用属性时，会自动执行

以上是属性的重载

__call，__callStatic是属于方法的重载，不是重写

__call($func方法名,$arguments参数)当外部调用一个没有定义的方法时，就会调用

__callStatic($meethod,$arg)当调用一个不存在的静态方法时，会自动执行 注意在function 前也要加入 static 因为是静态方法

__invoke($rag)当实例化一个类后，把这个对象变量当成函数调用时，会自动执行
例如：$test = new test();
$test("go....");

__toString() 当对象被当成string使用时，会执行，比如 echo($test);

__clone方法的一些应用
当一个对象被克隆时，会调用__clone，此时可以在里面执行一些逻辑，比如不想让某些值被克隆，或者初始化一些属性的值

对象拷贝：
浅拷贝：是地址传递（对象是浅拷贝）
深拷贝：复制一份，新开辟一块内存(普通变量是深拷贝)

加clone 使对象成为深拷贝，互不影响；
$a = new A();
$b = clone $a;

__clone()当使用clone时，会自动执行
$a = new A();
$b = clone $a; 在A类中会执行__clone()
例子：

class A{
public $obj = null;
public function __clone(){
$this->obj = clone $this->obj;//开辟了新空间给克隆的对象
}
}
Class B{
public $sex = 0;
}

$a = new A();
$a->obj= new B();
$b = clone $a;
$b->obj->sex = 1;
var_dump($a->obj->sex);

类型约束

class A{
public $obj = null;
public function go(){
echo "googogogogo";
}
}
class B{
public function go(){
echo "bbbbbb";
}
}
Function test(A $a){
$a->go();
}
test(new A());//必须是A的实例

trait 关键字

解决单继承问题 配合use 使用

trait A{
public function a(){
echo "aaaaa";
}
}
trait B{
public function b(){
echo "bbbb";
}
}

Class test{
use A,B;
public function c(){
echo "cccc";
}
}

$test = new test();
$test->a();
$test->b();
$test->c();

接口

可以理解为类的模板 不能直接被实例化

用instanceof 判断某个对象是否实现了某个接口
接口可以继承接口，但是类必须实现接口所有的方法

interface person {
public function eat();
public function sleep();
}
class man implements person{
public function eat(){
echo "chichi吃吃";
}
public function sleep(){
echo "shuishushi";
}
}
$aaa = new man();
$aaa->eat();
//接口继承 两种方法 
interface aa {
public function eat();
}
interface bb {
public function sleep();
}
interface person extends aa,bb{
//person就直接继承了两种方法
}
class man implements person{
public function eat(){
echo "chichi";
}
public function sleep(){
echo "shuishuishui";
}
}
//或者 直接实现两种接口
class man implements aa,bb{
public function eat(){
echo "chichi";
}
public function sleep(){
echo "shuishuishui";
}
}
//接口里面可以利用 const 定义一个常量 
interface person {
const aa = "bbb";
public function eat();
public function sleep();
}
echo person::aa;

抽象类：

（比如人和动物都会呼吸方法都一样，此时就不需要每个类去实现不同的呼吸方法，吃东西的方法不同，所以在类中各自实现逻辑）抽象类的子类只需要实现抽象方法；

内部有自己的执行方法

abstract class person {
public function holiday(){
echo '我是抽象类自己实现的方法';
}
//抽象方法，以分号结束，无方法体；抽象类中至少要有一个抽象方法
abstract public function eat();
}
class man extends person{
    public function eat(){
    $this->holiday();//直接调用即可
    }
}
$aaa = new man();
$aaa->eat();

单例模式：

让一个类只会被实例化一次，节省内存空间
先把构造函数和克隆函数变成私用属性

class test{
private static $_instance = null;//依靠属性存储实例对象判断是否已经实例过
private function __construct(){
// 私有后将不会被外部实例
}
private function __clone(){
// 私有后将不会被外部克隆
}
public static function getInstance(){
if(!(self::$_instance instanceof self)){
// instanceof判断是否是当前的实例，不是的话就实例化赋值，否则就返回
self::$_instance = new self();
}
return self::$_instance;
}
}
$test1 = test::getInstance();
$test2 = test::getInstance();
$test3 = test::getInstance();
var_dump($test1);
var_dump($test2);
var_dump($test3);
// 输出结果object(test)#1 (0) { } object(test)#1 (0) { } object(test)#1 (0) { }

工厂模式：

就是在多处实例化一个类，当这个类名需要改变时，就会导致大量地方需要更改，使用工厂模式避免这种情况发生

class A{
public function a(){
echo 'aaa';
}
public function c(){
echo 'ccc';
}
public function b(){
echo 'bbb';
}
}
class cashe{
public static function factory(){
return new A();//当业务逻辑变化时，只需要改此处
}
}
$cashe = cashe::factory();
$cashe->a();

面向对象功能汇总

有继承功能，必须有访问的控制，（私有公有属性），static静态关键字来保存一些公用的数据，重写对父类的方法属性重定义，final关键字不允许重写或者继承，访问静态属性的几个方法，接口中的方法是不用具体实现的，在类中才实现，而且必须实现接口中所有的方法，因为有了不同的实现方法逻辑，不同的对象产生不同的表现，这叫多态，存在与接口与类之间的叫抽象类，可以有一部分可以实现，一部分不用实现

/*--------------多态的一个应用实例 模拟USB设备的使用------------------*/

//一个USB的接口

interface USB{

function mount();//装载USB的方法

function work();//USB工作的方法

function unmount();//卸载USB的方法

}

//定义一个USB设备 U盘

class Upan implements USB{//实现USB接口

function mount(){

echo " U盘 装载成功<br/>";

}

function work(){

echo "U盘 开始工作<br/>";

}

function unmount(){

echo "U盘 卸载成功<br/>";

}

}

//定义一个USB设备 USB鼠标

class Umouse implements USB{//实现USB接口

function mount(){

echo " USB键盘 装载成功<br/>";

}

function work(){

echo "USB键盘 开始工作<br/>";

}

function unmount(){

echo "USB键盘 卸载成功<br/>";

}

}

//定义一个电脑类

class Computer{

//使用USB设备的方法

function useUSB ($usb){//$usb参数表示 使用哪种USB设备

$usb->mount();//调用设备的 装载方法

$usb->work();//调用设备的 工作方法

$usb->unmount();//调用设备的卸载方法

}

}

//定义一个电脑的使用者的类

class PcUser{

//

安装

USB的方法

function install(){

//首先拿来一台电脑

$pc=new Computer;

//拿来一些USB设备

$up=new Upan;//拿来一个U盘

$um=new Umouse;//拿来一个USB鼠标

//把USB设备插入电脑, 使用电脑中使用USB设备的方法 来调用 要插入的设备

$pc->useUSB($up);//插入U盘

$pc->useUSB($um);//插入USB鼠标

}

}

//实例化一个电脑用户

$user=new PcUser;

$user->install();//安装设备

/*-------------输出内容--------------

U盘 装载成功

U盘 开始工作

U盘 卸载成功

USB键盘 装载成功

USB键盘 开始工作

USB键盘 卸载成功

-----------------------------------*/

?>

以上就是本篇的全部内容，更多相关教程请访问php编程从入门到精通全套视频教程，php实战视频教程，bootstrap视频教程！

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!