PHP 的访问控制（可见性）、类常量和继承

旧城等待， 2022-05-27 07:22 200阅读 0赞

## 访问控制（可见性） ##

PHP 中，对类中的成员（属性和方法）的访问控制，是通过以下三个访问修饰符来实现的。

*  public（公有的）
 *  protected（受保护的）
 *  private（私有的）

public、protected 和 private 可以控制类成员的可见性（visibility）。

*  被定义为 public 的类成员，可以在任何地方被访问（任何地方可见）。
 *  被定义为 protected 的类成员，可以在其自身、子类和父类的内部访问。
 *  被定义为 private 的类成员，只能在其定义的类内部访问。

<?php class A { public $public = 'Public'; protected $protected = 'Protected'; private $private = 'Private'; const HASH = 'md5'; const STATUS = ['success'=>0, 'fail'=>1]; static $static = 'static'; public static $s1 = []; public function __construct($alias) { $this->alias = $alias; // 动态添加的属性，默认是 public。（不能动态添加一个静态属性） } function printHello() { // 在定义的类内部，可以访问自身的所有属性 echo $this->public; echo $this->protected; echo $this->private; echo ' '; } /** * 在父类中访问子类的成员，子类的 public、protected 的成员在父类中可见 */ public function accessChildClass() { $child = new static('b2'); // static 后期静态绑定 echo $child->protected;echo '--'; echo $child->alias; echo ' '; } } class B extends A { protected $protected = 'Protected2'; function printHello() { echo $this->public; echo $this->protected; echo $this->private; echo ' '; } /** * 在子类中访问父类的成员，父类的 public、protected 的成员在子类中可见 */ public function accessParentClass() { $parent = new parent('a2'); echo $parent->protected; echo '--'; echo $parent->alias; echo ' '; } } $obj = new A('a'); echo $obj->public; echo ' '; // 正常执行，public 的属性在任何地方可见 //echo $obj->protected; // 致命错误，因为 protected 的属性，只能在其自身、子类和父类中访问。致命错误会终止程序执行。 //echo $obj->private; // 致命错误 $obj->printHello(); // 正常执行，输出 Public、Protected 和 Private echo $obj->alias; echo ' '; // 正常执行，动态添加的属性，默认是 public echo A::HASH; echo ' '; // 正常执行，类常量在任何地方可见，是属于类的，而不是属于对象 echo B::HASH; echo ' '; // 正常执行，类常量可以被子类继承 $b = new B('b'); echo $b->public; echo ' '; // Public echo $b->private; echo ' '; // Notice: Undefined property //echo $b->protected; // Fatal error: Uncaught Error: Cannot access protected property $b->printHello(); // Public、Protected2、Notice: Undefined property: B::$private $b->accessChildClass(); // Protected2--b2，可以在父类中访问子类的 protected 和 public 的属性 $b->accessParentClass(); // Protected--a2, 也可以在子类中访问父类的 protected 和 public 的属性 var_dump(B::STATUS); echo ' '; // array(2) { ["success"]=> int(0) ["fail"]=> int(1) } echo A::$static; echo ' '; // static echo B::$static; echo ' '; // static var_dump(B::$s1); echo ' '; // array(0) { }

### 属性的可见性 ###

类中的属性的可见性，除了遵循下面三条通用的规则：

*  public 的属性，可以在任何地方被访问（任何地方可见）。
 *  protected 的属性，可以在其自身、子类和父类的内部访问。
 *  private 的属性，只能在其定义的类内部访问。

还需注意以下几点：

*  动态添加的属性，默认是 public 。（不能动态添加一个静态属性）
 *  static 关键字修饰的静态属性，默认是 public 。
 *  非静态属性，必须指定访问修饰符 public、protected 和 private 中的任意一个。

#### 非静态属性的访问方式 ####

*  通过 $this 访问，如 $this->public;
 *  通过具体的对象访问，如 (new A('a'))->public;

#### 静态属性的访问方式 ####

*  通过 self::、parent:: 和 static:: 访问，如：self::$static;
 *  通过具体的类名访问，如：A::$static;

### 方法的可见性 ###

类中的方法的可见性，除了遵循下面三条通用的规则：

*  public 的方法，可以在任何地方被访问（任何地方可见）。
 *  protected 的方法，可以在其自身、子类和父类的内部访问。
 *  private 的方法，只能在其定义的类内部访问。

还需注意以下几点：

*  方法如果没有明确指定可见性，默认是 public 。
 *  也可用 static 关键字将方法修饰为静态方法。

可以看出，方法的可见性和属性的可见性的规则基本是一致的。

#### 非静态方法的调用方式 ####

*  通过 $this 访问，如 $this->foo();
 *  通过具体的对象访问，如 (new B)->foo();
 *  通过 self::、parent:: 和 static:: 访问，如 static::foo();
 *  通过具体的类名访问，如 B::foo();

在 PHP 7 中，已经废弃（弃用）了静态调用非静态的方法，未来可能会移除该功能。

#### 静态方法的调用方式 ####

*  通过 self::、parent:: 和 static:: 访问，如 static::foo();
 *  通过具体的类名访问，如 B::foo();
 *  通过 $this 访问，如 $this->foo();
 *  通过具体的对象访问，如 (new B)->foo();

## 类常量 ##

类常量指的是在类内部的头部位置定义的常量。

如：

class A {
        const HASH = 'md5';
        const STATUS = ['success'=>0, 'fail'=>1];
        
        public function foo() { }
    }

可以把在类中始终保持不变的值定义为常量。

定义类常量只能使用 const 关键字。

常量的值必须是一个定值，不能是变量，类属性或其它操作（如函数调用）的结果。

在 PHP5.6 中，对 const 常量进行了增强，允许常量计算，允许使用包含数字、字符串字面值和常量的表达式结果来定义 const 常量。常量的值也可以是数组，但不能是变量。

关于类常量，还需注意以下几点：

*  类常量是属于类本身，而不是属于对象。
 *  类常量的访问方式和静态属性一致。
 *  类常量可以被继承。
 *  类常量不能被访问修饰符 public、protected 和 private 修饰。
 *  类常量不能被静态修饰符 static 修饰。
 *  类常量区分大小写。

在 PHP 中，变量、常量区分大小写，函数和类名不区分大小。但魔术常量不区分大小写。

## 继承 ##

在 PHP 中，类的继承会影响到类与类、对象与对象之间的关系。

关于类的继承，需要注意以下几点：

*  只有可见性为 public 和 protected 的属性和方法，才可以被子类继承。
 *  可见性为 private（私有）的属性或方法，不能被继承。
 *  类常量可以被继承。
 *  被子类继承的属性，可以在子类中重写（覆盖）；否则，将沿用原有的值。
 *  被子类继承的方法，也可在子类中重写（覆盖）；否则，将沿用原有的功能。

<?php class Person { public $name; protected $age=18; private $phone=''; public function getName() { echo $this->name; } protected function getAge() { echo $this->age; } protected function getClass() { echo __CLASS__; } private function getPhone() { echo $this->phone; } } class Tom extends Person { protected $age = 20; public function getName() { echo $this->name . '--' . __CLASS__; echo ' '; } public function printInfo() { $this->getAge(); echo '--'; parent::getAge(); echo '--'; parent::getClass(); } } $obj = new Tom(); $obj->getName(); // --Tom $obj->printInfo(); // 20--20--Person