Was ist objektorientiertes PHP? PHP-objektorientierte Zusammenfassung

Der Inhalt dieses Artikels ist: Was ist objektorientiert in PHP? PHP-objektorientierte Zusammenfassung. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.

Objektorientierte Funktionen:

* Wiederverwendbarkeit (jedes Modul kann im Projekt wiederverwendet werden)

* Flexibilität (jedes Modul kann einfach ausgetauscht werden und geändert)

* Erweiterbarkeit (es ist sehr praktisch, dem Modul neue Funktionen hinzuzufügen)

Die Beziehung zwischen Klassen und Objekten (Klassen erzeugen Objekte)

Vogelgleiche: Objekte mit den gleichen Eigenschaften werden in einer Kategorie zusammengefasst. Beispielsweise haben NBA-Spieler alle Attribute, die einem in den Sinn kommen, wie Name, Größe und Gewicht, Teamnummer und Methoden wie Laufen, Springen, Dribbeln und Schießen. Behandeln Sie sie als Klasse, und Jordan und James sind Instanzen von NBA-Spielern, auch Objekte genannt.

Das Objekt weist eine hohe interne Kohäsion auf (bestimmte Funktionen, alle zugehörigen Inhalte sind im Objekt gekapselt) und eine externe niedrige Kohäsion Kopplung (einige sichtbare Attribute und einige sichtbare Methoden des Objekts)

Verwenden Sie eine Klasse, um eine Klasse zu deklarieren. In der Klasse können nur Mitgliedsattribute und Mitgliedsmethoden vorhanden sein! ! ! ! Es kann keine anderen Klassen mit demselben Namen in einem Skript geben. Die instanziierte Klasse kann mehrere Objekte haben >Zugriffskontrolle:

public Auf öffentlich kann zugegriffen werden

private Auf privat kann nur innerhalb der Klasse selbst zugegriffen werdenprotected Auf die geschützten geerbten Unterklassen und die Klasse selbst kann intern, aber nicht extern zugegriffen werden, wie zum Beispiel: $ computer->output() ;Wenn die Methode „output()“ auf „geschützt“ gesetzt ist, wird ein Fehler gemeldet.

Methoden in der Klasse:


Rufen Sie ein Attribut in der Methode auf, und Sie müssen die Klasse instanziieren, um auf das Attribut zuzugreifen, und $this kann als verstanden werden Instanz dieser Klasse

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

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

Konstruktormethode (wird beim Instanziieren ausgeführt)

Die Konstruktormethode kann Parameter übergeben, die während der Instanziierung übergeben werden

Übergeben Durch die Parameter des Konstruktors wird durch Ändern der Eigenschaften im Inneren jedes Instanzobjekt anders gemacht

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

Zerstörungsmethode:

Wird bei Zerstörung ausgeführt, keine Parameter zulässig

Wird nach dem Programm automatisch ausgeführt endet, manuell freigegeben (Wenn alle Verweise auf das Objekt zerstört sind), wird der Destruktor im Voraus ausgeführt, und Sie müssen nicht bis zum Ende des Programms warten, um ihn aufzurufen

Wenn Sie einen Verweis löschen, Sie lösen lediglich die Bindung zwischen dem Variablennamen und dem Variableninhalt. Dies bedeutet nicht, dass der Variableninhalt zerstört wird

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

Der Unterschied zwischen Zuweisung und Klonen

:

$a=$b (unabhängige Referenz) und $a=& $ Die Zuweisungsmethode b (gleiche Referenz) zeigt auf dasselbe Objekt und denselben Speicherplatz; die Zuweisungsmethode

$a=clone $b zeigt auf ein anderes neues Objekt, einen anderen Block neuen Speicherplatzes.

//对象引用  在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?>

Klassenkonstante

Interner Zugriff self::constant name

Externer Zugriff erfordert keine Instanziierung: Klassenname::constant name

<?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
?>

Der Unterschied zwischen $this und self

Einer ist, dass das Objekt $this der Instanziierung entspricht. Man kann sagen, dass mit Ausnahme von statischen und konstanten Konstanten im Grunde alles andere kann diesen Kontakt verwenden;

self ist die Klasse selbst, die auf statische Eigenschaften und statische Methoden in dieser Klasse zugreifen kann, und kann auf statische Eigenschaften und statische Methoden in der übergeordneten Klasse zugreifen. Wenn Sie self verwenden, müssen Sie keine

Klassenvererbung

instanziieren, was bedeutet: Extrahieren Sie dieselben Attributmethoden und lassen Sie Unterklassen erben

extends sein, was bedeutet, dass nur eine übergeordnete Klasse vererbt werden kann

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

Die Unterklasse kann auch die Methode der übergeordneten Klasse überschreibenWenn die Unterklasse keinen Konstruktor hat , wird es aufgerufen. Wenn Sie die Konstruktormethode der übergeordneten Klasse aufrufen möchten, können Sie Ihre eigene aufrufen.

Verwenden Sie das Schlüsselwort parent:: __construct();, um die Konstruktormethode der übergeordneten Klasse aufzurufen.

Fügen Sie das letzte Schlüsselwort hinzu vor der Klasse und es wird nicht vererbt; hinzufügen Vor der Methode wird diese Methode nicht überschrieben

Namespace

(Lösen Sie das Namenskonfliktproblem)

Verwenden Sie das Prinzip dass das Dateisystem keine Verzeichnisse verwendet
Die importierte PHP-Datei Namespace-Verzeichnis-Unterverzeichnis hinzufügen;
Bei Verwendung aufrufen: neues Verzeichnis Unterverzeichnis Klassenname(); wie new comsessioncomputer();

Betroffen vom Namespace sind Klassen (einschließlich abstrakter Klassen, Merkmale), Schnittstellen, Funktionen, Konstanten (const und define werden beide zum Deklarieren von Konstanten verwendet (ihre Unterschiede werden nicht detailliert beschrieben), aber in einem Namespace wirkt define global, während const auf den aktuellen Raum wirkt. )

Es ist zu beachten, dass vor dem ersten Namensraum der aktuellen Skriptdatei kein Code stehen darf. Folgende Schreibmethoden sind falsch:

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

Da der Pfad alle geschrieben werden muss Wenn es aufgerufen wird, ist es sehr mühsam, daher wird die Verwendung von use angezeigt (use muss mit einem Klassennamen oder Funktionsnamen eingeführt werden).
Verwenden Sie use, um es beim Aufruf zuerst einzuführen. Sie können auch das Unterverzeichnis class verwenden Aliase zur Unterscheidung als

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

<?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 { }?>

Wichtiger Punkt: Beim Benennen Der Unterschied zwischen dem Aufruf globaler Klassen, Funktionen und Konstanten im Raum besteht darin, dass Seite a den Namespace-Namespace definiert, nachdem Seite b (globaler Raum) eingeführt wurde ), wenn Sie zu diesem Zeitpunkt die Klasse von Seite b aufrufen möchten, müssen Sie Folgendes tun:

Neuer venter () Fügen Sie ein

hinzu, um den globalen Raum darzustellen. Beim Aufrufen von Funktionen und Konstanten ist jedoch kein Hinzufügen erforderlich es, weil es automatisch nach dem globalen Raum sucht.

类自动加载：
当你实例化一个类时，这个类不存在，就会自动执行我们写的 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视频教程！

Das obige ist der detaillierte Inhalt vonWas ist objektorientiertes PHP? PHP-objektorientierte Zusammenfassung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!