12月03日_类与对象（OOP编程基本流程、 类与实例的引用、构造方法、类成员的访问控制、继承接口抽象）

1. OOP的基本步骤

<?php
// 面向对象（OOP）基本步骤
// 1. 创建类
class Demo1{
    // 2. 添加类成员
    // 创建属性
    public $name = '猪小明';
    // 创建方法
    public function getName(){
        // 第一步：类的实例化
        $obj = new Demo1;
        // 第二步：返回类属性
        return '我的名字是：' . $obj->name;
    }
}
// 3. 访问类成员
$obj = new Demo1;
echo $obj->name . '<br>';
echo $obj->getName();

2. 类与实例的引用

<?php
// 1. 创建类
class Demo2{
    // 2. 添加类成员
    public $name = '猪小明';
    public $age = 18;
    public function getName(){
        return '我的名字是：' . $this->name;
    }
    public function getAge(){
        return '我的年龄是：' . $this->age . '岁';
    }
}
// 3. 访问类成员
$obj = new Demo2();
echo $obj->getName() . '<br>';
echo $obj->getAge() . '<br>';

3. 构造方法

<?php
// 1. 创建类
class Demo3{
    // 2. 添加类成员
    public $name;
    public $age;
    // 构造方法
    // 1. 类实例的初始化
    // 2. 自动完成在类实例创建过程中的操作
    public function __construct($name,$age){
        $this->name = $name;
        $this->age = $age;
        // 在类实例化时自动会被执行
        echo $this->getInfo();
    }
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '岁';
    }
}
// 3. 访问类成员
new Demo3('猪小明', 18);

4. 类成员的访问控制以及属性重载

<?php
// 1. 创建类
class Demo4{
    // 2. 添加类成员
    public $name;
    // 如果不想让该属性在类的外部被访问，可以将该属性的访问控制符修改为：
    // private 私有成员，protected 受保护成员
    protected $age;
    private $job;
    public function __construct($name,$age,$job){
        $this->name = $name;
        $this->age = $age;
        $this->job = $job;
    }
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '，我的工作是：' . $this->job;
    }
    // 属性重载, 通过魔术方法 __get($name), __set($name,$value), __isset($name), __unset($name)
    public function __get($name){
        $username = $_GET['username'] ?? '';
        if (isset($username) && $username === 'admin'){
            return $this->$name ?? '属性未定义';
        }
        return '无权访问';
    }
    public function __set($name, $value){
        $username = $_GET['username'] ?? '';
        if (isset($username) && $username === 'admin'){
            echo isset($this->$name) ? $this->$name=$value : '属性不存在';
        }else{
            echo '无权修改';
        }
    }
    public function __isset($name){
        $username = $_GET['username'] ?? '';
        if (isset($username) && $username === 'admin'){
            echo isset($this->$name) ? '存在该属性' : '没有改属性';
        }else{
            echo '无权检测';
        }
    }
    public function __unset($name){
        $username = $_GET['username'] ?? '';
        if (isset($username) && $username === 'admin'){
            unset($this->$name);
            echo '删除成功';
        }else{
            echo '无权删除';
        }
    }
}
// 3. 访问类成员
$obj = new Demo4('猪小明',18,'程序员');
echo $obj->age . '<br>';
$obj->job = '老师';
echo '<br>';
isset($obj->sex);
echo '<br>';
unset($obj->age);

5. 类的继承

<?php
// 类的继承
// 1. 创建类
class Demo5{
    // 2. 添加类成员
    public $name;
    protected $age;
    private $job;
    public function __construct($name,$age,$job){
        $this->name = $name;
        $this->age = $age;
        $this->job = $job;
    }
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '，我的工作是：' . $this->job;
    }
}
class Demo5_1 extends Demo5{
    private $salary;
    public function __construct($name, $age, $job,$salary){
        // parent:: 调用 父类中的成员
        parent::__construct($name, $age, $job);
        $this->salary = $salary;
    }
    // 重写父类中的方法
    public function getInfo(){
        return parent::getInfo() . '，我的工资是：' . $this->salary;
    }
}
// 3. 访问类成员
$obj = new Demo5_1('猪小明',18,'程序员',12000);
echo $obj->getInfo();

6. trait技术

<?php
// trait: 代码复用方式，用来扩展当前类的功能
// trait: 当成一个公共方法库
// trait使用了类的定义的语法，但不是类，所以不能实例化
trait Test{
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '，我的工作是：' . $this->job;
    }
}
// 1. 创建类
class Demo6{
    // 导入trait类库
    use Test;
    // 2. 添加类成员
    public $name;
    protected $age;
    private $job;
    public function __construct($name,$age,$job){
        $this->name = $name;
        $this->age = $age;
        $this->job = $job;
    }
}
class Demo6_1 extends Demo6{
    private $salary;
    public function __construct($name, $age, $job,$salary){
        // parent:: 调用 父类中的成员
        parent::__construct($name, $age, $job);
        $this->salary = $salary;
    }
    // 重写父类中的方法
    /*public function getInfo(){
        return parent::getInfo() . '，我的工资是：' . $this->salary;
    }*/
}
// 优先级：当前类中的同名方法 > trait类中的同名方法 > 父类中的同名方法
// 3. 访问类成员
$obj = new Demo6('猪小明',18,'Java工程师');
echo $obj->getInfo() . '<br>';
$obj1 = new Demo6_1('张三',24,'PHP工程师',12000);
echo $obj1->getInfo();

7. 接口interface

<?php
// 接口
interface iDemo{
    public function getInfo();
    public function getJob();
}
// 1. 创建类
class Demo7 implements iDemo{
    // 2. 添加类成员
    public $name;
    protected $age;
    private $job;
    public function __construct($name,$age,$job){
        $this->name = $name;
        $this->age = $age;
        $this->job = $job;
    }
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '，我的工作是：' . $this->job;
    }
    public function getJob(){
        return '我是一名优秀的' . $this->job;
    }
}
// 3. 访问类成员
$obj = new Demo7('猪小明',18,'php程序员');
echo $obj->getInfo() . '<br>';
echo $obj->getJob() . '<br>';

8. 抽象类abstract

<?php
// 抽象类：包含抽象方法
// 接口全是抽象方法
// 抽象类中可以有普通方法
abstract class Demo{
    abstract public function getInfo();
    public function getSalary($salary){
        return '我的工资是：' . $salary;
    }
}
// 1.创建类
class Demo8 extends Demo{
    // 2. 添加类成员
    public $name;
    protected $age;
    private $job;
    public function __construct($name,$age,$job){
        $this->name = $name;
        $this->age = $age;
        $this->job = $job;
    }
    public function getInfo(){
        return '我的名字叫：' . $this->name . '，我今年' . $this->age . '岁，我的工作是：' . $this->job;
    }
}
// 3. 访问类成员
$obj = new Demo8('猪小明',22,'程序员');
echo $obj->getInfo() . '<br>';
echo $obj->getSalary(20000);

9. 总结

通过以上实例的练习，对类与对象有了更深刻的认识和理解。

（重点）OOP编程基本流程:

• 创建类
• 添加类成员
• 访问类成员