2020年5月24日

    1. <?php
    2. class A{
    3. protected static function test(){}
    5. public static function __callStatic($name,$params){
    6. var_dump($name);
    7. var_dump($params); 
    9. //通过接收到的名字做操作，然后返回值
    10. if($name=='sum'){
    11. //求和
    12. $sum=0;
    13. foreach($params as $value){
    14.     $sum+=$value;
    15. }
    16. return $sum;
    17. }
    18. }
    19. }
    22. //调用不存在方法
    23. A::hz('a','b');
    25. echo"<hr>";
    26. //调用没有权限的方法
    27. A::test(100,200,300);
    28. echo"<hr>";
    29. //魔法方法中实现累加功能
    30. $res=A::sum(530,110,125);
    31. var_dump($res);
    33. class A{
    34. //通常不写形参，参数并不是确定
    35. public function __invoke(){
    37. $p =func_get_args();
    38. var_dump($p);
    39. $sum=0;
    40. foreach ($p as $value){
    41. $sum+=$value;
    42. }
    43. return $sum;
    44. }
    45. }
    47. //把对象当成函数调用起始就是去调用类中的__invoke方法
    48. $obj=new A();
    49. var_dump($obj(50,60,70));
    51. abstract class A{
    52. public $name="黑子";
    53.  //定义抽象方法
    54. abstract public function demo();
    55. abstract public function demo1($name,$age);
    57.   public function adc(){
    58.   var_dump("adc");
    60.   }
    61. }
    63. class B extends A{
    64. //实现抽象方法
    65. public function demo(){
    66. var_dump("demo方法");
    68. }
    69. public function demo1($n,$a){
    70. var_dump("demo1方法",$n,$a);
    71. }
    72. }
    74. $obj=new B();
    75. var_dump($obj);
    76. $obj->demo();
    77. $obj->demo1('小黑'，18);
    78. $obj->adc();
    79. var_dump($obj->name);
    82. <?php
    83. class A{
    84. protected static function test(){}
    86. public static function __callStatic($name,$params){
    87. var_dump($name);
    88. var_dump($params); 
    90. //通过接收到的名字做操作，然后返回值
    91. if($name=='sum'){
    92. //求和
    93. $sum=0;
    94. foreach($params as $value){
    95.     $sum+=$value;
    96. }
    97. return $sum;
    98. }
    99. }
    100. }
    103. //调用不存在方法
    104. A::hz('a','b');
    106. echo"<hr>";
    107. //调用没有权限的方法
    108. A::test(100,200,300);
    109. echo"<hr>";
    110. //魔法方法中实现累加功能
    111. $res=A::sum(530,110,125);
    112. var_dump($res);
    114. class A{
    115. //通常不写形参，参数并不是确定
    116. public function __invoke(){
    118. $p =func_get_args();
    119. var_dump($p);
    120. $sum=0;
    121. foreach ($p as $value){
    122. $sum+=$value;
    123. }
    124. return $sum;
    125. }
    126. }
    128. //把对象当成函数调用起始就是去调用类中的__invoke方法
    129. $obj=new A();
    130. var_dump($obj(50,60,70));
    132. abstract class A{
    133. public $name="黑子";
    134.  //定义抽象方法
    135. abstract public function demo();
    136. abstract public function demo1($name,$age);
    138.   public function adc(){
    139.   var_dump("adc");
    141.   }
    142. }
    144. class B extends A{
    145. //实现抽象方法
    146. public function demo(){
    147. var_dump("demo方法");
    149. }
    150. public function demo1($n,$a){
    151. var_dump("demo1方法",$n,$a);
    152. }
    153. }
    155. $obj=new B();
    156. var_dump($obj);
    157. $obj->demo();
    158. $obj->demo1('小黑'，18);
    159. $obj->adc();
    160. var_dump($obj->name);
    164. <?php
    165. class A{
    166. protected static function test(){}
    168. public static function __callStatic($name,$params){
    169. var_dump($name);
    170. var_dump($params); 
    172. //通过接收到的名字做操作，然后返回值
    173. if($name=='sum'){
    174. //求和
    175. $sum=0;
    176. foreach($params as $value){
    177.     $sum+=$value;
    178. }
    179. return $sum;
    180. }
    181. }
    182. }
    185. //调用不存在方法
    186. A::hz('a','b');
    188. echo"<hr>";
    189. //调用没有权限的方法
    190. A::test(100,200,300);
    191. echo"<hr>";
    192. //魔法方法中实现累加功能
    193. $res=A::sum(530,110,125);
    194. var_dump($res);
    196. class A{
    197. //通常不写形参，参数并不是确定
    198. public function __invoke(){
    200. $p =func_get_args();
    201. var_dump($p);
    202. $sum=0;
    203. foreach ($p as $value){
    204. $sum+=$value;
    205. }
    206. return $sum;
    207. }
    208. }
    210. //把对象当成函数调用起始就是去调用类中的__invoke方法
    211. $obj=new A();
    212. var_dump($obj(50,60,70));
    214. abstract class A{
    215. public $name="黑子";
    216.  //定义抽象方法
    217. abstract public function demo();
    218. abstract public function demo1($name,$age);
    220.   public function adc(){
    221.   var_dump("adc");
    223.   }
    224. }
    226. class B extends A{
    227. //实现抽象方法
    228. public function demo(){
    229. var_dump("demo方法");
    231. }
    232. public function demo1($n,$a){
    233. var_dump("demo1方法",$n,$a);
    234. }
    235. }
    237. $obj=new B();
    238. var_dump($obj);
    239. $obj->demo();
    240. $obj->demo1('小黑'，18);
    241. $obj->adc();
    242. var_dump($obj->name);

    笔记：
    魔术方法 callStatic
    当调用一个不可访问（不存在）的静态方法，自动调用
    callStatic(string $name,array $param):mixed
    注意：需要修饰为静态

    魔术方法 invoke
    invoke([$…]):mixed
    把对象当成函数调用的时候自动换行，并且会将实参传递带该魔术方法中

    抽象类
    限定子类必须编写方法，同时还能有一些通用的方法(属性)继承
    语法：
    类：abstract class 类名{}
    方法：abstract public function 函数名（）；

    1.如果类中有抽象方法，那类也必须定义为抽象类；
    2.抽象类不能实例化
    3.继承的抽象类中的所有方法必须实现（定义），可以添加形参但是必须兼容原有规则（抽象方法）；
    4.出了抽象方法以外，其他内容都按正常的继承来使用