类的静态成员、类引用self:: ，接口、抽象类、

编辑: admin 分类: 电脑知识 发布时间: 2023-06-14 来源:互联网
一、类的静态成员、类引用self::
  1. /**
  2.  * 静态成员、类常量是属于类本身，不需要实例化，就可以被访问到
  3.  * 1. static 静态成员
  4.  * 2. self:: 类引用
  5.  * 3. const 类常量
  6.  * 4. __callStatic 当调用部存在的静态方法时
  7.  * 5. :: 范围解析符 用于类常量，静态成员的访问
  8.  */
  1. class Teacher
  2. {
  3.     public const cates = ['前端','后端','全栈'];
  5.     // 静态属性
  6.     public static string $uname;
  7.     private static int $salary;
  8.     static int $count = 0;
  9.     // 修饰符 放在 类型符 前面 : static string
  10.     public static string $siteName = '海外运维网';
  12.     // 静态方法：如果是公共的，可省public，不建议
  13.     public static function getCount()
  14.     {
  15.         // 静态成员与类的实例无关，不能用 $this 来访问
  16.         // 使用 self:: 引用，静态成员用$ sell::$count
  17.         return sprintf(__CLASS__ . '类被实例化了%d次' , self::$count);
  18.     }
  20.     public function __construct($uname,$salary)
  21.     {
  22.         self::$uname = $uname;
  23.         self::$salary = $salary;
  24.         self::$count++;
  25.     }
  27.     public static function getBK(){
  28.         return self::$uname . '来自' . self::$siteName . '可以胜任' . join(',', self::cates);
  29.     }
  30. }
  32. // print_r(Teacher::cates); //类常量不建议类外部访问
  33. $mj = new Teacher('灭绝',20000);
  34. //echo $mj->getCount();
  35. echo Teacher::getCount()."<br />";
  36. echo Teacher::getBK();

注意点：" class="reference-link">注意点：
  1. 修饰符 放在 类型符 前面 : static string
  2. 静态方法：如果是公共的，可省public，不建议
  3. 静态成员与类的实例无关，不能用 $this 来访问；使用 self:: 引用，静态成员用$ sell::$count
  4. 类常量不建议类外部访问
二、接口、抽象类、trait2.1、interface 定义接口
  1. interface iDemo
  2. {
  3.    // 所有成员必选是公共的
  4.    public const gender = 'MALE';
  5.    // 所有方法都是抽象方法（只有声明，没有实现）
  6.    public function sum($a, $b);
  7.    public function sub($a, $b);
  8.    public function mul($a, $b);
  9.    public function div($a, $b);
  10. }
2.2、imlements 实现接口，abstract抽象类抽象方法
  1. abstract class aDemo implements iDemo{
  2.    public function sum($a, $b)
  3.    {
  4.       return $a + $b;
  5.    }
  6.    public function sub($a, $b)
  7.    {
  8.       return $a - $b;
  9.    }
  10.    // 没有实现的方法，在抽象类中可声明
  11.    abstract public function mul($a, $b);
  12.    abstract public function div($a, $b);
  13. }
  15. interface A{
  16.    public const A = 1;
  17. }
  18. interface B{
  19.    public const B = 2;
  20. }
  22. class User implements A, B {}
2.3、trait组合式继承，解决php oop 单继承，高耦合的诟病" class="reference-link">组合式继承，解决php oop 单继承，高耦合的诟病
  1. // trait： 工具箱，基于类的语法，但和接口一样，不能实例化
  2. trait t1
  3. {
  4.    public function dump($data){
  5.       var_dump($data);
  6.       die;
  7.    }
  8. }
  9. trait t2
  10. {
  11.    public function sum($a,$b,...$arg)
  12.    {
  13.       return $a + $b +array_sum($arg);
  14.    }
  15. }
  17. class work1 extends work
  18. {
  19.    use t1,t2;
  20.    /*
  21.    public function sum($a,$b,...$args)
  22.    {
  23.       return "hello 海外运维网";
  24.    }*/
  25. }
  27. echo (new work1)->sum(10, 20, 30, 40, 50);

注意点：" class="reference-link">注意点：
  1. 定义接口的所有成员必选是公共的
  2. 定义接口所有方法都是抽象方法（只有声明，没有实现）
  4. oop 单继承 只能继承一个父类
  5. 但可以实现多个接口，多态
  7. 抽象类中可以有抽象方法，可以部分实现接口中的抽象方法
  8. 没有实现的方法，在抽象类中可声明
  10.  * 同名方法优先级别：当前类同名成员 > trait > 继承成员
三、后期静态绑定 static::
  1. // ! 后期静态绑定 static::
  2. // 静态继承时，不要再用self::，全部用static::
  4. class Car
  5. {
  6.     private static function getName()
  7.     {
  8.         return 'Car';
  9.     }
  11.     public static function run()
  12.     {
  13.         // ! php内核将类的继承实现了放在编译阶段 就确认了self解析为car
  14.         // self:: 的限制，对当前类的静态引用，取决于定义当前方法所在的类，定义类和调用类不能绑定
  15.         // return self::getName();
  17.         // ! static 后期静态绑定 static::不再被解析为定义当前方法所在的类，而是实际运行时计算的
  18.         return static::getName();
  19.     }
  20. }
  22. class BMW extends Car
  23. {
  24.     public static function getName()
  25.     {
  26.         return 'E300';
  28.     }
  29. }
  31. echo Car::run() . PHP_EOL; // Car
  32. echo BMW::run() . PHP_EOL; // Car

四、查询构造器（链式调用）查询构造器：Db::table()->field()->where()->limit(1)->select();" class="reference-link">查询构造器：Db::table()->field()->where()->limit(1)->select();
  1. class Query
  2. {
  3.     protected $db;      // pdo链接对象
  4.     protected $table;
  5.     protected $field;
  6.     protected $limit;
  8.     // 链接数据库
  9.     private function connect($dsn, $username, $password)
  10.     {
  11.         $this->db = new PDO($dsn, $username, $password);
  12.     }
  14.     function __construct($dsn, $username, $password)
  15.     {
  16.         $this->connect($dsn, $username, $password);
  17.     }
  19.     function table($table)
  20.     {
  21.         $this->table = $table;
  22.         return $this;
  23.     }
  25.     function field($filed)
  26.     {
  27.         $this->field = $filed;
  28.         return $this;
  29.     }
  31.     public function limit($limit)
  32.     {
  33.         $this->limit = $limit;
  34.         return $this;
  35.     }
  37.     public function getSql()
  38.     {
  39.         return sprintf('SELECT %s FROM %s Limit %d', $this->field, $this->table, $this->limit );
  40.     }
  42.     public function select()
  43.     {
  44.         return $this->db->query($this->getSql())->fetchAll(PDO::FETCH_ASSOC);
  45.     }
  46. }
  48. // 工作类
  49. class db
  50. {
  51.     static function __callStatic($method, $args)
  52.     {
  53.         $dsn = 'mysql:host=localhost;dbname=shop';
  54.         $query = new Query($dsn,'root', 'root');
  55.         // 直接委托给Query类中的普通方法完成
  56.         return call_user_func([$query, $method],...$args);
  57.     }
  58. }
  60. $res = Db::table('users')
  61.     ->field('uid,username,phone')
  62.     ->limit(3)
  63.     ->select();
  64.     var_dump($res);

注意点：

@形参名字可以随便起名字，一一对应即可;
链式调用的方法名系统已固定，不可更改

  1.     function field($filed1)
  2.     {
  3.         $this->field1 = $filed1;
  4.         return $this;
  5.     }
  6.     public function limit($limit)
  7.     {
  8.         $this->limit = $limit;
  9.         return $this;
  10.     }
  11.     public function getSql()
  12.     {
  13.         return sprintf('SELECT %s FROM %s Limit %d', $this->field1, $this->table, $this->limit );
  14.     }
  16.     public function select()
  17.     {
  18.         return $this->db->query($this->getSql())->fetchAll(PDO::FETCH_ASSOC);
  19.     }
  20. // 工作类
  21. class db
  22. {
  23.     static function __callStatic($method, $args)
  24.     {
  25.         $dsn = 'mysql:host=localhost;dbname=shop';
  26.         $query = new Query($dsn,'root', 'root');
  27.         // 直接委托给Query类中的普通方法完成
  28.         return call_user_func([$query, $method],...$args);
  29.     }
  30. }
  32. $res = Db::table('users')
  33.     ->field('uid,username,phone')
  34.     ->limit(3)
  35.     ->select();
  36.     var_dump($res);

【文章转自：韩国站群服务器 http://www.558idc.com/krzq.html 欢迎留下您的宝贵建议】
更多阅读