简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
Home
Article
Q&A
Course
Topic
Download
Game
Dictionary
Recent Updates

博客列表 >实例演示类的扩展,抽象,接口的语法 2. 全局成员有哪些,他们有哪些特点?为什么要用命名空间

实例演示类的扩展,抽象,接口的语法 2. 全局成员有哪些,他们有哪些特点?为什么要用命名空间

P粉314265155
P粉314265155原创
2022年08月22日 08:19:11292浏览

类与对象

  1. <?php
  2. // 类与对象
  4. namespace  _0815;
  6. use _0815\Query as _0815Query;
  8. /**
  9.  * 1. 属性重载: __get(),__set()
  10.  * 2. 方法重载:__call($name,$args), __callStatic($name,$args)
  11.  */
  13. // 封装, 重载, 继承
  14. class User {
  15.     // 私有 封装
  16.     private int $salary =10000;
  17.         // 私有 封装
  18.         private int $age=100;
  19.         // 查询接口 
  20.         public function  getAge(){
  21.             return $this ->age;
  22.         }
  24. }
  25. // 实例化
  26. $user = new User ();
  27. echo  $user ->getAge() ;
  28. echo '<hr>';
  29. //--------------------------------------------
  30. class User2 {
  31.     // 私有 封装
  32.     private int $salary =10000;
  33.         // 私有 封装
  34.         private int $age=100;
  35.         // 查询接口   属性拦截器  魔术方法  属性重载
  36.                             //    注意两个下划线
  37.         public function __get($name){
  38.             return $this ->$name;
  39.         }
  41. }
  42. // 实例化
  43. $user2 = new User2 ();
  44. echo  $user2 ->age ;
  45. echo '<hr>';
  46. //--------------------------------------------
  48. class User3 {
  50.     //  private 私有 封装  常用
  51.     // $data  数据容器  用数组表示
  53.     private array $data = [
  54.         'age' => 20,
  55.     ];
  58.         // 查询接口   属性拦截器  魔术方法  属性重载
  59.                             //    注意两个下划线
  60.                             // 商业代码
  61.         public function __get($name){
  62.             if (array_key_exists($name,$this ->data) ){
  63.                 return $this -> data[$name];
  64.             }else {
  65.                 return "$name  不存在" ;
  66.             }
  67.         }
  68. }
  69. // 实例化
  70. $user3 = new User3 ();
  71. echo  $user3 ->age ;
  72. echo '<hr>';
  73. echo  $user3 ->dog ;
  74. echo '<hr>';
  75. //--------------------------------------------
  77. class User4 {
  79.     //  private 私有 封装  常用
  80.     // $data  数据容器  用数组表示
  82.     private array $data = [
  83.         'age' => 20,
  84.     ];
  87.         // 查询接口   属性拦截器  魔术方法  属性重载
  88.                             //    注意两个下划线
  89.                             // 商业代码
  90.         public function __get($name){
  91.         //    借助中间变量 result  实现单 return 返回
  92.             $result  =null ;
  93.             if (array_key_exists($name,$this ->data) ){
  94.               $result =  $this -> data[$name];
  95.             }else {
  96.                 $result =  "$name  不存在" ;
  97.             }
  98.                   return   $result;
  99.         }
  100. }
  101. // 实例化
  102. $user4 = new User4 ();
  103. echo  $user4 ->age ;
  104. echo '<hr>';
  105. echo  $user4 ->dog ;
  106. echo '<hr>';
  108. //--------------------------------------------
  110. class User5 {
  112.     //  private 私有 封装  常用
  113.     // $data  数据容器  用数组表示
  115.     private array $data = [
  116.         'age' => 20,
  117.     ];
  120.         // 查询接口   属性拦截器  魔术方法  属性重载
  121.                             //    注意两个下划线
  122.                             // 商业代码
  123.         public function __get($name){
  125.             // return array_key_exists($name ,$this ->data)? $this ->data[$name]:"$name 属性不存在";
  126.                         //    判断属性是否存在
  127.             $condition  =   array_key_exists($name ,$this ->data);
  128.             return  $condition ? $this ->data[$name]:"$name 属性不存在";
  129.         }
  130.             // __set($name,$value):  见 812代码
  131. }
  132. // 实例化
  133. $user5 = new User5 ();
  134. echo  $user5 ->age ;
  135. echo '<hr>';
  136. echo  $user5 ->dog ;
  137. echo '<hr>';
  139. //--------------------------------------------
  141. class User6 {
  143.     //  private 私有 封装  常用
  144.     // $data  数据容器  用数组表示
  146.     private array $data = [
  147.         'age' => 20,
  148.     ];
  151.         // 查询接口   属性拦截器  魔术方法  属性重载
  152.                             //    注意两个下划线
  153.                             // 商业代码
  154.         public function __get($name){
  156.             // return array_key_exists($name ,$this ->data)? $this ->data[$name]:"$name 属性不存在";
  158.             $condition  =   array_key_exists($name ,$this ->data);
  159.             return  $condition ? $this ->data[$name]:"$name 属性不存在";
  160.         }
  161.             // __set($name,$value):  见 812代码
  163.                 // 可以自动拦截对于方法的非法访问
  164.                         // 第一个参数是方法名称
  165.         // 第二个参数是以数组表示的参数列表
  166.             public function __call($name, $arguments)
  167.             {
  168.                 // return  '方法不存在';
  169.                 printf('方法名：%s<br>参数列表：<pre>%s</pre><br>',$name ,print_r($arguments,true));
  170.             }
  173.             public  static function __callStatic($name, $arguments)
  174.             {
  175.          // 第一个参数是方法名称
  176.         // 第二个参数是以数组表示的参数列表
  177.         printf('方法名: %s<br>参数列表: <pre>%s</pre>', $name, print_r($arguments, true));
  178.             }
  180. }
  181. // 实例化
  182. $user6= new User6 ();
  183. echo  $user6->age ;
  184. echo '<hr>';
  185. echo  $user6 -> cat;
  186. echo '<hr>';
  187. // echo  $user6 -> hello();
  188. // echo '<hr>';
  189. // 非静态方法  类的实例访问
  190. echo  $user6 -> hello('小狗','123@qq.om');
  191. echo '<hr>';
  192. // 静态方法 类访问        ：：方法名
  193. User6  ::word (100,200);
  194. echo '<hr>';
  195. // tinkphp  查询构造器  数据库操作  
  196. // Query  固定语法   
  197. class Query {
  198.     // 当这个查询类  实例化时，自动连接数据库 实例化的时候  自动连接数据库
  199.     //    public function __construct()
  200.     //    {
  201.         // self::connect();
  202.     //    }
  203.    public function table(){
  204.       return $this;
  205.    }
  206.    public function where(){
  207.     return $this;
  208. }
  209. public function find(){
  210.        echo '完成';
  211. }
  213. }
  214. // 查询入口类
  215. class Db{
  216.     public static function __callStatic($name, $arguments)
  217.     {
  218.         // echo  $name ,'，', $arguments [0];
  219.         // 所有查询操作再次完成， 单入口查询，惰性查询
  220.         return call_user_func_array( [ new  Query,$name],$arguments );
  221.     }
  222. }
  224. Db ::table( 'think_user'   )->where('id', 1)->find();
  225.             //      表名
  226. // Db::table('think_user')->where('id', 1)->find();

类的扩展

  1. <?php
  2.  namespace _0815;
  4. use _0815\Demo1 as _0815Demo1;
  6. /**
  7.  * 类的扩展/抽象/最终
  8.  * 1. 可继承成员: protected
  9.  * 2. extends: 类成员的来源
  10.  * 3. parent: 父类引用
  11.  */
  12. class Person
  13. {
  14.     // 属性 
  15. //   默认 public  公告成员，当前类 类外部
  16. // public $email = '123@qq.com';
  17. // private 私有成员   类外部不可见  
  18. private int $id =18;
  19. // protected   受保护的    
  20. protected string $name;
  21. // public > protected > private
  22.     // 类中,类外,子类: public
  23.     // 类中,子类: protected
  24.     // 类中: private
  26.     // 方法 
  27.     public function __construct($name)
  28.   {
  29.     $this ->name =$name;
  30.   }
  32.     // 自定义方法
  33.     protected function getInfo(): string
  34.     {
  35.         return $this->name;
  36.     }
  38. }
  39.             // 继承 /扩展  
  41.             class Stu extends Person
  42.             {
  43. // 只需要 扩展父类的属性和方法
  44.     //  1、  属性扩展  扩展之前需要创建一个构造方法     继承扩展  相当于把父类除了 私有属性，其他都拿到了
  46.   // extends: 相当于把父类代码复制到当前类中(除Private成员外)
  47.     // protected string $name;
  48.     // public function __construct($name)
  49.     // {
  50.     //     $this->name = $name;
  51.     // }
  52.     // protected function getInfo(): string
  53.     // {
  54.     //     return $this->name;
  55.     // }
  57.     // 属性扩展 
  58.     // 之前的
  59.     // protected string $name;
  60.     // 扩展的
  61.     private string $lesson;
  62.     private int $score;
  63.     // 2、方法扩展
  64.     // 构造方法
  65.     public function __construct($name, $lesson, $score)
  66.     {
  67.     // $this ->nam = $name;
  68.     // $this ->lesson = $lesson;
  69.     //     $this ->score = $score;
  70.     // 简化  parent ：引用父类  相当于执行了  父类的构造方法  获取所有能获取到的（除了私有
  71.     parent::__construct($name);
  72.     // $this ->name = $name;
  73.     $this->lesson = $lesson;
  74.     $this->score = $score;
  75. }
  76. //   自定义方法 拓展 注意 protected   要跟父类一样或者高于父 类  public
  77. public function getInfo(): string
  78. {
  79.     return parent::getInfo() .   '同学, (' . $this->lesson . ' ) , 成绩: ' . $this->score .'<br>';
  80.     }
  81. }
  83. $stu = new Stu('小张', 'php', 90);
  84. echo $stu->getInfo() ;
  85. echo '<hr>';
  87. // 2. 禁用父类, 仅允许通过它的子类来访问父类成员
  88. // 把当前类,声明为"抽象类": abstract
  89. // 如果类中有抽象方法,则这个类必须声明为抽象类
  90.   abstract   class Demo1 {
  91.     public string $name = 'admin';
  92.     // 没有具体实现 叫抽象方法  前面必须加 abstract
  93.         // 如果某个方法没有具体实现,应该声明成抽象方法
  94.     abstract  public static  function getInfo($name);
  95. }
  97. class Demo2 extends Demo1 {
  98.     // 在子类中, 必须将父类中的抽象方法实现了
  99.     // public   function getInfo($name)
  100.     // {
  101.     //     return 'Hello, ' .$name;
  102.     // }
  103.     public  static  function getInfo($name)
  104.     {
  105.         return 'Hello, ' .$name;
  106.     }
  107. }
  108. // new Demo2();
  109. echo Demo2::getInfo('朱老师');
  111. echo  '<hr>';
  113. // 抽象类: 强制要求必须继承才能用
  115. // 最终类: 禁止继承,直接用
  116. // final: 不能扩展了
  117. // final class Demo3
  118. // {
  119. // }
  121. // class Demo4 extends Demo3
  122. // {
  123. // }

接口

  1. <?php
  2. namespace _0815;
  4. use _0815\Demo2 as _0815Demo2;
  6. // 接口  升级版的抽象类
  7. // abstract  class    =  interface  接口
  8. // 接口类
  9. interface iUser{
  10.     // public string $name;
  11. // //   如果 某个方法 没有具体实现，应该声明为抽象方法
  12. // abstract public static function getInfo ($name);
  13. // abstract public static function getInfo1 ($score);
  14. // abstract public static function getInfo2 ($age);
  16. // 接口里面两类成员  常量、方法
  17. // 常量
  18. public  const NATION = 'CHINA';
  20. // 方法  public
  21. public function m1();
  23. public function m2();
  25. }
  27. //工作类  实现了 接口的类   将接口类方法实现
  29. // class Demo1 implements iUser{
  31. // // 接口的抽象方法,必须在工作类中全部实现
  32. //     public function m1(){
  34. //     }
  35. //     public function m2(){
  37. //     }
  38. // }
  41. // 如果实现类 仅实现了接口 一部分抽象方法 应该为抽象类  
  42.                                                         // iUser  接口类固定写法
  43. abstract     class Demo2 implements iUser{
  45.     // 部分实现时，需要将类变为抽象类
  46.         public function m1(){
  48.         }
  50.     }
  51.  class Demo3 extends  Demo2{
  54.             public function m2(){
  56.             }
  58.         }
  60. // php是单继承  ,但是可以 使用接口多继承 
  61. interface A {
  63. }
  64. interface B {
  66. }
  67. interface C {
  69. }
  70. // Test类,同时从三个接口中获取成员,间接实现了"多继承"
  71. // 用途:对于增删改查
  72. class Test implements A,B,C {
  74. }
  76. interface iDb {
  77.                                     //    插入
  78. public static function insert (array $data);
  79.                                     //    更新
  80.  public static function updata (array $data ,string $where  );
  81.                                      //    删除
  82.  public static function delete (string $where );
  84.                                       //    查询
  85. public static function select (array $option     );
  87. }
  89. abstract class  aDb {
  90.                                         //    插入
  91. public static function insert (array $data){}
  92. //    更新
  93. public static function updata (array $data ,string $where  ){}
  94.  //    删除
  95. public static function delete (string $where ){}
  97.   //    查询
  98. public static function select (array $option     ){}
  99. }
  100. // 实现
  101. class Db extends aDb {
  103. }

全局成员

  1. <?php
  2. namespace _0815;
  4. // 全局成员:函数 常量、类、接口、全局有效，禁止重复声明
  6. function hello(){
  8. }
  9. const A =1 ;
  10. class B {
  12. }
  13. // 将第二个 hello 声明在另外一个空间中，不会重名了
  14. namespace _0815_1;
  15. function hello (){
  17. }
  18. const A =2;
  19. class B {
  21. }

命名空间

  1. <?php
  2. // 命名空间解决了:全局成员的命名冲突,借鉴了同名文件可存入在不同的目录下面
  3. namespace one;
  5. class Demo1 {
  6.     public  static     string $name = '小猫';
  7. }
  8. // 当存在 命名空间时，全局成员应该使用完整的名称
  9. // 类名 =  空间名称\类名
  10. // ::class 获取 类的完整名称 
  11. echo Demo1::class.'<br>';
  12. echo '<hr>';
  13. namespace two;
  15. class Demo1 {
  16.     public  static  string $name = '小狗';
  18. }
  19. echo Demo1::class.'<br>';
  20. echo '<hr>';
  21. // 跨空间访问
  22. // 在two 里面访问 one 
  23. // 报错的  实际访问路径变成了 two\one\Demo1
  24. // echo one\Demo1::$name;
  25. // 跨空间访问  正确写法 从根空间/全局空间写起 开始查询 用反斜线  \
  26. echo \one\Demo1::$name;
  27. echo '<hr>';
  28. echo \two\Demo1::$name;

命名空间类型

  1. <?php
  2. // 命名空间类型、
  3. // 1. 当前路径: 非限定名称, Index          Index::show();
  4. // 2. 相对路径: 限定名称, two\Index
  5. // 3. 绝对路径: 完全限定名称, \one\two\Index
  7. namespace _0815;
  11. namespace one;
  13. class Index {
  16.     public static function show(){
  17.         return __METHOD__;
  18.     }
  19. }
  20. // Index::show();   非限定名称
  21. // one\Index::show
  22. echo Index::show();
  23. echo '<hr>';
  24. // 如果我在one空间中, 访问 one\two中的成员
  25. // 方式一  绝对路径  完全限定名称
  26. echo \one\two\Index::show(). '<br>';
  27. // 方式二   限定名称
  28. echo two\Index::show(). '<br>';
  30. // 空间可以分层/分级管理
  31. namespace   one\two;
  32. class Index {
  35.     public static function show(){
  36.         return __METHOD__;
  37.     }
  38. }
  39. // one\two\Index::show
  40. echo Index::show();
  41. echo '<hr>';

use 简化命令空间/类名

  1. <?php
  3. namespace _0815;
  4. namespace one;
  8. class Index {
  9.     public static function show(){
  10.         return __METHOD__;
  11.     }
  12. }
  13. echo two\three\Index::show();
  14. echo '<hr>';
  15. // use  默认使用完全限定名称的类名/绝对路径
  16. // echo \one\two\three\Index::show();
  17. // use 进行简化
  18. use  \one\two\three\Index  as UserIndex;
  19. echo  UserIndex::show();
  20. echo '<hr>';
  23. namespace   one\two\three;
  24. class Index {
  27.     public static function show(){
  28.         return __METHOD__;
  29.     }
  31. }
  32. //---------------------------------------------
  34. namespace  four;
  36. // 如果当前空间中的没有Index类,可以进一步的简化
  37. // use  one\two\three\Index as Index;
  38. // 如果当前类别名与原始类名相同,可以不写
  39. // 如果当前空间中有Index类, 就不能省去as
  40. use  one\two\three\Index;
  41. echo Index::show() ;
  42. echo '<hr>';
  45. namespace  five;
  46. class Index {
  49.     public static function show(){
  50.         return __METHOD__;
  51.     }
  53. }
上一条：写一个类的自动加载器 2. 预习PDO基本知识,与常用的SQL语句下一条：类的扩展和命名空间
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多