search

博客列表 >PHP基础：PHP抽象类和接口、类的重载和方法的重载

PHP基础：PHP抽象类和接口、类的重载和方法的重载

初见
初见原创
2021年10月22日 11:25:17610浏览

静态继承

  1. <?php
  2. // 1、静态成员 （属性和方法）
  3. class Shop{
  4.     public static $title='苹果13PRO';
  5.     public $price;
  6.     public $num1=1;
  7.     public static $num2=1;
  8. //构造 给与静态成员默认值会报错
  9. //使用静态成员没有经过构造方法
  10.     public function __construct($title,$price)
  11.     {
  12.         $this->title =$title;
  13.         $this->price =$price;
  14. //        普通成员变量，每次从头开始计算
  15.         $this->num1++;
  16. //        静态变量成员调用一次，就会增加1
  17. //        静态成员为本类调用，为所有实例共享
  18. //        存在内存中，只要使用了改变了它的值，它会在内存中保存改变后的数据
  19.         self::$num2++;
  20.     }
  21.     public static function vedio($tit){
  22. //        静态成员用self 代表本类 Shop， 普通方法用$this
  23.         return '看视频手机：'. self::$title . $tit;
  24.     }
  25. }
  27. class Son extends Shop
  28. {
  29. // 静态也能被继承
  30. }
  31. /*
  32.  * 静态化成员的优缺点
  33.  * 1、存在多个实例，静态成员在内存中，只占一份
  34.  * 2、静态成员 执行效率比 实例化高
  35.  *
  36.  * 缺点
  37.  * 静态成员不能自动销毁 实例化会自动销毁
  38. */
  39. echo Son::vedio('!厉害了！'); //看视频手机：苹果13PRO!厉害了！

抽象类

  1. /* 2、抽象类
  2.  * （多态的一种，静态也是多态的一种）
  3.  * 抽象类 用于描述一些十五所具有的特性和行为 但是没有具体实现
  4.  * 抽象有类 也有方法  abstract
  5.  * */
  7. abstract class Person
  8. {
  9.     abstract  public  function  say();
  10.     abstract  public  function  eat();
  11.     //抽象方法
  12. }
  13. //new Person(); Cannot instantiate abstract class Person
  14. //抽象类不能被实例化的，不能生产出来对象
  16. //抽象类继承抽象类
  17. abstract class Chinese extends Person
  18. {
  19.     protected $name;
  20.     //构造方法也可以在抽象类里使用
  21.     public function __construct($name)
  22.     {
  23.         $this->name =$name;
  24.     }
  25. // 抽象类里是可以有普通方法的
  26.     public  function  say(){
  27.         return $this->name . '我是中国人，我说汉语';
  28.     }
  30. }
  31. //架构师 把项目架起来，在做很多抽象类，你写的代码必须继承抽象类
  32. //有多少个抽象方法就继承多少个抽象方法
  33. // 如果继承了抽象类，不能把所有的方法重写，只能自己也是抽象类
  34. class Anhui extends Chinese
  35. {
  36.     public  function  eat(){
  37.         return $this->name . '我是中国人，我吃中国菜';
  38.     }
  40. }
  41. $obj =new Anhui('小明');
  43. echo $obj->say();//小明我是中国人，我说汉语
  44. echo '<hr />';
  45. echo $obj->eat(); //小明我是中国人，我吃中国菜
  47. // 抽象类 设计类和实现类是分离的 可以为子类提供 公用的方法 作为子类重写模板来使用

类常量 const

  1. class App
  2. {
  3.     // const 常量关键词
  4.     const APP_NAME='PHP';
  5.     public function  get_name(){
  6.         return self::APP_NAME;//调用常量
  7.     }
  8. }
  9. ///常量不能实例化访问
  11. echo App::APP_NAME; //静态访问方式
  13. $obj = new App();
  15. echo $obj->get_name();
  16. //常量会当成静态成员进行访问

接口

  • 接口
  1. //也是多态的一种，不管是普通还是抽象，都是单继承，就是一个子类只能继承一个父类
  2. // interface 关键词 创建 替换class
  3. interface File
  4. {
  5.     //接口只能声明两种成员 常量 抽象方法
  6.     const APP_NAME='中小学教育部';
  7.     //接口的方法本身就是抽象的不能放abstract
  8.     public  function no_ke($o,$t);
  9.     public  function no_ye(...$param);
  11. }
  12. interface Guojia
  13. {
  14.     //接口里可以用静态方法
  15.     public  static function no_tifa($param);
  17. }
  18. // 接口不能继承
  19. // 实现接口implements
  20. class Teacher implements File,Guojia{
  21.     public  function no_ke($o,$t){
  22.         return $o . $t;
  23.     }
  24.     public  function no_ye(...$param){
  25.         return print_r($param);
  26.     }
  27.     // 接口有静态成员，重写也要用静态
  28.     public static function no_tifa($param){
  29.         return $param;
  30.     }
  31. }
  33. $obj = new Teacher();
  34. echo $obj->no_ke('补课?','不补课!'); //补课?不补课!
  35. echo '<hr />';
  36. echo $obj->no_ye('作业?','没有作业!','不能留作业!');
  37. //Array ( [0] => 作业? [1] => 没有作业! [2] => 不能留作业! ) 1
  39. echo '<hr />';
  40. //echo $obj->no_tifa('不能体罚!'); //不能体罚!
  41. //静态成员不要实例化
  42. echo Teacher::no_tifa('不能体罚!');//不能体罚!
  • 示例
  1. abstract class Computer
  2. {
  3.    const APP_NAME="Win11 电脑";
  4.    abstract public function install($param);
  6. }
  7. interface Plugo{
  8.     public function install_o($param);
  9. }
  10. interface Plugt{
  11.     public function install_t($param);
  12. }
  14. class VScode extends Computer implements Plugo,Plugt{
  15.     public function install($param){
  16.         return '安装成功：'.$param;
  17.     }
  18.     public function install_o($param){
  19.         return '安装成功：'.$param;
  20.     }
  21.     public function install_t($param){
  22.         return '安装成功：'.$param;
  23.     }
  24. }
  26. $obj = new VScode();
  27. echo $obj->install("vscode");
  28. echo '<br />';
  29. echo $obj->install_o("插件1");
  30. echo '<br />';
  31. echo $obj->install_t("插件2");

后期静态绑定

  1. //后期静态绑定 延迟静态绑定  静态::访问类 就是后期
  2. // 关键词 static
  3. class A{
  4.     public static function test(){
  5.         return 'A';
  6.     }
  7.     public function show(){
  8.         //return $this->test();
  9.         return static::test();
  10.     }
  11. }
  13. class B extends A{
  14.     public static function test(){
  15.         return 'B';
  16.     }
  17. }
  18. $a =new A();
  19. //实例化A 用a请求$this 先找A
  20. echo $a->show();
  21. echo '<hr />';
  22. $b =new B();
  23. //实例化B 找B
  24. echo $b->show();

魔术方法

  • __destruct 析构方法
  1. class A{
  2.     public $name;
  3.     public function  __construct($name)
  4.     {
  5.         $this->name=$name;
  6.     }
  7.     public function __destruct()
  8.     {
  9.         echo '执行完成';
  10.         //可以执行很多代码 比如unset
  11.     }
  12. }
  13. $a= new A('明明');
  14. echo $a->name;
  15. $name=$a->name;
  16. echo '<hr />';
  17. unset($a);
  18. echo '<hr />';
  19. //$name=$a->name;
  20. echo $name;

析构方法

  • 属性重载 get
  1. class People{
  2.     //私有的 受保护的都可以使用
  3.     private $name;
  4.     protected $age;
  5.     protected $height;
  6.     public function __construct($name,$age,$height)
  7.     {
  8.         $this->name=$name;
  9.         $this->age=$age;
  10.         $this->height=$height;
  11.     }
  12.     public function __get($n){
  13.         //__get 参数是 我们要找的成员名字，外面找name 返回name
  14. //        return $this->name;
  15.         //要找name $n就是name  $this->$n 相当于 $this->name
  16.         if($n=='name'||$n=='age'){
  17.             return $this->$n;
  18.         }
  19.         //empty 没有值也会当成真
  20.         if(empty($this->$n)){
  21.             return $n.',你访问的成员不存在!';
  22.         }
  23.         return $n.',你访问的成员不能访问!';
  24.     }
  25. }
  27. $obj = new People('明明',18,180);
  28. echo $obj->name;
  29. echo '<hr />';
  30. echo $obj->age;
  31. echo '<hr />';
  32. echo $obj->height;  //height,你访问的成员不能访问!
  • set 修改
  1. class People{
  2.     //私有的 受保护的都可以使用
  3.     private $name;
  4.     protected $age;
  5.     protected $height;
  6.     public function __construct($name,$age,$height)
  7.     {
  8.         $this->name=$name;
  9.         $this->age=$age;
  10.         $this->height=$height;
  11.     }
  12.     public function __get($n){
  13.         //__get 参数是 我们要找的成员名字，外面找name 返回name
  14. //        return $this->name;
  15.         //要找name $n就是name  $this->$n 相当于 $this->name
  16.         if($n=='name'||$n=='age'){
  17.             return $this->$n;
  18.         }
  19.         //empty 没有值也会当成真
  20.         if(empty($this->$n)){
  21.             return $n.',你访问的成员不存在!';
  22.         }
  23.         return $n.',你访问的成员不能访问!';
  24.     }
  25.     //设置需要两个参数
  26.     public function __set($key,$value){
  27. //        print_r($key.'----'.$value);
  28.         //通过返回$this 的key =要修改的值
  29.         return $this->$key=$value;
  30.     }
  33. }
  34. $obj = new People('花花',25,160);
  35. echo $obj->age;
  36. echo '<hr />';
  37. $obj ->age =26;
  38. echo '<hr />';
  39. echo $obj->age;
  • 方法重载
  1. //方法重载 __call 访问未定义的方法时，触发
  2. class People{
  3.     //call 有两个参数
  4.     public function __call($key,$value){
  5.         // $key 第一个参数是访问的方法
  6.         //$value 第二个参数是方法的传值
  7. //        print_r($key); //add
  8. //        print_r($value);//Array ( [0] => 10 [1] => 20 [2] => 30 [3] => 40 )
  9. //        return 1;
  10.         //方法重载是为了提醒和处理错误信息
  11. //        if($key=='add')
  12. //        {
  13. //            $num=0;
  14. //            foreach ($value as $v){
  15. //                $num +=$v;
  16. //            }
  17. //            return $num;
  18. //        }
  19.         return '方法名：'.$key.'<br> 方法参数：<pre>'.print_r($value,true).'</pre>';
  20.     }
  21. }
  22. $obj = new People();
  23. echo $obj->add(10,20,30,40);
  • 静态重载 callStatic
  1. class People{
  2.     //callStatic 静态触发 要用静态方法
  3.     public static function __callStatic($key,$value){
  5.         return '方法名：'.$key.'<br> 方法参数：<pre>'.print_r($value,true).'</pre>';
  6. //
  7.     }
  8. }
  9. //静态处理不能用普通方式来执行
  10. //$obj = new People();
  11. //echo $obj->add(10,20,30,40);
  12. //没有静态方法就会执行模式方法__callStatic
  13. echo People::add(100,200,300);
  • 汇总
关键词 类外声明 声明类 声明属性 声明方法 解释
const √ √ 定义类常量
extends √ 扩展类，用一个类去扩展它的父类
public √ √ 公用属性或方法
protected √ √ 私有属性或方法
private √ √ 受保护的属性或方法
static 备注1 √ √ 静态成员
abstract √ 备注2 √ 抽象类或方法
interface √ 创建接口
implements √ 实现接口
final √ √ 类不能被继承
parent:: 访问父类
$this-> 访问本类
self:: 访访问本类静态
static:: 后期静态绑定
namespace √ 创建命名空间

备注1：老师课件显示static可以声明类，我试了下发现不能用，先去掉
备注2：老师课件中abstract 可以声明属性，应该是可以声明抽象方法

  • 其他魔术方法
方法 描述
__construct 构造方法，实例类的时候，自动调用
__destruct 析构方法，类执行完后，自动调用
__call 在对象中调用一个不可访问方法时调用
__callStatic 用静态方式中调用一个不可访问方法时调用
__get 获得一个类的成员变量时调用
__set 设置一个类的成员变量时调用
__isset 当对不可访问属性调用 isset()或 empty()时调用
__unset 当对不可访问属性调用 unset()时被调用
__sleep 执行 serialize()时，先会调用这个函数
__wakeup 执行 unserialize()时，先会调用这个函数
__toString 类被当成字符串时的回应方法
__invoke 调用函数的方式调用一个对象时的回应方法
__set_state 调用 var_export()导出类时，此静态方法会被调用
__clone 当对象复制完成时调用
__autoload 尝试加载未定义的类
__debugInfo 打印所需调试信息
上一条：mysql 与初识类下一条：静态、抽象、类常量、接口、后期静态绑定以及魔术方法
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多