面向对象编程-第九期php线上班

12月03日作业:

1. 手抄课堂笔记: 1203.md (必做)

2. 编程代码,抄写课堂案例,也可以自定义(选做)

demo1.php

<?php
    //OOP基本步骤
//1.创建类
class Demo1{
//2.添加类成员
    //在类中的变量和函数，和程序中的变量与函数有区别，添加了访问控制符
    //套马甲 变量->属性 ， 函数 -> 方法 ，先写访问控制符，跟着写成员
    //    创建属性
    public $site='php中文网';
    //创建方法
    public function getSite(){
//        输出当前类的属性
//        第一步，类的实例化
        $obj=new Demo1();
        return $obj->site.'欢迎您！~~';
        //第二步，然后返回值
    }
}
//3.访问类成员
//可以在类的外部进行访问
//先要创建类的实例才能访问里面的成员
$obj=new Demo1();
//访问属性 和 访问方法 都叫 访问类成员 使用对象成员访问符 ->
echo  $obj -> site .'<br>'; //访问属性
echo $obj ->getSite(); //访问方法

demo2.php

<?php
//1.创建类
class Demo2{
//2.添加类成员
    public $site='php中文网';
    public $role='讲师';
    public function getSite(){
//        第一步，类的实例化；self是类名的引用，始终与当前类名绑定
//        $obj=new self;
        return $this->site.'欢迎您！~~';
//        $this是当前类的实例的引用，伪对象，它始终与当前类的实例绑定
        //第二步，然后返回值
    }
    public function getRole(){
//        第一步，类的实例化;self是类名的引用，始终与当前类名绑定
//        $obj=new self;
        return $this->role;
        //第二步，然后返回值
    }
}
//3.访问类成员
$obj=new Demo2();
//访问属性 和 访问方法 都叫 访问类成员 使用对象成员访问符 ->
echo  $obj -> site .'<br>'; //访问属性
echo $obj ->getRole().'<br>'; //访问方法

demo3.php

<?php
//1.创建类
class Demo3{
//2.添加类成员
    public $site; //变成抽象属性，先不赋值，不写死，不给值默认值是null，后面通过构造函数进行传值
    public $role;
    public function getInfo(){
        return '我是：'.$this->site.$this->role;
    }
//构造方法：在实例化的时候系统自动调用 魔术方法 名称固定 __construct()
//构造方法一般完成两件事情：1.类实例的初始化；2.自动完成在类实例创建过程中的操作
    public function __construct($site,$role)
    {
        //1.初始化类成员 ☆☆☆☆☆☆☆☆☆ 
        $this->site=$site;
        $this->role=$role;
//        //2.创建类实例           //辅助理解，这么写不对，但过程存在
//        $obj=new self();
//        // 3.添加类实例成员     //辅助理解，这么写不对，但过程存在
//        $obj->site=$this->site;
//        $obj->role=$this->role;
//        创建时同步自动执行的代码 ☆☆☆☆☆☆☆☆☆
        echo $this->getInfo(); //放在return前面，自动创建时执行才有意义
//        4.返回类实例         //辅助理解，这么写不对，但过程存在
//        return $obj;
    }
}
//3.访问类成员
$obj=new Demo3('PHP 英文网English','Docter'); //构造方法要传参，访问时也要给参数

demo4.php

<?php
//访问控制，实现对类的封装
//1.创建类
class Demo4{
//2.添加类成员
    public $site; //变成抽象属性，先不赋值，不写死，不给值默认值是null，后面通过构造函数进行传值
//    不想让该属性在类的外部被访问，可以将该属性的访问控制符修改为：private或者protected
    private $role;
//    private $name='emagic';
    public function getInfo(){
        return '我是：'.$this->site.$this->role;
    }
    //构造方法：
    public function __construct($site,$role)
    {
        //1.初始化类成员 ☆☆☆☆☆☆☆☆☆
        $this->site=$site;
        $this->role=$role;
    }
//    外部无权访问，是为了防止非法访问，不代表禁止访问
//为这样的属性创建一个访问器方法，来过滤访问请求
//    public function getRole(){
////        仅允许指定用户名的账户访问，其他用户返回无权访问提示
//        $username=$_GET['username']??'';
////        等同于之前版本的$username=isset($_GET['username'])?$_GET['username']:'无权访问';
//        if(isset($username) && $username ==='admin') {
//            return $this->role;
//        }else{
//            return '无权访问';
//        }
//    }
//    public function getName(){
//       return isset($this->name)?$this->name:'不存在该属性';
//    }
//    魔术方法  __get($要取的属性)，属性重载
    public function __get($name){
//        仅允许指定用户名的账户访问，其他用户返回无权访问提示
        $username=$_GET['username']??'';
//        等同于之前版本的$username=isset($_GET['username'])?$_GET['username']:'无权访问';
        if(isset($username) && $username ==='admin') {
            return isset($this->$name)?$this->$name:'属性未定义';
        }else{
            return '无权访问';
        }
    }
}
//3.访问类成员
$obj = new Demo4('www. PHP 法文网 .io','讲师');
echo $obj->role .'<br>'; //封装后的private、protected从外部不能直接这样访问，要用访问器，除非使用了属性重载 如__get，就可以使用
//使用访问器方法访问 ☆☆☆☆☆
//echo $obj->getRole();
echo '<hr>';
//echo $obj->name; //对于不存在的数据如何控制操作
//echo $obj->getName(); //使用访问器方法访问 ☆☆☆☆☆

demo5

<?php
//类的继承
//1.创建类
class Demo5
{
//2.添加类成员
    public $site;
    private $role;
//    private $name='emagic';
    public function getInfo()
    {
        return '我是：' . $this->site . '讲师：'.$this->role;
    }
    //构造方法：
    public function __construct($site, $role)
    {
        $this->site = $site;
        $this->role = $role;
    }
}
class Demo5_1 extends  Demo5{
    //子类也是个类
    private $course;//继承是为了发展，扩展属性,当前子类的自身属性
    public function __construct($site, $role, $course)
    {
      //  parent调用父类的构造方法
        parent::__construct($site, $role);
        $this->course=$course;
    }
            //  重写父类中的方法也是一种扩展
        public function getInfo()
        {
            return parent::getInfo().',负责的课程是：'.$this->course;
        }
}
//3.访问类成员
$sub = new Demo5_1('PHP粤语网','Emagic','php');
echo $sub->getInfo();

demo6.php

<?php
//trait代码复用方式，用来扩展当前类的功能
//trait当做公共方法库，代码库
//trait借助了累的定义的语法，但不是类，所以不能实例化
trait Test{
    public function getInfo(){
        return '我是：'.$this->site.'讲师'.$this->role;
    }
}
//1.创建类
//将一个trait类库嵌入到类库中，Demo6又可以叫做宿主类
class Demo6{
    //如何导入trait类库，用关键字use
    use Test;
//    2.添加类成员
    public $site;
    protected $role;
//    public function getInfo(){
//        return '我是：'.$this->site.'讲师'.$this->role;
//    }
    //构造方法
    public function __construct($site,$role)
    {
        $this->site=$site;
        $this->role=$role;
    }
}
//trait 还可以用在类的继承的上下文环境中
class Demo6_1 extends Demo6{
//    当前子类的自身属性
    private $course;
    public function __construct($site, $role,$course)
    {
        //parent调用父类中的成员
        parent::__construct($site, $role);
        $this->course=$course;
    }
//    重写父类中的方法
    public function getInfo()
    {
        return parent::getInfo().',负责的课程是：'.$this->course;
    }
}
//优先级关系：当前类中的同名方法>trait类中的同名方法>父类中的同名方法
//3.访问类成员
$obj = new Demo6('php 蚊子网','emagic');
echo $obj->getInfo();
echo '<hr>';
$sub= new Demo6_1('php.io','莫小仙','php');
echo $sub->getInfo();

demo7

<?php
//接口
//对象的模板是类，类的模板是哪个？类的模板就是接口
//面向接口编程是最重要的编程思想之一，许多高级应用都严重依赖于它
//接口是一种约定，他是定义了实现它的类中必须实现的方法
//接口中没有方法都是具体实现，所以不能实例化。
//接口定义工作类中的方法原型
interface iDemo{
    //php有接口常量和接口防范，接口常量一般用做配置文件
    public function getinfo(); //接口中没有具体事下，所以不用花括号{}
    public function hello();
}
//1.创建类
//Demo7实现了接口的方法，现在叫工作类.接口定义的方法出现几个它必须都要实现几个
class Demo7 implements iDemo
{
//2.添加类成员
    public $site;
    protected $role;
    public function getInfo(){
        return '我是：'.$this->site.'讲师'.$this->role;
    }
    public function hello()
    {
       return 'Hello 大家晚上吃好了吗?';
    }
    //构造方法
    public function __construct($site,$role)
    {
        $this->site=$site;
        $this->role=$role;
    }
}
//3.访问类成员
$obj=new Demo7('php泰文网','peter猜');
echo $obj->getInfo().'<br>';
echo $obj->hello().'<br>';

demo8.php

<?php
//抽象类
//接口中全是抽象方法，而抽象类中有抽象方法也有具体已实现的方法，两者共同之处就是都不能实例化，因为有抽象方法
abstract class Chouxiang{
    //抽象方法 未实现，加abstract，子类要实现
    abstract public function getInfo ();
    //具体方法，已实现方法
    public function hello()
{
    return 'Hello 大家晚上吃好了吗?';
}
}
//1.创建类
//Demo8 工作类
class Demo8 extends Chouxiang
{
//2.添加类成员
    public $site;
    protected $role;
    public function getInfo(){
        return '我是：'.$this->site.'讲师'.$this->role;
    }
    //构造方法
    public function __construct($site,$role)
    {
        $this->site=$site;
        $this->role=$role;
    }
}
//3.访问类成员
$obj=new Demo8('php俄文网','Zhu洛夫斯基');
echo $obj->getInfo().'<br>';
echo $obj->hello().'<br>';

对着天空,将OOP编程的三大步骤,大声的喊10遍

课堂小结

1.Demo1 经常性访问类的成员，会频繁实例化，每次都要$obj=new Demo2()，且受类名变动影响大

编程要做到一处更新处处有效

2.Demo2 改进了demo1 ,self是类名的引用，始终实现与当前类名绑定

但仍有个问题没有解决，$obj是当前类的一个实例（对象），每次都要new ,没有实现共享
改进->$this是当前类的实例的引用，伪对象，它始终与当前类的实例绑定
$obj=new self;return $obj->site;可以直接用return $this->site代替

3.类的实例化new Demo3() 与 函数调用 Demo3()只差了一个关键字new，但是实例化的时候里面自动调用了一些函数进行了操作

demo3 演示构造方法：在实例化的时候系统自动调用 魔术方法 名称固定 __construct()
构造方法一般完成两件事情：
（1）类实例的初始化；
（2）自动完成在类实例创建过程中的操作

4.demo4研究如何限制对类成员的访问，实现对类的封装

魔术方法 get($要取的属性)，属性重载set($name,$value),isset,unset.
echo $obj->role .’<br>‘; //封装后的private、protected从外部不能直接这样访问，要用访问器，除非使用了属性重载 如__get，就可以使用

5.类的继承 extends

实现代码的重复利用
继承是为了发展，扩展属性,当前子类的自身属性
parent调用父类的构造方法
重写父类中的方法也是一种扩展

6.trait 多继承

trait当做公共方法库，代码库
当前类中的同名方法>trait类中的同名方法>父类中的同名方法

7.接口

Demo7实现了接口的方法，现在叫工作类.接口定义的方法出现几个它必须都要实现几个
接口是一种约定，他是定义了实现它的类中必须实现的方法
接口中没有方法都是具体实现，所以不能实例化。

8.抽象类

接口中全是抽象方法，而抽象类中有抽象方法也有具体已实现的方法，两者共同之处就是都不能实例化，因为有抽象方法

phpstrom里面设置PHP版本时，不能下拉选中版本，要取消对勾的地方，下拉箭头就由灰色变成可选的了