2020年5月17日

    1. <?php
    2. class A
    3. {
    4. public $name;//定义名字
    5. //定义构造方法
    6. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    7. //作用：对象的内容初始化（做某件事件前的准备工作）
    8. public function __construct($demo){
    9. echo "构造方法"
    10. var_dump($demo);
    11. $this→name = $demo;
    12. }  
    13. }
    15. $obj = new A('黑子');
    16. var_dump($obj);
    20. class A
    21. {
    22. public $name;//定义名字
    23. //定义构造方法
    24. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    25. //作用：对象的内容初始化（做某件事件前的准备工作）
    26. public function __construct($demo){
    27. //初始化name变量的内容
    28. $this→name = $demo;
    29. echo $this→name, ":结构","<br>";
    30. }  
    31. //定义析构方法  
    32. //执行：在对象销毁即将执行前 执行→销毁
    33. //1.文件执行完成 2.unset（从内存中移除）
    34. //作用：关闭数据库连接 关闭文件  关闭目录
    35. public function __destruct(){
    36. echo $this→name, ":析构","<br>";
    37. }
    38. }
    40. $obj = new A('张三');
    41. $obj2 = new A('李四');
    42. $obj3 = new A('王五');
    45. class A{
    46. public $name = '公共';
    47. protected $name2 = '受保护';
    48. private $name3 = '私有';
    50. public function fangwen(){
    51. var_dump($this->name);
    52. var_dump($this->name2);
    53.  var_dump($this->name3);
    55.   $this -> demo1();
    56.   $this -> demo2();
    57.   $this -> demo3();
    58. }  
    59.   //测试每个修饰符的功能
    60.   public function demo1(){
    61.   var_dump('公开的成员方法');
    62.   }
    63.     public function demo2(){
    64.   var_dump('受保护的成员方法');
    65.   }
    66.     public function demo3(){
    67.   var_dump('私有的成员方法');
    68.   }
    69. }
    71. //实例化
    72. $obj =new A();
    73. var_dump($obj->name);
    76. <?php
    77. class A
    78. {
    79. public $name;//定义名字
    80. //定义构造方法
    81. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    82. //作用：对象的内容初始化（做某件事件前的准备工作）
    83. public function __construct($demo){
    84. echo "构造方法"
    85. var_dump($demo);
    86. $this→name = $demo;
    87. }  
    88. }
    90. $obj = new A('黑子');
    91. var_dump($obj);
    95. class A
    96. {
    97. public $name;//定义名字
    98. //定义构造方法
    99. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    100. //作用：对象的内容初始化（做某件事件前的准备工作）
    101. public function __construct($demo){
    102. //初始化name变量的内容
    103. $this→name = $demo;
    104. echo $this→name, ":结构","<br>";
    105. }  
    106. //定义析构方法  
    107. //执行：在对象销毁即将执行前 执行→销毁
    108. //1.文件执行完成 2.unset（从内存中移除）
    109. //作用：关闭数据库连接 关闭文件  关闭目录
    110. public function __destruct(){
    111. echo $this→name, ":析构","<br>";
    112. }
    113. }
    115. $obj = new A('张三');
    116. $obj2 = new A('李四');
    117. $obj3 = new A('王五');
    120. class A{
    121. public $name = '公共';
    122. protected $name2 = '受保护';
    123. private $name3 = '私有';
    125. public function fangwen(){
    126. var_dump($this->name);
    127. var_dump($this->name2);
    128.  var_dump($this->name3);
    130.   $this -> demo1();
    131.   $this -> demo2();
    132.   $this -> demo3();
    133. }  
    134.   //测试每个修饰符的功能
    135.   public function demo1(){
    136.   var_dump('公开的成员方法');
    137.   }
    138.     public function demo2(){
    139.   var_dump('受保护的成员方法');
    140.   }
    141.     public function demo3(){
    142.   var_dump('私有的成员方法');
    143.   }
    144. }
    146. //实例化
    147. $obj =new A();
    148. var_dump($obj->name);
    151. <?php
    152. class A
    153. {
    154. public $name;//定义名字
    155. //定义构造方法
    156. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    157. //作用：对象的内容初始化（做某件事件前的准备工作）
    158. public function __construct($demo){
    159. echo "构造方法"
    160. var_dump($demo);
    161. $this→name = $demo;
    162. }  
    163. }
    165. $obj = new A('黑子');
    166. var_dump($obj);
    170. class A
    171. {
    172. public $name;//定义名字
    173. //定义构造方法
    174. //执行：当类被实例化的时候回执行（实例化就是创造对象）
    175. //作用：对象的内容初始化（做某件事件前的准备工作）
    176. public function __construct($demo){
    177. //初始化name变量的内容
    178. $this→name = $demo;
    179. echo $this→name, ":结构","<br>";
    180. }  
    181. //定义析构方法  
    182. //执行：在对象销毁即将执行前 执行→销毁
    183. //1.文件执行完成 2.unset（从内存中移除）
    184. //作用：关闭数据库连接 关闭文件  关闭目录
    185. public function __destruct(){
    186. echo $this→name, ":析构","<br>";
    187. }
    188. }
    190. $obj = new A('张三');
    191. $obj2 = new A('李四');
    192. $obj3 = new A('王五');
    195. class A{
    196. public $name = '公共';
    197. protected $name2 = '受保护';
    198. private $name3 = '私有';
    200. public function fangwen(){
    201. var_dump($this->name);
    202. var_dump($this->name2);
    203.  var_dump($this->name3);
    205.   $this -> demo1();
    206.   $this -> demo2();
    207.   $this -> demo3();
    208. }  
    209.   //测试每个修饰符的功能
    210.   public function demo1(){
    211.   var_dump('公开的成员方法');
    212.   }
    213.     public function demo2(){
    214.   var_dump('受保护的成员方法');
    215.   }
    216.     public function demo3(){
    217.   var_dump('私有的成员方法');
    218.   }
    219. }
    221. //实例化
    222. $obj =new A();
    223. var_dump($obj->name);

    实例化类
    发起实例化请求→执行构造函数（构造对象的初始内容）→得到对象
    构造函数可以接受参数
    传递参数给结构函数
    栈内存 变量都是存储在栈内存 后进先出
    栈内存可以理解为是一个桶子；
    队列（排队） 先进先出

    访问控制
    属性
    [访问修饰符]变量名字；
    方法
    [访问修饰符]function 函数名(){}
    访问修饰符：public 公开（公共）
    protected 受保护的
    private 私有的
    访问位置：内部 外部

    使用实例化的对象来访问就是外部访问