search

博客列表 >php中的类及trait

php中的类及trait

后网络时代
后网络时代原创
2021年03月08日 23:21:221198浏览

1. 实例演示类声明，类的实例化，类的静态成员与类的扩展;

  1. <?php
  2.     // 简单类定义
  3. class  test{
  4.  // 声明属性
  5. public  $name=1000;
  6. //构造函数：用户对象初始化
  7. public  function   __construct($name){
  8. $this->name=$name;
  9. }
  11. //实例方法定义
  12. function  demo(){
  14.   echo   $this->name;
  15. }
  17. }
  19. // //简单类的实例化：
  20. // 要创建一个类的实例，必须使用 new 关键字
  21. $ob=new   test('zhangsan');
  22. $ob->demo();
  24. echo "<hr>";
  25. $str="test";
  27. $obj1=new   test('张三');
  28. $obj1->demo();
  30. echo  "<br>";
  32. // 在类定义内部，可以用 new self 和 new parent 和  new  self创建新对象。 
  34. // 创建新对象
  36. class  AA{
  37. static  public  function   getobj(){
  39.     return  new  AA;//与new   self 一致
  40. }
  41. }
  43. class  childclass  extends  AA{}
  45. $obj1=new   AA;
  47. $obj2=new   $obj1;//产生新对象
  49. var_dump($obj2==$obj1);
  50. echo "<br>";
  51. $obj3=AA::getobj();
  52. var_dump($obj3 instanceof  AA);
  53. echo "<br>";
  54. $obj4=childclass::getobj();
  56. var_dump($obj4  instanceof   childclass);
  58. echo "<hr>";
  59. class  AAA{
  60. static  public  function   getobj(){
  62.     return  new static;//后期静态绑定开始
  63. }
  64. }
  66. class  childclass1  extends  AAA{}
  67. $obj5=childclass1::getobj();
  68. var_dump($obj5  instanceof   childclass1);
  69. $obj6=&$obj5;
  71. echo  "<br>";
  73. var_dump($obj6===$obj5);
  74. echo "<br>";
  75. //动态创建一个
  76. class   vary{
  77. public  $name="zhangsan";
  78. const    st=<<< EOT
  79. 类常量
  80. EOT;//只能字面量
  81. }
  82. echo vary::st;
  83. echo  "<br>";
  84. //动态创建对象
  85. $o="vary";
  86. $obj=new  $o;
  87. echo $obj->name;
  88. echo "<hr>";
  89. // 静态（static）关键字
  90. // 声明类属性或方法为静态，就可以不实例化类而直接访问
  91. // 静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
  92. // 由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
  93. //静态变量是共享的
  94. class   foostatic{
  95. public  static   $my_static="foostatic";//不能被实例调用
  97. public   function    callstatic(){
  99. echo  static::$my_static;
  101. }
  104. public  static  function    callstamothod(){
  106. echo  '静态方法可以被对象调用(静态属性不可以由对象通过 -> 操作符来访问。),也可以被类调用，所以在他里面不能使用$this';
  108.     }
  110. }
  112. $op=new  foostatic;
  113. $op->callstamothod();
  114. echo "<br>";
  115. $op->callstatic();
  116. echo  "<br>",foostatic::$my_static;
  118. class Foo {
  119.     public static $bar = 'a static property';
  120.   }
  121.   echo "<br>";
  122.   //php  可以使用new  对象名称来生成一个新对象  对象可以使用::来访问静态属性和方法 对象可以当成类来使用,反过来却不行
  123.   $baz = (new Foo)::$bar;
  124.   echo $baz;
  125. echo  "<hr>";
  126. //类的继承  exstends
  128. class   ad{
  129. static   $id=1;
  130. static   public    function  st(){
  131.    echo "static  与public 书写上不讲究";
  132. }
  133. }
  136. class   ef   extends ad{
  138.     static   $id=30;//可以重写
  140. static   public    function  st(){  //静态方法可以重写
  141.    echo "静态方法可以重写";
  142. }
  143. }
  145. echo ef::$id;//静态属性可以继承
  146. echo  "<br>";
  147. echo ef::st();

结果：

2. 描述trait功能,以及trait与父类的区别与联系,并实例演示trait 的冲突与优先级的解决方案

答：

  1. // 为了对使用的类施加强制要求，trait 支持抽象方法的使用。
  2. // 警告
  3. // 一个可继承实体类，可以通过定义同名非抽象方法来满足要求；方法的签名可以不同。
  4. trait Hello {
  5.     public function sayHelloWorld() {
  6.         echo 'Hello'.$this->getWorld();
  7.     }
  8.     abstract public function getWorld();
  9. }
  11. class MyHelloWorld {
  12.     private $world=111;
  13.     use Hello;
  14.     public function getWorld() {
  15.         return $this->world;
  16.     }
  17.     public function setWorld($val) {
  18.         $this->world = $val;
  19.     }
  20. }
  21. $obj=new    MyHelloWorld();
  23. echo $obj->getWorld();
  24. echo "<hr>";
  25. // Traits 可以定义静态成员静态方法静态变量。
  26. trait    counter{
  27. public  static   $name="zhangsan";
  28. public    function  inc(){
  30.     static  $c=0;
  31.     $c=$c+1;
  32.     echo  "$c\n";
  33. }
  34. public  static   function  de(){
  36.   echo  "静态方法!!";  
  37. }
  38. }
  40. class  c1{
  42.     use  counter;
  43. }
  45. class  c2{
  47.     use  counter;
  48. }
  50. $o=new   c1();
  51. $o->inc();
  52. $p=new    c2();
  53. $p->inc();
  54. echo "<br>";
  55. $p->de();
  56. c1::de();
  57. echo "<br>";
  58. echo c1::$name;
  59. echo  "<hr>";
  60. // Trait 定义了一个属性后，类就不能定义同样名称的属性，否则会产生 fatal error。
  61. //  有种情况例外：属性是兼容的（同样的访问可见度、初始默认值）。 
  62. //  在 PHP 7.0 之前，属性是兼容的，则会有 E_STRICT 的提醒。
  63. //优先顺序示例
  64. // 从基类继承的成员会被Trait中的同名成员覆盖。
  65. // 优先顺序是当前类中的方法会覆盖 trait 方法，
  66. // 而 trait 方法又覆盖了基类中的方法。
  67. //属性定义的时候只能定义成
  68. // class demoT{
  69. // public  $name=111;
  70. // }
  71. // trait  tt{
  72. //     public  $name=111;
  73. // }
  74. // class  yy extends  demoT{
  75. // use  tt;
  76. // public  $name=222;
  77. // }
  78. class   Base{
  79. public  function  hello(){
  80. echo  "helloword (parent)";
  81. }
  82. }
  83. trait   sayWorld{
  84.     function  hello(){
  85.         parent::hello();
  86.         echo  "<br>";
  87.         echo  "trait,覆盖了父类的同名方法";
  88.     }
  89. }
  91. class   parentandtrait  extends  Base{
  93. use  sayworld;
  95. }
  97. $obj=new  parentandtrait;
  99. $obj->hello();
  101. echo "<br>";
  102. class    Mythod{
  104.     use  sayworld;
  105.          public  function  hello(){
  107.              echo  "当前类型中与trait中同名的方法会覆盖trait中的方法";
  109.          }
  110. }
  112. $obj1=new  Mythod;
  114. $obj1->hello();
  115. //总结：优先顺序是当前类中的方法会覆盖 trait 方法，而 trait 方法又覆盖了基类中的方法
  117. echo  "<hr>";
  118. //多个 trait
  119. // 通过逗号分隔，在 use 声明列出多个 trait，可以都插入到一个类中。
  120. trait    arr1{
  121. public   function  member(){
  122.       echo  "会员数据信息";
  123.       echo "<pre></pre>";
  124.    } 
  125. }
  127. trait    arr2{
  129.     public   function  mark(){
  130.           echo  "会员积分";
  131.           echo "<pre></pre>";
  132.        } 
  133. }
  136. class    currentclass{
  137. use  arr1,arr2;
  138. public     function   output(){
  140. echo "对个trait的使用";
  141. echo "<pre></pre>";
  143. } 
  145. }
  147. $obj=new  currentclass;
  149. $obj->output();
  151. $obj->member();
  153. $obj->mark();
  154. echo "<hr>";
  155. // 如果两个 trait 都插入了一个同名的方法，如果没有明确解决冲突将会产生一个致命错误。
  156. // 为了解决多个 trait 在同一个类中的命名冲突，
  157. // 需要使用 insteadof 操作符来明确指定使用冲突方法中的哪一个。
  158. // 以上方式仅允许排除掉其它方法，as 操作符可以 为某个方法引入别名。
  159. //  注意，as 操作符不会对方法进行重命名，也不会影响其方法。
  160. trait  AAA{
  162.    public    function  smallTalk(){
  163.         echo  'a';
  164.    }
  166.    public  function  bigTalk(){
  168.     echo  "A";
  170.    }
  172. }
  175. trait  BBB{
  177.     public    function  smallTalk(){
  178.          echo  'b';
  179.     }
  181.     public  function  bigTalk(){
  183.      echo  "B";
  185.     }
  187.  }
  189.  class  Talker{
  190.   use   AAA,BBB{
  191.     BBB::smallTalk insteadof  AAA;
  192.     AAA::bigTalk   insteadof  BBB;
  193.   }
  195.  }
  196.  $obj=new  Talker;
  197.  $obj->smallTalk();
  198. echo "<br>";
  199.  $obj->bigTalk();
  200.  echo  "<hr>";
  201.  class   aliased_as{
  202.     use   AAA,BBB{
  203.         BBB::smallTalk insteadof  AAA;
  204.         AAA::bigTalk   insteadof  BBB;
  205.         BBB::bigTalk   as  aliased_BBB;
  206.       }
  207.  }
  209. $obj=new    aliased_as;
  211. $obj->aliased_BBB();
  213. echo "<pre></pre>";
  215. // 修改方法的访问控制,使用 as 语法还可以用来调整方法的访问控制。
  217. //示例 #6 修改方法的访问控制
  219. trait   modfy_as{
  220.       public  function    hello(){
  221.        echo "使用as修改权限";
  222.     }
  223. }
  225. class     modfyasclass{
  226. use  modfy_as{
  228.     hello  as  protected;
  230. }
  232. function   test(){
  234.     echo  $this->hello();
  235. }
  236. }
  239. $obj=new  modfyasclass;
  240. // $obj->hello();
  241. $obj->test();
  244. // 给方法一个改变了访问控制的别名
  245. // 原版 sayHello 的访问控制则没有发生变化
  247. class     modfyasclassii{
  249.     use  modfy_as{
  251.         hello  as  protected  okay;
  253.     }
  256. function   test(){
  258.     $this->okay();
  259. }
  261. }
  264. $obj=new   modfyasclassii;
  266. $obj->test();
  268. echo  "<hr>";
  270. // 从 trait 来组成 trait
  271. // 正如 class 能够使用 trait 一样，其它 trait 也能够使用 trait。
  272. // 在 trait 定义时通过使用一个或多个 trait，
  273. // 能够组合其它 trait 中的部分或全部成员。
  274. trait     okay{
  276. public   function    Testokay(){
  278. echo   "Testokay";
  280. }
  282. }
  284. trait     Methodtest{
  286.     public   function    Testmethod(){
  288.     echo   "Methodtest";
  290.     }
  292. }
  294. trait   testokaymethod{
  296.   use  okay,Methodtest;
  298. }
  300. class       okay_methodtest{
  302.     use  testokaymethod; 
  303. }
  304. $obj=new   okay_methodtest;
  305. $obj->Testokay();
  306. echo "<pre></pre>";
  307. $obj->Testmethod();
  309. echo  "<br>";

运行结果:

上一条：快速开发对项目有价值下一条：控制器访问与参数解析类以及api天气接口实现输入城市查询天气
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多