日志

PHP类的访问控制

PHP的类属性、方法的可见性通过三个关键词来定义,即public、protected和private

  • 关键词

  1. public

    类成员(方法、属性)可以随处访问;
    以var声明的类属性会被定义为public性质;
    为了兼容PHP4,如果没有指定访问控制,属性和方法默认为公有的;

  2. protected

    类成员可以被自身、继承类和父类访问。(注意:类实例对象不可访问)

  3. private

    类成员只允许自身访问

  • 例子

PHP version: PHP5.5

  1. <?php
  2. class obj{
  3. public $obj_pub = 'obj_pub';
  4. protected $obj_protected = 'obj_protected';
  5. private $obj_private = 'obj_private';
  6.  
  7. public function print_data(){
  8. echo $this->obj_private;
  9. echo $this->obj_protected;
  10. echo $this->obj_private;
  11. }
  12.  
  13. protected function method_protected(){}
  14.  
  15. private function method_private(){}
  16. }
  17.  
  18. $o = new obj();
  19. echo $o->obj_pub;//公有属性调用
  20. echo $o->obj_protected; //报错,实例对象不可访问受保护的类属性
  21. echo $o->obj_private; //报错,实例对象不可访问私有属性
  22. echo $o->print_data();//调用公有方法
  23.  
  24. class animal extends obj{
  25. public function print_1(){
  26. echo $this->obj_pub;//调用父类公有属性
  27. echo $this->obj_protected;//调用父类受保护的属性
  28. }
  29.  
  30. public function print_2(){
  31. echo $this->obj_privatje;//报错,父类私有属性禁止子类访问
  32. }
  33.  
  34. public function foo(){
  35. $this->print_data();//调用父类公有方法
  36. $this->method_protected();//调用父类受保护的方法
  37. $this->method_private();//报错,父类私有方法禁止子类访问
  38. }
  39. }
  40.  
  41. $a = new animal();
  42. $a->print_1();
  43. $a->print_2();
  44. $a->foo();
转载请注明出处:

© http://hejunhao.me

日志

PHP的__construct和__destruct

__construct

__construct是PHP的构造函数,在对象创建时首先被调用,如果子类没有定义构造函数则会从父类继承其构造函数(非私有时),如果子类已经定义了构造函数则不会隐式调用父类的构造函数,子类可以通过parent::__construct(..)的方式调用父类构造函数.构造函数主要在对象创建时进行必要的初始化工作.

特别地,子类的构造函数的参数不需要与父类的构造函数一致,即覆盖时不会报E_STRICT错误

如果子类没有定义__construct(),也没有从父类继承,那么会尝试寻找旧式构造函数(与类同名的函数)(注意:从PHP5.3.3起,在命名空间中,与类同名的方法不再作为构造函数

__destruct

__destruct是PHP的析构函数,在对象被删除或隐式销毁时被调用. (since PHP5)

例子

  1. <?php
  2. class obj{
  3. public $name = '';
  4. function __construct($name){
  5. echo 'obj_construct call' . PHP_EOL;
  6. $this->name = $name;
  7. }
  8.  
  9. function __toString(){
  10. return $this->name . PHP_EOL;
  11. }
  12.  
  13. function __destruct(){
  14. echo 'obj_destruct call' . PHP_EOL;
  15. }
  16. }
  17.  
  18. class animal extends obj{
  19. public $name = '';
  20. public $height = '';
  21. function __construct($name, $height){
  22. parent::__construct($name);
  23. echo 'animal_construct call' . PHP_EOL;
  24. $this->name = $name;
  25. $this->height = $height;
  26. }
  27.  
  28. function __toString(){
  29. return $this->name . ': ' . $this->height . PHP_EOL;
  30. }
  31. }
  32.  
  33. class dog extends animal{
  34.  
  35. function __destruct(){
  36. echo 'dog_destruct call'.PHP_EOL;
  37. }
  38. }
  39.  
  40. $d = new dog('dog','90cm');
  41. echo $d;
  42. unset($d);
  43. echo '--------分割线-----' . PHP_EOL;
  44. $a = new animal('animal', '100cm');
  45. echo $a;
  46. unset($a);
  47.  
  48. /********输出********
  49.  
  50. obj_construct call
  51. animal_construct call
  52. dog: 90cm
  53. dog_destruct call
  54. --------分割线-----
  55. obj_construct call
  56. animal_construct call
  57. animal: 100cm
  58. obj_destruct call
  59.  
  60. *********************/
日志

PHP中this、self和parent的区别

this

this是指向类实例化对象的指针,因此它指向的不是类而是类实例化后的对象,例如 $obj = new Animal(); 此时类内部定义的$this指的就是$obj这个对象,而不是Animal这个类.

self

self是类自身的引用,通常指向类的静态成员常量,在类体内引用静态成员和常量时不能用$this->var / $this->foo() 的形式.

parent

parent是指向父类的引用,通过parent可以访问父类方法(不管是否为静态)、父类静态成员父类常量,但不可以访问父类的非静态属性.(注意:$this也可以调用父类方法,但是如果继承类覆盖了父类方法A,那么$this->A()指的是继承类的A()方法,而parent::A()指的依然是父类的A()方法,不受覆盖影响

例子

  1. <?php
  2. class Object{
  3. public $name = '';
  4. public function __construct($name){
  5. $this->name = $name;
  6. }
  7.  
  8. protected function foo(){
  9. echo 'Object foo function'.PHP_EOL;
  10. }
  11. }
  12.  
  13. class Animal extends Object{
  14. public static $count = 0;
  15. const OBJECT_ID = 999;
  16.  
  17. public function __construct($name){
  18. parent::__construct($name);
  19. self::count();
  20. parent::foo();
  21. $this->foo();
  22. }
  23.  
  24. protected function foo(){
  25. echo 'Animal foo function'.PHP_EOL;
  26. }
  27.  
  28. private static function count(){
  29. self::$count += 1;
  30. }
  31. }
  32.  
  33. $a = new Animal('dog');
  34. echo $a->name;
  35. echo PHP_EOL;
  36. echo Animal::$count;
  37. echo PHP_EOL;
  38. echo Animal::OBJECT_ID;
  39. echo PHP_EOL;
  40.  
  41. $c = new Animal('cat');
  42. echo $c->name;
  43. echo PHP_EOL;
  44. echo Animal::$count;
  45. echo PHP_EOL;
  46. echo Animal::OBJECT_ID;
  47.  
  48. /*****Output*****
  49. Object foo function
  50. Animal foo function
  51. dog
  52. 1
  53. 999
  54. Object foo function
  55. Animal foo function
  56. cat
  57. 2
  58. 999
  59.  
  60. *******************/
转载请注明出处:

© http://hejunhao.me