微信公众号 讲师中心
首页
文章
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 Prompt指令
学习
大前端 后端开发 数据库 移动端 运维开发 计算机基础
编程手册
大前端 后端开发 数据库 移动端 运维开发 计算机基础
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机/移动开发 手机游戏
搜索
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程
自媒体 新闻
首页 > 博客列表 > 面向对象编程-第九期php线上班
博主信息
博文 53
粉丝 3
评论 0
访问量 58878
专题推荐
更多>
相关推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
面向对象编程-第九期php线上班
emagic
原创
958人浏览过

12月03日作业:

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

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

demo1.php

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

demo2.php

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

demo3.php

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

demo4.php

  1. <?php
  2. //访问控制，实现对类的封装
  3. //1.创建类
  4. class Demo4{
  5. //2.添加类成员
  6.     public $site; //变成抽象属性，先不赋值，不写死，不给值默认值是null，后面通过构造函数进行传值
  7. //    不想让该属性在类的外部被访问，可以将该属性的访问控制符修改为：private或者protected
  8.     private $role;
  9. //    private $name='emagic';
  11.     public function getInfo(){
  12.         return '我是：'.$this->site.$this->role;
  13.     }
  14.     //构造方法：
  15.     public function __construct($site,$role)
  16.     {
  17.         //1.初始化类成员 ☆☆☆☆☆☆☆☆☆
  18.         $this->site=$site;
  19.         $this->role=$role;
  20.     }
  21. //    外部无权访问，是为了防止非法访问，不代表禁止访问
  22. //为这样的属性创建一个访问器方法，来过滤访问请求
  23. //    public function getRole(){
  24. ////        仅允许指定用户名的账户访问，其他用户返回无权访问提示
  25. //        $username=$_GET['username']??'';
  26. ////        等同于之前版本的$username=isset($_GET['username'])?$_GET['username']:'无权访问';
  27. //        if(isset($username) && $username ==='admin') {
  28. //            return $this->role;
  29. //        }else{
  30. //            return '无权访问';
  31. //        }
  32. //    }
  34. //    public function getName(){
  35. //       return isset($this->name)?$this->name:'不存在该属性';
  36. //    }
  38. //    魔术方法  __get($要取的属性)，属性重载
  39.     public function __get($name){
  40. //        仅允许指定用户名的账户访问，其他用户返回无权访问提示
  41.         $username=$_GET['username']??'';
  42. //        等同于之前版本的$username=isset($_GET['username'])?$_GET['username']:'无权访问';
  43.         if(isset($username) && $username ==='admin') {
  44.             return isset($this->$name)?$this->$name:'属性未定义';
  45.         }else{
  46.             return '无权访问';
  47.         }
  48.     }
  49. }
  50. //3.访问类成员
  51. $obj = new Demo4('www. PHP 法文网 .io','讲师');
  52. echo $obj->role .'<br>'; //封装后的private、protected从外部不能直接这样访问，要用访问器，除非使用了属性重载 如__get，就可以使用
  53. //使用访问器方法访问 ☆☆☆☆☆
  54. //echo $obj->getRole();
  55. echo '<hr>';
  57. //echo $obj->name; //对于不存在的数据如何控制操作
  58. //echo $obj->getName(); //使用访问器方法访问 ☆☆☆☆☆

demo5

  1. <?php
  2. //类的继承
  3. //1.创建类
  4. class Demo5
  5. {
  6. //2.添加类成员
  7.     public $site;
  8.     private $role;
  10. //    private $name='emagic';
  12.     public function getInfo()
  13.     {
  14.         return '我是：' . $this->site . '讲师：'.$this->role;
  15.     }
  17.     //构造方法：
  18.     public function __construct($site, $role)
  19.     {
  20.         $this->site = $site;
  21.         $this->role = $role;
  22.     }
  23. }
  25. class Demo5_1 extends  Demo5{
  26.     //子类也是个类
  27.     private $course;//继承是为了发展，扩展属性,当前子类的自身属性
  28.     public function __construct($site, $role, $course)
  29.     {
  30.       //  parent调用父类的构造方法
  31.         parent::__construct($site, $role);
  32.         $this->course=$course;
  33.     }
  34.             //  重写父类中的方法也是一种扩展
  35.         public function getInfo()
  36.         {
  37.             return parent::getInfo().',负责的课程是：'.$this->course;
  38.         }
  40. }
  42. //3.访问类成员
  43. $sub = new Demo5_1('PHP粤语网','Emagic','php');
  44. echo $sub->getInfo();

demo6.php

  1. <?php
  2. //trait代码复用方式，用来扩展当前类的功能
  3. //trait当做公共方法库，代码库
  4. //trait借助了累的定义的语法，但不是类，所以不能实例化
  6. trait Test{
  7.     public function getInfo(){
  8.         return '我是：'.$this->site.'讲师'.$this->role;
  9.     }
  10. }
  12. //1.创建类
  13. //将一个trait类库嵌入到类库中，Demo6又可以叫做宿主类
  14. class Demo6{
  15.     //如何导入trait类库，用关键字use
  16.     use Test;
  18. //    2.添加类成员
  19.     public $site;
  20.     protected $role;
  22. //    public function getInfo(){
  23. //        return '我是：'.$this->site.'讲师'.$this->role;
  24. //    }
  26.     //构造方法
  27.     public function __construct($site,$role)
  28.     {
  29.         $this->site=$site;
  30.         $this->role=$role;
  31.     }
  32. }
  34. //trait 还可以用在类的继承的上下文环境中
  36. class Demo6_1 extends Demo6{
  37. //    当前子类的自身属性
  38.     private $course;
  40.     public function __construct($site, $role,$course)
  41.     {
  42.         //parent调用父类中的成员
  43.         parent::__construct($site, $role);
  45.         $this->course=$course;
  46.     }
  48. //    重写父类中的方法
  49.     public function getInfo()
  50.     {
  51.         return parent::getInfo().',负责的课程是：'.$this->course;
  52.     }
  53. }
  54. //优先级关系：当前类中的同名方法>trait类中的同名方法>父类中的同名方法
  55. //3.访问类成员
  56. $obj = new Demo6('php 蚊子网','emagic');
  57. echo $obj->getInfo();
  58. echo '<hr>';
  60. $sub= new Demo6_1('php.io','莫小仙','php');
  61. echo $sub->getInfo();

demo7

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

demo8.php

  1. <?php
  3. //抽象类
  4. //接口中全是抽象方法，而抽象类中有抽象方法也有具体已实现的方法，两者共同之处就是都不能实例化，因为有抽象方法
  5. abstract class Chouxiang{
  6.     //抽象方法 未实现，加abstract，子类要实现
  7.     abstract public function getInfo ();
  9.     //具体方法，已实现方法
  10.     public function hello()
  11. {
  12.     return 'Hello 大家晚上吃好了吗?';
  13. }
  14. }
  15. //1.创建类
  16. //Demo8 工作类
  17. class Demo8 extends Chouxiang
  18. {
  20. //2.添加类成员
  21.     public $site;
  22.     protected $role;
  24.     public function getInfo(){
  25.         return '我是：'.$this->site.'讲师'.$this->role;
  26.     }
  27.     //构造方法
  28.     public function __construct($site,$role)
  29.     {
  30.         $this->site=$site;
  31.         $this->role=$role;
  32.     }
  33. }
  35. //3.访问类成员
  36. $obj=new Demo8('php俄文网','Zhu洛夫斯基');
  37. echo $obj->getInfo().'<br>';
  38. 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版本时，不能下拉选中版本，要取消对勾的地方，下拉箭头就由灰色变成可选的了

批改老师：天蓬老师天蓬老师

批改状态：合格

老师批语：完成的不错, 对于重要进行了标注, 很好的习惯
本博文版权归博主所有，转载请注明地址！如有侵权、违法，请联系admin@php.cn举报处理！
全部评论 文明上网理性发言，请遵守新闻评论服务协议
0条评论
作者最新博文
关于我们 免责申明 举报中心 意见反馈 讲师合作 广告合作 最新更新 English
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习

Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • PHP学习

  • 技术支持

  • 返回顶部
    • 登录PHP中文网，和优秀的人一起学习！
    全站2000+教程免费学
    微信扫码登录