微信公众号 讲师中心
首页
文章
web3.0 后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 Prompt指令
学习
大前端 后端开发 数据库 移动端 运维开发 UI设计 计算机基础
编程手册
大前端 JavaScript 后端开发 数据库 移动端 运维开发 UI设计 计算机基础 XML Web Services
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机/移动开发 手机游戏
最近更新
搜索
web3.0 后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程
游戏教程 自媒体 新闻
首页 > 博客列表 > 实例演示类的扩展,抽象,接口的语法 2. 全局成员有哪些,他们有哪些特点?为什么要用命名空间
博主信息
博文 46
粉丝 2
评论 0
访问量 30165
专题推荐
更多>
相关推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
实例演示类的扩展,抽象,接口的语法 2. 全局成员有哪些,他们有哪些特点?为什么要用命名空间
P粉314265155
原创
477人浏览过

类与对象

  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. }
批改老师：PHPzPHPz

批改状态：合格

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

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

  • PHP学习

  • 技术支持

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