Ringkaskan asas-asas objek PHP

Artikel ini membawa anda pengetahuan yang berkaitan tentang PHP, yang terutamanya memperkenalkan isu berkaitan pengaturcaraan berorientasikan objek Intipati pengaturcaraan berorientasikan objek adalah untuk meningkatkan subjek operasi data dan fungsi, iaitu , objek Semoga ia membantu semua orang.

Pembelajaran yang disyorkan: "Tutorial PHP"

Pembelajaran praktikal php, thinkphp, Redis, vue, uni-app dan lain-lain teknologi, Sistem e-dagang sumber terbuka yang disyorkan likeshop, anda boleh belajar daripada idea, anda boleh pergi ke hak cipta untuk kegunaan komersial percuma, alamat muat turun gitee:
Klik untuk memasukkan alamat projek

Berorientasikan objek: Pengaturcaraan OOP (objected oriented programming)

Process-oriented ialah idea pengaturcaraan

Intipati pengaturcaraan berorientasikan objek adalah untuk meningkatkan subjek operasi data dan fungsi, iaitu objek

Semua data dan fungsi dalam berorientasikan objek kebanyakannya terdiri daripada subjek (objek ) untuk dipanggil dan dikendalikan

Asas berorientasikan objek

Perbezaan antara berorientasikan proses dan berorientasikan objek

Kata kunci berorientasikan objek

• Kelas: kelas, mentakrifkan struktur terluar subjek berorientasikan objek, digunakan untuk membalut data subjek dan functions (functions)
• Objek: objek, wakil khusus bagi jenis transaksi tertentu, juga dipanggil instance
• Instantiation: baharu, proses objek menjana kelas
• Ahli kelas: ahli
  • Kaedah: kaedah, pada asasnya fungsi yang dicipta dalam struktur kelas, dipanggil Kaedah ahli atau fungsi ahli
  • Atribut: sifat, pada asasnya pembolehubah yang dicipta dalam struktur kelas, dipanggil pembolehubah ahli
  • Pemalar kelas: const, pada asasnya dicipta dalam struktur kelas Pemalar

Buat objek

<?phpclass  People{}$man=new People();# 实例化类，man就是对象var_dump($man);?>
    # 输出object(People)#1 (0) { }
    #1表示：对象编号，与类无关，是整个脚本中对象的序号(0)表示：成员变量（属性）个数{}表示：具体成员变量信息（键值对）

Objek kelas

<?phpclass  Buyer{
    # 常量声明
    const BIG_NAME=&#39;BUYER&#39;;
    # 常量不需要加 $

    # 属性声明
    # $name;
    # 错误的，类内部属性必须使用访问修饰限定符
    public $name;
    public $money=0;
    
    # 方法声明
    function display(){
        echo __CLASS__;
        # 魔术常量，输出类名
        # 方法内部变量属于局部变量
    }}# 实例化$a = new Buyer();# 属性操作，增删改查echo $a->money;$a->money='20';$a->sex='male';unset($a->name);echo '<br>';# 方法操作$a->display();echo '<br>';var_dump($a);?>
    # 输出0Buyerobject(Buyer)#1 (2) { ["money"]=> string(2) "20" ["sex"]=> string(4) "male" }

Nota: Pemalar kelas tidak diakses oleh objek

Kelayakan pengubahsuaian akses

Kata kunci pengubahsuaian sebelum atribut atau kaedah, digunakan untuk mengawal lokasi akses atribut atau kaedah

• awam: awam, dalam kelas dan Boleh diakses dari luar kelas
• dilindungi: dilindungi, hanya dibenarkan untuk diakses dalam kelas yang berkaitan
• peribadi: persendirian, hanya dibenarkan untuk diakses dalam atribut kelas penentu

Mesti ada kelayakan pengubah suai akses Kaedah ini tidak boleh mempunyai kelayakan pengubah suai akses Nilai lalainya ialah kelas dalaman objek

$this Objek yang dibina ke dalam kaedah akan secara automatik menunjuk ke kaedah yang akan dipanggil. berada dalam struktur kelas

dan boleh mengakses mana-mana ahli yang diubah suai oleh kelayakan pengubahsuaian akses

Ahli persendirian diakses melalui kaedah awam (kaedah awam boleh diakses di luar kelas )

• $ini mewakili objek, dan persekitaran di mana $this terletak berada di dalam kaedah kelas, jadi objek $this boleh diakses di dalam kelas, jadi semua sifat dan kaedah adalah tidak dihadkan oleh pengubah suai akses

<?phpclass  Article{
    protected $name = &#39;a&#39;;
    private $type = &#39;art&#39;;

    public function get_name()
    {
        var_dump($this);
    }}$a = new Article();var_dump($a);?>
    # 输出object(Article)#1 (2) { ["name:protected"]=> string(1) "a" ["type:private"]=> string(3) "art" }

Kaedah pembina

__construct() ialah kaedah ajaib terbina dalam sistem Ciri kaedah ini ialah selepas objek dijadikan instantiated, objek itu serta-merta Tujuan memanggil

• secara automatik. pembina adalah untuk memulakan sumber, termasuk sifat objek dan sumber lain

• Setelah pembina ditakrifkan, dan pembina Kaedah mempunyai parameter sendiri, jadi anda hanya boleh menggunakan nama kelas baharu ( senarai parameter) untuk membuat instantiat dengan betul

• Kaedah ajaib juga boleh dipanggil terus melalui objek, tetapi ia tidak berguna

• Kaedah pemusnah

<?phpclass  Article{
    public $name=&#39;xiaoli&#39;;
    private $sex="male";

    public function __construct($name,$sex)
    {
        $this->name = $name;
        $this->sex = $sex;
    }}$a = new Article('xiaowang', 'famale');var_dump($a);?>

__destruct(), yang dipanggil secara automatik apabila objek dimusnahkan untuk melepaskan sumber

Pemusnahan objek

• Objek tidak mempunyai pembolehubah menunjuk (pembolehubah menghala ke data lain)
• Objek dimusnahkan secara aktif (tidak ditetapkan memusnahkan pembolehubah objek)
  1. Pelaksanaan skrip tamat (sumber dikeluarkan secara automatik)
  3. Selepas skrip PHP dilaksanakan, semua sumber akan dikeluarkan, jadi kaedah pemusnah biasanya kurang digunakan
• Nilai yang melalui objek

Definisi: The objek akan disimpan Pembolehubah ditugaskan kepada pembolehubah lain

<?phpclass  Article{
    protected $name = &#39;xiaoli&#39;;
    private $sex = &#39;famale&#39;;

    public function __destruct()
    {
        // TODO: Implement __destruct() method.
        echo __FUNCTION__;
    }}$a=new Article();# 销毁对象$a=1;unset($a);# __destructendecho &#39;end&#39;;?>
    # 不销毁对象，php在运行结束也会释放资源# end__destruct

Dalam PHP, nilai objek dihantar melalui rujukan: iaitu, satu pembolehubah objek diberikan kepada pembolehubah lain, dan dua pembolehubah menghala ke yang sama alamat objek, iaitu, hanya terdapat satu objek

Pengendali resolusi julat (akses tetap kelas)

mempunyai dua titik bertindih yang terdiri daripada "::", yang digunakan khas untuk

<?phpclass  Article{
    public $name = &#39;xiaoli&#39;;
    public $sex = &#39;famale&#39;;}$a=new Article();$b=$a;var_dump($a,$b);echo &#39;<br>';$a->name="wangxiaohu";var_dump($a,$b);echo '<br>';?>
    # 输出object(Article)#1 (2) { ["name"]=> string(6) "xiaoli" ["sex"]=> string(6) "famale" } object(Article)
    #1 (2) { ["name"]=> string(6) "xiaoli" ["sex"]=> string(6) "famale" }object(Article)
    #1 (2) { ["name"]=> string(10) "wangxiaohu" ["sex"]=> string(6) "famale" } object(Article)
    #1 (2) { ["name"]=> string(10) "wangxiaohu" ["sex"]=> string(6) "famale" }

kelas untuk melaksanakan operasi ahli kelas

, yang boleh melaksanakan kelas Akses terus kepada ahli kelas

pengendali resolusi skop digunakan untuk mengakses ahli kelas menggunakan

• skop Operator penghuraian juga boleh digunakan oleh objek sebagai kelas (tidak disyorkan)

  类名::类成员

• Pemalar kelas hanya boleh diakses oleh kelas

  $对象名::类成员

• Pemalar kelas adalah tetap, tetapi sifat objek berbeza untuk objek berbeza



静态成员

定义：使用 static 关键字修饰的类成员，表示该成员属于类访问

• 静态成员
  • 静态属性
  • 静态方法
• 静态成员是明确用来给类访问的，而不是对象
• 静态成员只是多了一个 static 关键字修饰，本身也可以被对象访问
• 静态成员同样可以使用不同的访问修饰限定符限定，效果一致

<?phpclass  Article{
    public static $name = &#39;hlm&#39;;
    public static $type = &#39;art&#39;;

    public static function getName()
    {
        return self::$name;
    }}# 静态属性$a = new Article();echo Article::$name;# 静态方法echo Article::getName();?>

self关键字

• 在类的内部（方法里面）使用，代替类名的写法
• self 如同 $this 代表内部对象一样，能够在方法内部代替当前类名
• 能够保障用户方便修改类名字
• self 关键字是代替类名，所以需要配合范围解析操作符 ::

<?phpclass  Article{
    public static function getInstance1()
    {
        return new self();
    }

    public static function getInstance2()
    {
        return new Article();
    }}$a = Article::getInstance1();$b = Article::getInstance2();var_dump($a,$b);?>
    # 输出object(Article)
    #1 (0) { } object(Article)
    #2 (0) { }

类加载

类的访问必须保证类在内存中已经存在，所以需要再用类之前将类所在的 PHP 文件加载到内存中

• 类的加载分为两种

  • 手动加载：在需要使用类之间通过 include 将包含类的文件引入到内存
  • 自动加载：提前定义好类结构和位置，写好引入类文件代码，在系统需要类而内存不存在的时候想办法让写好的加载类的代码执行（自动加载是自动运行写好的加载类的代码）

• 自动加载两种方式

  • 魔术函数 __autoload：系统自动调用，需要传入类名，在函数内部实现类的手动加载（PHP7及之后不建议使用此方法）

  function __autoload($classname){
      # 找到对应的文件路径和命名规范，手动加载}

   
  • 自定义函数：自己定义类的加载实现，然后通过 spl_autoload_register 注册到自动加载机制（可注册多个自动加载）

  # 自定义类加载函数function 自定义函数($classname){
      # 找到对应的文件和命名规范，手动加载}#注册自动加载sql_autoload_register('自定义函数名字')

自动加载要求在声明类的时候有良好的规范

• 类名与文件名一致：类名.php 或者 类名.class.php
• 类文件分类放好

例：手动加载

Article.php

<?phpclass  Article{
    public function getName(){
        return __METHOD__;
    }}

mian.php

<?php # include &#39;Article.php&#39;;# 直接加载比较消耗资源，而且如果类已经在内存中存在，直接include会报错，建议判断后再加载if(!class_exists(&#39;Article&#39;)){
    include &#39;Article.php&#39;;}$a=new Article();var_dump($a->getName());
    # outputstring(16) "Article::getName"

自动加载

• __autoload（不建议使用）

一个系统中，可能类文件会放到不同的路径下，因此一个完整的自动加载函数，应该要进行文件判定功能

<?php function __autoload($classname){
    # 形参代指 类名
    #组织文件路径，假设当前路径下，有两个文件夹下都有类c和类m
    $c_file = &#39;c/&#39; . $classname . &#39;.php&#39;;
    if (file_exists($c_file)) {
        include_once($c_file);
        return true;
    } 
    //if 语句如果只有一行不需要加 {}
    //include_once 只加载一次

    $m_file = &#39;m/&#39; . $classname . &#39;.php&#39;;
    if (file_exists($m_file)) {
        include_once($m_file);
        return true;
    }
}


$a=new Article();
$b=new Article();

• spl_autoload_register

<?phpfunction  autoload01($classname){
    if(!class_exists($classname)){
        $file_name=$classname.&#39;.php&#39;;
        if(file_exists($file_name)) include_once $file_name;
    }}spl_autoload_register(&#39;autoload01&#39;);$a=new Article();

对象克隆

通过已有的对象复制一个新的同样的对象，但两者之间并非同一个对象

面向对象高级

面向对象三大特性

封装、继承、多态

类的封装

类的继承

inherit，子类合法拥有父类的某些权限

• 继承必须满足继承关系：即存在合理的包含关系
• 继承的本质是子类通过继承可以直接使用父类已经存在的数据和数据操作
• PHP 使用 extends 关键字表示继承

子类也称派生类

父类也称基类

# 父类class Human{}# 子类继承class Man extends Human{}

类的多态

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果

• 需要发生类的继承，同时出现方法的重写（override），即子类拥有与父类同名的方法
• 在实例化对象的时候让父类对象指向子类对象（强制类型，PHP不支持，PHP 弱类型很灵活）
• 结果：父类对象表现的子类对象的特点

—PHP继承—

<?phpclass  Human{
    public function show(){
        echo __METHOD__;
    }}class Man extends Human{}$m=new Man;$m->show();

有限继承

子类在继承父类的成员时，并非继承所有内容，而是继承并使用父类部分内容

• Intipati warisan dalam PHP ialah warisan objek
• Kandungan yang diwarisi dalam PHP: semua ahli awam, ahli dilindungi dan harta persendirian kelas induk, kaedah persendirian tidak boleh diwarisi
• Ahli yang dilindungi adalah eksklusif untuk warisan dan boleh diakses dalam kelas induk atau subkelas
• Ahli persendirian hanya boleh diakses dengan menetapkan kaedah awam atau dilindungi dalam kelas yang mereka milik
• Kaedah struktur dan kaedah pemusnah boleh diwarisi oleh subkelas,

override Override

override, dan subclass mentakrifkan ahli dengan nama yang sama dengan kelas induk

kata kunci induk

Ungkapan untuk mengakses ahli kelas induk secara eksplisit

Selepas kaedah ditindih, akses yang dipanggil It is kaedah subkelas Jika anda ingin mengakses kaedah kelas induk, anda boleh memaksa akses kepada kaedah kelas induk dengan menggunakan kaedah induk dalam kaedah subkelas

ibu bapa tidak boleh digunakan untuk mengakses atribut kelas induk (statik. atribut boleh)

Ciri warisan PHP

• PHP hanya boleh mewarisi tunggal, hanya satu kelas induk (jika anda mewarisi berbilang kelas, anda boleh menggunakan warisan rantai)
• Dalam pewarisan PHP, hanya terdapat kaedah Persendirian tidak boleh diwarisi
• PHP membenarkan pewarisan pembina dan pemusnah dalam kelas induk

Pengikatan tertunda statik

Kelas Akhir Akhir

Gunakan kata kunci akhir untuk mengubah suai nama kelas, menunjukkan bahawa kelas ini tidak boleh diwarisi

Kata kunci akhir boleh juga mengubah suai kaedah dan mewakili kaedah Tidak boleh ditindih (biasanya kelas ini tidak menggunakan kata kunci akhir)

Abstrak kelas abstrak

Kelas yang diubah suai dengan abstrak kata kunci, menunjukkan bahawa Kelas hanya boleh diwarisi dan tidak boleh dijadikan instantiated

Kata kunci abstrak boleh mengubah suai kaedah, menunjukkan bahawa kaedah tersebut ialah kaedah abstrak tidak mempunyai badan kaedah (tiada {})

Kelas dengan kaedah abstrak Mestilah kelas abstrak

Kelas yang mewarisi kelas abstrak mestilah sama ada kelas abstrak atau melaksanakan semua kaedah abstrak dalam kelas abstrak

penggunaan semula kod sifat

Berlaku untuk situasi di mana terdapat kod biasa antara kelas yang berbeza, tetapi tiada hubungan warisan antara kelas Dalam kes ini, kod biasa boleh disimpan dalam sifat .

Ciri boleh mempunyai ahli yang boleh dimiliki oleh kelas (termasuk statik), kaedah ahli (termasuk kaedah statik dan abstrak), tetapi tidak boleh mempunyai pemalar kelas

sifat digunakan. untuk penggunaan semula kod, tidak boleh dijadikan instantiated, tidak boleh diwarisi

sifat mempunyai nama yang sama

Sesebuah kelas mungkin perlu memperkenalkan berbilang ciri, dan nama yang sama mungkin muncul dalam ciri yang berbeza

Antara muka tidak boleh dibuat seketika, tetapi kelas boleh melaksanakan antara muka

nama antara muka antara muka{}

nama kelas melaksanakan nama antara muka{}

ahli antara muka

Ahli antara muka hanya boleh mempunyai dua jenis

Pemalar antara muka: const

Kaedah antara muka biasa (kaedah biasa dan kaedah statik)

lebihan PHP
• lebih muatan bermakna berbilang kaedah dengan nama yang sama boleh muncul dalam kelas, tetapi bilangan dan jenis parameter adalah berbeza

Digunakan untuk toleransi kesalahan

Pemuatan berlebihan atribut

Apabila objek mengakses keizinan yang tidak wujud atau tidak mencukupi, kaedah ajaib dicetuskan secara automatik untuk mengelakkan kod daripada menjadi salah. Dicetuskan apabila mengakses atribut yang tidak wujud atau mempunyai kebenaran yang tidak mencukupi

__set(nama atribut, nilai atribut) : Dicetuskan apabila menetapkan atribut yang tidak wujud atau mempunyai kebenaran tidak mencukupi

__isset(nama atribut ): Dicetuskan apabila menentukan atribut yang tidak wujud atau mempunyai kebenaran yang tidak mencukupi

__unset(nama atribut): Padam sifat tidak wujud atau dibenarkan Dicetuskan apabila atribut tidak mencukupi

__tostring(): Sebagai rentetan

kaedah terlebih beban

• objek atau akses kelas tidak wujud atau Kaedah dengan kebenaran yang tidak mencukupi, secara automatik mencetuskan kaedah ajaib untuk menjadikan kod bebas ralat
• • __cal(方法名，方法参数列表)：调用不存在或者权限不够的方法时触发
  • __callStatic(方法名，方法参数列表)：调用不存在或者权限不够的静态方法时触发

  对象遍历

  将对象中的所有属性以键值对的形式取出并进行访问

  • 对象是一种复合数据类型，对象中真正保存的内容是属性

  • 对象的属性本质也是一种键值对关系：名字 = 值

  • 对象遍历就是利用 foreach 对对象中的属性进行取出解析

  • 对象遍历遵循访问修饰限定符的限定：即类外只能遍历所有共有属性

    foreach(对象变量 as [属性名变量 =>] 属性值变量){
        #属性名变量代表取出的每个属性的名字
        #属性值变量代表取出的每个属性的值}

    

  Iterator 迭代器

  

  生成器

  

  

  yield 关键字

  设计模式

  design pattern，是软件开发人员在软件开发过程中问题的解决方法

  单例模式

  singleton，是一种类的设计只会最多产生一个对象的设计思想

  保证资源唯一性

  工厂模式

  。。。。。。

  命名空间

  namespace，指人为的将内存进行分隔，让不同内存区域的同名结构共存，从而解决在大型项目能出现重名结构问题

  

  基础语法：

  namespace 关键字定义空间

  命名规则

  字母、数字、下划线，不能以数字开头

  命名空间必须写在所有代码之前，定义了一个，之后可以定义多个

  

  子空间

  subspace，即在已有空间之上，再在内部进行空间划分

  子空间直接通过 namespace+路径符号 \ 实现

  非限定名称

  直接访问元素本身，代表当前所属空间（当前目录）

  限定名称

  使用空间名+原名，代表访问当前空间子空间（当前目录子目录）

  完全限定名称

  从根目录（全局空间）开始访问，使用 \ 作为全局空间开始符号（根目录）

  全局空间元素访问：使用完全限定名称访问

  

  命名空间引入

  

  推荐学习：《PHP视频教程》

Atas ialah kandungan terperinci Ringkaskan asas-asas objek PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!