2020年5月21日

    1. <?php
    2. class A{
    3. protected $a = '黑子';
    4.   public function __isset($name){
    5.   return isset($this->$name);
    7.   }
    8. }
    10. $res= new A();
    11. //访问不存在的属性
    12. var_dump(isset($res->b));
    13.   var_dump(empty($res->b));
    14. //访问不可访问的属性
    15.   var_dump(isset($res->a));
    16.   var_dump(empty($res->a));
    20. class A{
    21. protected $a = '黑子';
    22.   public function __unset($name){
    23.   unset($this->$name);
    25.   }
    26. }
    29. $res=new A();
    30. var_dump($res);
    31. //删除一个不存在的属性
    32. unset($res->b);
    33. //删除一个不可访问的属性
    34. unset($res->a);
    37. class A{
    38. public static $name = 'A=>static';
    39. public static function demo(){
    40. //使用静态变量
    41. //用self代替$this
    42. var_dump(self::$name);
    43.   //调用静态方法
    44.   self::demo1;
    46. }
    47. public static function demo1(){
    48. var_dump('demo1');
    49. }
    50. //如非要访问动态内容(特定时使用)
    51.   public static function gto(){
    52.   $res =new self();
    53.   var_dump($res);
    54.     //调用动态方法
    55.     $res->demo2();
    56.   }
    57.   public function demo2(){
    58.   var_dump('demo2');
    59.     var_dump($this);
    60.   }
    61. }
    63. //访问静态变量
    64. var_dump(A::$name);
    65. //使用静态方法
    66. A::demo();
    67. //静态方法调用动态
    68. A::gto();
    70. final class A{
    71. final public function demo(){
    72. var_dump('A::demo()');
    73. }
    74. }
    76. //测试
    77. //$obj = new A();
    78. //$obj->demo();
    80. class B extend A{
    81. //public function demo(){
    82. //var_dump("不可覆盖")}
    83. }
    85. $obj =new B;
    86. $obj->demo();
    89. class A{}
    90. //判断对象是否属于某个类
    91. //实例化得到一个对象  
    92. $res = new A();
    93. var_dump($res instanceof A);  
    95. //判断对象和对应的类是否是祖先
    96. class B{}
    97. class C extends B{}
    98. //实例化得到c类对象
    99. $resC = new C();
    100. var_dump($resC instanceof B);
    101. //继承只能单继承，多层级的方式来继承多个类
    102. class D extends C{}
    103. $resD = new D();
    104. var_dump($resD instanceof B);
    105. //c类对象是否是d类的实例化
    106. //不是
    107. var_dump($resC instanceof D);
    111. class A{
    112. public $name = 'hz';
    113.   public function __clone(){
    114.   $this->name ='克隆01';
    115.   }
    116. }
    119. $res1 = new A();
    120. var_dump($res1->name);
    122. $res2 = $res1;//变量的内存地址赋值给$res2
    123. var_dump($res2->name);
    124. //改变res2的name属性
    125. $res2->name='fire';
    126. var_dump($res1->name,$res2->name);
    127. echo"<hr>";
    128. $res3 =clone $res1;
    129. var_dump($res3->value);
    130. echo"<hr>"
    131. $res3 ->value="new fire";
    132. var_dump($res1->value,$res3->value);
    133. ?>
    137. <?php
    138. class A{
    139. protected $a = '黑子';
    140.   public function __isset($name){
    141.   return isset($this->$name);
    143.   }
    144. }
    146. $res= new A();
    147. //访问不存在的属性
    148. var_dump(isset($res->b));
    149.   var_dump(empty($res->b));
    150. //访问不可访问的属性
    151.   var_dump(isset($res->a));
    152.   var_dump(empty($res->a));
    156. class A{
    157. protected $a = '黑子';
    158.   public function __unset($name){
    159.   unset($this->$name);
    161.   }
    162. }
    165. $res=new A();
    166. var_dump($res);
    167. //删除一个不存在的属性
    168. unset($res->b);
    169. //删除一个不可访问的属性
    170. unset($res->a);
    173. class A{
    174. public static $name = 'A=>static';
    175. public static function demo(){
    176. //使用静态变量
    177. //用self代替$this
    178. var_dump(self::$name);
    179.   //调用静态方法
    180.   self::demo1;
    182. }
    183. public static function demo1(){
    184. var_dump('demo1');
    185. }
    186. //如非要访问动态内容(特定时使用)
    187.   public static function gto(){
    188.   $res =new self();
    189.   var_dump($res);
    190.     //调用动态方法
    191.     $res->demo2();
    192.   }
    193.   public function demo2(){
    194.   var_dump('demo2');
    195.     var_dump($this);
    196.   }
    197. }
    199. //访问静态变量
    200. var_dump(A::$name);
    201. //使用静态方法
    202. A::demo();
    203. //静态方法调用动态
    204. A::gto();
    206. final class A{
    207. final public function demo(){
    208. var_dump('A::demo()');
    209. }
    210. }
    212. //测试
    213. //$obj = new A();
    214. //$obj->demo();
    216. class B extend A{
    217. //public function demo(){
    218. //var_dump("不可覆盖")}
    219. }
    221. $obj =new B;
    222. $obj->demo();
    225. class A{}
    226. //判断对象是否属于某个类
    227. //实例化得到一个对象  
    228. $res = new A();
    229. var_dump($res instanceof A);  
    231. //判断对象和对应的类是否是祖先
    232. class B{}
    233. class C extends B{}
    234. //实例化得到c类对象
    235. $resC = new C();
    236. var_dump($resC instanceof B);
    237. //继承只能单继承，多层级的方式来继承多个类
    238. class D extends C{}
    239. $resD = new D();
    240. var_dump($resD instanceof B);
    241. //c类对象是否是d类的实例化
    242. //不是
    243. var_dump($resC instanceof D);
    247. class A{
    248. public $name = 'hz';
    249.   public function __clone(){
    250.   $this->name ='克隆01';
    251.   }
    252. }
    255. $res1 = new A();
    256. var_dump($res1->name);
    258. $res2 = $res1;//变量的内存地址赋值给$res2
    259. var_dump($res2->name);
    260. //改变res2的name属性
    261. $res2->name='fire';
    262. var_dump($res1->name,$res2->name);
    263. echo"<hr>";
    264. $res3 =clone $res1;
    265. var_dump($res3->value);
    266. echo"<hr>"
    267. $res3 ->value="new fire";
    268. var_dump($res1->value,$res3->value);
    269. ?>
    273. <?php
    274. class A{
    275. protected $a = '黑子';
    276.   public function __isset($name){
    277.   return isset($this->$name);
    279.   }
    280. }
    282. $res= new A();
    283. //访问不存在的属性
    284. var_dump(isset($res->b));
    285.   var_dump(empty($res->b));
    286. //访问不可访问的属性
    287.   var_dump(isset($res->a));
    288.   var_dump(empty($res->a));
    292. class A{
    293. protected $a = '黑子';
    294.   public function __unset($name){
    295.   unset($this->$name);
    297.   }
    298. }
    301. $res=new A();
    302. var_dump($res);
    303. //删除一个不存在的属性
    304. unset($res->b);
    305. //删除一个不可访问的属性
    306. unset($res->a);
    309. class A{
    310. public static $name = 'A=>static';
    311. public static function demo(){
    312. //使用静态变量
    313. //用self代替$this
    314. var_dump(self::$name);
    315.   //调用静态方法
    316.   self::demo1;
    318. }
    319. public static function demo1(){
    320. var_dump('demo1');
    321. }
    322. //如非要访问动态内容(特定时使用)
    323.   public static function gto(){
    324.   $res =new self();
    325.   var_dump($res);
    326.     //调用动态方法
    327.     $res->demo2();
    328.   }
    329.   public function demo2(){
    330.   var_dump('demo2');
    331.     var_dump($this);
    332.   }
    333. }
    335. //访问静态变量
    336. var_dump(A::$name);
    337. //使用静态方法
    338. A::demo();
    339. //静态方法调用动态
    340. A::gto();
    342. final class A{
    343. final public function demo(){
    344. var_dump('A::demo()');
    345. }
    346. }
    348. //测试
    349. //$obj = new A();
    350. //$obj->demo();
    352. class B extend A{
    353. //public function demo(){
    354. //var_dump("不可覆盖")}
    355. }
    357. $obj =new B;
    358. $obj->demo();
    361. class A{}
    362. //判断对象是否属于某个类
    363. //实例化得到一个对象  
    364. $res = new A();
    365. var_dump($res instanceof A);  
    367. //判断对象和对应的类是否是祖先
    368. class B{}
    369. class C extends B{}
    370. //实例化得到c类对象
    371. $resC = new C();
    372. var_dump($resC instanceof B);
    373. //继承只能单继承，多层级的方式来继承多个类
    374. class D extends C{}
    375. $resD = new D();
    376. var_dump($resD instanceof B);
    377. //c类对象是否是d类的实例化
    378. //不是
    379. var_dump($resC instanceof D);
    383. class A{
    384. public $name = 'hz';
    385.   public function __clone(){
    386.   $this->name ='克隆01';
    387.   }
    388. }
    391. $res1 = new A();
    392. var_dump($res1->name);
    394. $res2 = $res1;//变量的内存地址赋值给$res2
    395. var_dump($res2->name);
    396. //改变res2的name属性
    397. $res2->name='fire';
    398. var_dump($res1->name,$res2->name);
    399. echo"<hr>";
    400. $res3 =clone $res1;
    401. var_dump($res3->value);
    402. echo"<hr>"
    403. $res3 ->value="new fire";
    404. var_dump($res1->value,$res3->value);
    405. ?>

    笔记
    魔术方法 isset
    isset(string $name) :bool
    在使用isset或者empty()去访问一个不存在或不可访问的属性时自动调用

    从哪来（调用 访问）
    到哪去（返回值 结果）

    魔术方法 unset
    unset(string $name) :void
    当调用unset去删除不可访问或不存在访问的属性时自动调用

    静态修饰符：static
    语法：
    属性：[访问控制修饰符] [静态修饰符] 变量[ = 值]；
    方法：[访问控制修饰符] [静态修饰符] function 方法名(){}

    静态内容（有静态修饰符的方法和属性）无需实例化，直接使用 ::调用；
    静态方法中没有$this全部使用self代替
    静态方法中只能去访问静态方法和静态变量
    如非要访问动态内容(特定时使用);静态方法中去new这个类；就会得到对象

    final 关键词(修饰符)
    类：final class 类名{}
    方法：final [访问控制修饰符] [静态修饰符] function 方法名(){}

    instanceof 运算符 关键字
    用来判断一个对象是否属于某个类（或祖先）

    对象克隆
    由于对象复制不能够直接复制（引用类型）所以需要使用clone关键字；
    clone(): clone() :void
    当克隆时自动调用；类似构造函数(clone);
    去做一些特殊参数的初始化