Community Learn Tools Library Leisure
search
English
Home > List of blog posts > 面向对象编程-第九期php线上班
Blogger Information
Blog 53
fans 3
comment 0
visits 46631
Special Recommendation
More>
Related recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
面向对象编程-第九期php线上班
emagic
Original
746 people have browsed it

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版本时，不能下拉选中版本，要取消对勾的地方，下拉箭头就由灰色变成可选的了

Correcting teacher：天蓬老师天蓬老师

Correction status：qualified

Teacher's comments：完成的不错, 对于重要进行了标注, 很好的习惯
Statement of this Website
The copyright of this blog article belongs to the blogger. Please specify the address when reprinting! If there is any infringement or violation of the law, please contact admin@php.cn Report processing!
All comments Speak rationally on civilized internet, please comply with News Comment Service Agreement
0 comments
Author's latest blog post