PHP 面向对象

最新推荐文章于 2023-01-09 23:46:50 发布
最新推荐文章于 2023-01-09 23:46:50 发布
阅读量163 收藏
点赞数
分类专栏： PHP 后端 文章标签： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/userpython/article/details/107989884
版权
PHP 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
后端
13 篇文章 0 订阅
订阅专栏

创建类和对象及基本操作

<?php
    // 定义类：首字母大写，大驼峰命名
    class Humanity{
        // 定义变量
        public $name; 
        public $sex;
        public $age = 22;
        
        // 定义常量
        const HOME = 'earth';

        // 定义方法：首字母小写，小驼峰命名
        // 类方法就是一段等待执行的代码，相对于该类所有的实例都是一样的，
        // 方法里面本身并不保存数据，在该类所有的实例中方法的代码其实是共享的
        public function eat($food){
            // $this：表示当前类的对象，一般用在类的方法内
            // 调用类变量
            echo "<P>{$this->name}正在吃{$food}</p>";
            // 调用类方法
            $this->say($food); 
        }
        public function say($content){
            echo "还说{$content}真好吃";
        }
    }

    // 创建对象
    $kuse = new Humanity();

    // 设置对象属性
    $kuse->name = "苦涩";
    $kuse->sex = "男";

    // 调用对象属性
    var_dump($kuse->name);
    var_dump($kuse->sex);
    var_dump($kuse->age);

    // 添加属性，只存在于当前对象，其他对象没有该属性
    $kuse->id = 12;
    var_dump($kuse->id);  

    // 调用对象方法
    $kuse->eat("苹果");
?>

对象的遍历、复制、比较、序列化等

<?php
    // 定义类：首字母大写，大驼峰命名
    class Humanity{
        // 定义变量
        public $name; 
        public $sex;
        public $age = 22;
        
        // 定义常量
        const HOME = 'earth';

        // 定义方法：首字母小写，小驼峰命名
        // 类方法就是一段等待执行的代码，相对于该类所有的实例都是一样的，
        // 方法里面本身并不保存数据，在该类所有的实例中方法的代码其实是共享的
        public function eat($food){
            // $this：表示当前类的对象，一般用在类的方法内
            // 调用类变量
            echo "<P>{$this->name}正在吃{$food}</p>";
            // 调用类方法
            $this->say($food); 
        }
        public function say($content){
            echo "还说{$content}真好吃";
        }
    }

    // 创建对象
    $kuse = new Humanity();

    // 设置对象属性
    $kuse->name = "苦涩";
    $kuse->sex = "男";

    // 遍历对象
    echo '---------------遍历对象---------------';
    foreach ($kuse as $key=>$val){
        var_dump($key);
        var_dump($val);
    }

    // 判断一个对象是不是属于一种特定的类型
    echo '---------------判断对象类名---------------';
    var_dump($kuse instanceof Humanity);

    // 获取某个对象是由哪个类创建出来的
    echo '---------------获取对象的类名---------------';
    var_dump(get_class($kuse));

    // 对象的引用：默认按引用传递（地址传递）
    echo '---------------对象的引用---------------';
    $tongKu = $kuse;
    var_dump($tongKu);
    $kuse->name = "痛苦";
    var_dump($tongKu);

    // 对象的复制
    echo '---------------对象的复制---------------';
    $clone_kuse = clone $kuse;
    var_dump($clone_kuse);
    $kuse->age = 24;
    $clone_kuse->name = "克隆苦涩";
    var_dump($clone_kuse);
    // var_dump($kuse);

    // 对象的比较
    echo '---------------对象的比较---------------';
    $A = new Humanity();
    $A->name = "A";
    $A->sex = "女";

    $B = new Humanity();
    $B->name = "A";
    $B->sex = "女";
    // ==：属性和属性值都相等，且为同一个类的实例
    var_dump($A==$B);//true

    // ===：两个对象变量一定要指向某个类的同一个实例（同一个对象）
    var_dump($A===$B);//false
    $AA = $A;//同一个实例
    var_dump($AA === $A);//true
    $clone_A = clone $A;//克隆A
    var_dump($clone_A === $A);//false

	// 对象序列化：将对象转换成字符串
    // 序列化一个对象将会保存其所有变量及类名，但是不会保存对象的方法
    echo "---------------对象序列化-------------";
    $str = serialize($kuse);
    var_dump($str);
    
    // 反序列化
    // 能够重新把字符串变回PHP原来的值
    $unstr = unserialize($str);
    var_dump($unstr);

    // $unstr->eat('苹果');

    echo "---------------销毁对象-------------";
    unset($kuse);
    // var_dump($kuse);
?>

构造函数和析构函数

<?php
    // 定义类：首字母大写，大驼峰命名
    class Humanity{
        // 定义变量
        public $name; 
        public $sex;
        public $age = 22;
        
        // 定义常量
        const HOME = 'earth';

        // 定义构造函数
        public function __construct($name, $age){
            $this->name = $name;
            $this->age = $age;
        }

        // 定义析构函数
        // 在该类的实例被销毁时自动调用
        public function __destruct(){
            echo "<p>啊~~~，{$this->name} 被销毁了！！！</p>";
        }

        // 定义方法：首字母小写，小驼峰命名
        public function eat($food){
            echo "<P>{$this->name}正在吃{$food}</p>";
        }
    }

    // 创建对象
    $kuse = new Humanity("苦涩", '男');
    echo $kuse->name;
?>

继承

<?php
    // 定义类：首字母大写，大驼峰命名
    class Humanity{
        // 定义变量
        public $name; 
        public $sex;
        public $age = 22;
        
        // 定义常量
        const HOME = 'earth';

        // 定义构造函数
        public function __construct($name, $age){
            $this->name = $name;
            $this->age = $age;
        }

        // 定义析构函数
        // 在该类的实例被销毁时自动调用
        public function __destruct(){
            echo "<p>啊~~~，{$this->name} 被销毁了！！！</p>";
        }

        // 定义方法：首字母小写，小驼峰命名
        // 在方法前面加上final，就不能再被子类重写，属性不能定义为final
        public function eat($food){
            echo "<P>{$this->name} 正在吃 {$food}</p>";
        }
    }

    // 继承
    // Student类继承了Humanity类
    // 子类继承了父类的属性和方法，并且还可以定义自己的属性和方法
    class Student extends Humanity {
        public $stuId;

        public function test($subject){
            echo "<p>{$this->name} 正在考 {$subject}</p>";
        }

        // 方法重写，参数的个数要和父类一致，构造函数的参数个数无需和父类里面的构造函数的参数个数一致
        public function eat($food){
            echo "<P>{$this->name} 正在快速吃 {$food}</p>";
        }
    }

    // 创建子类对象
    $kuse = new Student("苦涩", '男');
    $kuse->stuId = "123";
    echo $kuse->stuId;
    $kuse->test("数学");
    $kuse->eat("菠萝", 3);

    // 获取父类的类名
    var_dump(get_parent_class($kuse));
?>

可见性

可见性分为：public（公共的）、protected（受保护的）、private（私有的）

本类里面

  • 可以 访问可见性为public的属性
  • 可以 访问可见性为protected的属性
  • 可以 访问可见性为private的属性

子类里面

  • 可以 访问可见性为public的属性
  • 可以 访问可见性为protected的属性
  • 不能访问可见性为private的属性

类的外面

  • 可以 访问可见性为public的属性
  • 不能访问可见性为protected的属性
  • 不能访问可见性为private的属性

范围解析操作符、静态成员

<?php
    class Humanity{
        public $name; 
        public $sex;
        public $age = 22;
        
        // 类常量
        const HOME = "地球";

        // 静态属性
        static public $counter = 0;

        // 定义构造函数
        public function __construct($name, $age){
            $this->name = $name;
            $this->age = $age;
        }

        public function eat($food){
            echo "<P>{$this->name} 正在吃 {$food}</p>";
        }

        public function hello(){
            echo "<p>父类：你好，我是来自".self::HOME."的外星人</p>";
        }
    }

    class Student extends Humanity {
        public $stuId;

        // 类常量
        const HOME = "火星";

        public function test($subject){
            echo "<p>{$this->name} 正在考 {$subject}</p>";
        }

        public function eat($food){
            echo "<P>{$this->name} 正在快速吃 {$food}</p>";
        }

        public function hello(){
            
            echo "<p>子类：你好，我是来自".self::HOME."的外星学生</p>";
            echo "<p>子类：你好，我是来自".parent::HOME."的外星学生</p>";

            // 在子类里面访问父类中的方法（被重写了的方法）
            parent::hello();
        }

        static public function say(){
            echo "<p>子类中的静态方法：你好，我是来自".self::HOME."的外星学生</p>";
        }
    }

    // 范围解析操作符
    // 作用：
    // 一：访问类里面的静态成员----------------------------------------------
    //     *****怎样定义？*****
    //          在定义类属性或者方法的时候，在可见性的前面或者后面加上static即可
    //          static 可见性 $属性名；
    //                  访问这些静态属性的时候和类常量一样！不同的地方在于：类常量不能修改其值，静态属性可以修改值！
    //                  每一次修改都会记录
    //                  注意：需要写上$
                echo Humanity::$counter;

    //          static 可见性 function 方法名称(){}
    //                  注意：静态方法里面不可以使用$this
                Student::say();
    //     *****作用：********
    //          静态成员和具体的实例没有关系！我们在使用这些成员的时候无需通过具体的实例！
    //          静态方法，访问的时候无需通过具体的实例
    
    // 二：访问类里面的常量--------------------------------------------------
    //     ******类内部如何访问？**************
    //           self::类常量名
    //           parent::类常量名（访问父类中的常量名）
    $a = new Humanity("苦涩", '男');
    $a->hello();
    $b = new Student("痛苦", '男');
    $b->hello();
    //     *****类外部如何访问？*****************
    //          类名称::类常量名
    echo Humanity::HOME.'<br>';

    // 三：在子类里面访问父类中的方法（被重写了的方法）--------------------------
    //        parent::方法名();
?>

抽象类和抽象方法

<?php
    // 抽象类
    // 抽象类的使命就是用来被其他类继承拓展的，直接实例化抽象类没有意义
    abstract class Humanity{
        public $name; 
        public $sex;

        // 定义构造函数
        public function __construct($name, $age){
            $this->name = $name;
            $this->age = $age;
        }

        // 抽象方法
        // 不需要定义方法的具体功能，具体功能由子类来完成
        abstract public function eat($food);
    }

    class Student extends Humanity {

        // 继承父类抽象方法，并重写
        public function eat($food){
            echo "<P>{$this->name} 正在快速吃 {$food}</p>";
        }
    }


    // -----------------------抽象类------------------------------------
    // 从语法上去限制某个类不能够被直接实例化（限制一个父类不能够被直接实例化）

    // -----------------------抽象方法------------------------------------
    // 不需要定义方法的具体功能，具体功能由子类来完成
    // 注意：在子类里面具体实现抽象方法的时候，可见性要等于高于父类里面的可见性
    //       参数个数要一致
    //       在子类里面必须要去实现抽象类里面的抽象方法
    //       只有抽象方法里面才可以有抽象方法，抽象类里面不一定要有抽象方法
    new Student('苦涩', '女');
?>

接口

<?php
    interface iA{
        public function aa();
        public function bb();
    }

    interface iB{
        public function cc();
    }

    class A implements iA, iB{
        public function aa(){

        }

        public function bb(){

        }

        public function cc(){

        }
    }

    // -----------------------接口------------------------------------
    // 接口是用来规定一个类应该怎么去写、规定一个类必须要去实现哪些方法
?>

traits

<?php
    // ------------------------traits-----------------------
    // 使得类里面的代码（主要指属性和方法）更加灵活的被复用
    // traits和include有点相似
    // 通过include技术可以引入文件
    // 通过traits技术可以引入代码


    trait tA{
        public function aa(){
            echo "<p>traits: aa....</p>";
        }
        public function bb(){
            echo "<p>bb....</p>";
        }
    }

    abstract class Dog {
        public function aa(){
            echo "<p>父类：aa....</p>";
        }
        use tA;
    }
    class Huskies extends Dog{
        public function aa(){
            echo "<p>子类：aa....</p>";
        }
        // use tA;
    }

    $a = new Huskies();
    // 优先级：父类 < traits < 子类
    $a->aa();
    $a->bb();
?>

魔术方法

<?php
    // ------------------------魔术方法-----------------------
    // 在特定时机自动执行
    // 魔术方法以 __ 开头
    // 注意：自己定义方法时，不要以 __ 开头
    // 1. __construct()
    // 2. __destruct()
    // 3. __set($name, $value)
    //          在给不可访问(不存在或可见性不够)的属性“赋值”时会自动执行
    class Human {
        public function __set($name, $value){
            echo "<p>{$name}:{$value}</p>";
        }

        public function __get($name){
            echo "<p>{$name}</p>";
        }

        public function __call($funName, $arr){
            var_dump($funName);//方法名
            var_dump($arr);//方法参数
        }
    }
    $ren = new Human();
    $ren->hhh = '哈哈哈';

    // 4. __get($name)
    //          在读取不可访问的属性时，自动自行
    var_dump($ren->hihi);

    // 5. __call($name, $arr)
    //           在对象中调用一个不可访问的方法时，自动调用
    $ren->hello('hhh', 'hihihi');
?>
苦涩2020
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php面向对象
03-04
这本书是讲解php的，它从各个方面讲解了php，先是大概讲解了php语法，然后是php怎么用面向对象，然后接着讲解了其他的重要的内容。
php-------面向对象详解
weixin_38166852的博客
06-07 155
php面向对象详解 面向对象 对象概念是面向对象技术的核心。在显示世界里我们所面对的事情都是对象，如计算机、电视机、自行车等。在面向对象的程序设计中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象. 对象的主要三个特性 对象的行为：可以对 面向对象 对象概...
PHP之面向对象（上）
weixin_30266885的博客
08-25 109
面向过程：每个小系统有着明确的开始和和结束。开始和结束之间有着严谨的因果关系。 比如：上帝创造一个人，如果有70亿人那就很麻烦 随机函数先获取随机的数字作为数组的下标，然后再从数组中获取对应下标的数字。 面向对象 引入例子：女娲人身蛇尾，用女娲造人引出类和实例：女娲造人前先思考人的形象然后再造人 所以：人的形象是抽象的，用来说明人的特点；而每...
php面向对象什么意思,全面解析PHP面向对象的三大特征
weixin_42544461的博客
03-09 265
PHP面向对象的三大特征： 继承，封装，多态一.继承1、如何实现继承？给子类使用extends关键字，让子类继承父类；class Student extends Person{}2、实现继承的注意事项？① 子类只能继承父类的非私有属性。②子类继承父类后，相当于将父类的属性和方法copy到子类，可以直接使用$this调用。③ PHP只能单继承，不支持一个类继承多个类。但是一个类进行多层继承；clas...
php面向对象详解
weixin_34200628的博客
12-02 92
前言 自从php进入5.0版本以来，PHP开始全面地支持面向对象编程。嗯，谁说php很low。我们专注web开发好不好；谁说php代码烂，自己水平不行写的代码当然烂了；谁说php框架不优雅的，你用过laravel吗。好了，进入正题，面向对象的三大特性分别是封装性，继承性以及多态性，使用面向对象开发，让我们的程序可维护以及扩展性大大提高。...
php面向对象程序设计入门教程
10-16
主要介绍了php面向对象程序设计,结合实例形式分析了PHP面向对象程序设计的基本概念、原理以及类的定义、对象实例化、构造方法等简单使用技巧,需要的朋友可以参考下
PHP面向对象概念
10-28
要详细了解PHP OO最好看PHP手册。大家都知道的部分就不说了，这里只记下容易忘记的部分
全面解析PHP面向对象的三大特征
12-17
PHP面向对象的三大特征： 继承，封装，多态 一.继承 1、如何实现继承？ 给子类使用extends关键字，让子类继承父类； class Student extends Person{} 2、实现继承的注意事项？ ① 子类只能继承父类的非私有属性。 ②...
PHP面向对象
ou_nvhai的博客
01-16 119
多态 继承（extends,class） 抽象（abstract）1 接口（interface）2 特性（trait）3 魔术函数 理解 如js的钩子。在对象的生命周期中对具体事件的回调 方法 时机 备注 __construct 创建对象时调用 对象初始化 __destruct 对象被销毁时调用 unset（obj），失去引用时，手动释放指定变量/关闭远程connect 等等 __get 读取不可访问属性时调用 比方对象的属性不存在 … … 还有很多，用到的时候再查 .
php 面向对象
帅波的博客
08-25 261
php面向对象概括 一、面向对象的概念 面向对象实现了软件工程的三个目标：重用性、灵活性和扩展性 使其编程的代码更简洁，更易于维护，并且具有更强的可重用性 面向对象的3大特点: 封装：隐藏对象的属性和实现细节 继承：从一个基类得到一个或多个类的机制 多态：根据使用类的上下文来重新定义或改变类的性质或行为 二、类和对象的关系 类是用于生成对象的代码模板 PHP中使用关键字class和一个任...
PHP的面向对象
weixin_51884452的博客
01-09 725
php面向对象详解！！！
php面向对象实例
最新发布
05-25
以下是一个简单的 PHP 面向对象实例，演示了创建类、实例化对象、定义属性和方法以及访问它们： ```php class Animal { // 定义属性 public $name; public $age; // 定义方法 function eat() { echo $this->...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值