上一节:

  PHP 访问控制

  • 公共成员（public）

    通过将成员指定为私有的，可以将其可访问性限制为声明它的类。私有成员不能从继承声明它的类的类引用，也不能从类外部访问。通过使用成员的private关键字指定，可以使类成员变为私有的。 
    function getPrice() {
   echo $this->price . "<br/>";
   echo "我是来自子类的方法1<br/>";
}
   
function getTitle(){
   echo $this->title . "<br/>";
   echo "我是来自子类的方法1<br/>";
}
    尝试一下

  • 私有成员（private）

    除非您另行指定，否则类的属性和方法是公共的，可以显式的用关键字public指定。也就是说，可以在三种可能的情况下访问它们
    • 从声明它的类之外
    • 从声明它的类中
    • 从另一个实现声明它的类的类中
    class MyClass {
   private $car = "skoda";
   $driver = "SRK";
   
   /*构造方法*/
   function __construct($par) {
        
   }
   
   function myPublicFunction() {
      return("外部和继承类，我是可见的!");
   }
   
   private function myPrivateFunction() {
      return("外部和继承类，我是不可见的!");
   }
}
    当MyClass类由另一个使用extends继承的类时，myPublicFunction()将是可见的，$driver也是可见的。子类不会对myPrivateFunction和$car有任何意识或访问权限，因为它们被声明为私有的。

  • 受保护成员（protected）

    受保护的属性或方法可以在声明它的类中以及扩展该类的类中访问。受保护的成员在这两类之外是不可用的。可以通过在成员使用protected关键字来保护类成员。 
    class MyClass {
   protected $car = "skoda";
   $driver = "SRK";

   /*构造方法*/
   function __construct($par) {
      
   }
   
   function myPublicFunction() {
      return("我外部和继承类都可见");
   }
   
   protected function myPrivateFunction() {
      return("我只是在类内部和继承类中可见，外部不可见");
   }
}

  • 接口（interface）

    定义接口以向实现者提供通用函数名称。不同的实现者可以根据需要实现这些接口（换句话说接口只是声明，没有实现，是一种特殊的类，可以用interface来声明接口）。可以说，接口是开发人员实现的骨架。 
    interface Mail {
   public function sendMail();
}
    然后，如果另一个类实现了该接口（用implements来实现），就像这样 
    class Report implements Mail {
   // sendMail() 函数的具体实现写在这里
   public  function sendMail(){
       echo 'send  mail!!';
   }
}

  • 类常量（interface）

    常量有点像变量，因为它保存一个值，但实际上更像是一个函数，因为常量是不可变的。一旦声明了常量，它就不会改变。声明一个常量很容易，访问类常量可以用类名加两个冒号来访问，就像在这个版本的MyClass中一样 
    class MyClass {
   const requiredMargin = 1.7;
   
   function __construct($incomingValue) {
      //构造函数
   }
}

echo  MyClass::requiredMargin;
    尝试一下
    在这个类中，requiredMargin是一个常量。它使用关键字const声明，并且在任何情况下都不能将其更改为1.7以外的任何值。请注意，常量的名称没有前导$，因为变量名称可以。

  • 抽象类（abstract）

    抽象类是无法实例化的，只能继承的类。您使用关键字abstract声明一个抽象类，如下所示，从抽象类继承时，父类声明中标记为abstract的所有方法都必须由子类定义实现; 此外，必须使用相同的可见性定义这些方法。 
    <?php
abstract class MyAbstractClass {

        abstract function myAbstractFunction();

        function test(){
                echo 'test';
        }
}

class MyClass extends MyAbstractClass{
        // 这个类继承了一个抽象类，必需实现里面的抽象方法
        function myAbstractFunction(){
                echo 'abstract';
        }
}
    请注意，抽象类中的函数定义也必须以关键字abstract开头。在非抽象类中包含抽象函数定义是不合法的。

  • static 关键字

    将类成员或方法声明为静态使得它们可以访问而无需实例化类。声明为static的成员无法使用实例化的类对象访问（尽管静态方法可以）。
    试试下面的例子 
    <?php
class Foo {
        public static $my_static = 'foo';

        public  function staticValue() {
                return self::$my_static;
        }

        public static function staticMethod(){
                echo 'test11<br/>';
        }
}
//静态类成员属性通过类名访问
print Foo::$my_static . "<br/>";

$foo = new Foo();
print $foo->staticValue() . "<br/>";

//静态类成员方法通过类名访问 和 通过实例访问都可以
Foo::staticMethod();
$foo->staticMethod();

?>
    尝试一下

  • final 关键字

    PHP 5引入了final关键字，它通过在方法中添加final前缀来阻止子类覆盖方法。如果类本身被定义为final，则无法被继承。
    以下示例结果导致致命错误：无法覆盖最终方法BaseClass::moreTesting() 
    <?php

   class BaseClass {
      public function test() {
         echo "BaseClass::test() called<br>";
      }
      
      final public function moreTesting() {
         echo "BaseClass::moreTesting() called<br>";
      }
   }
   
   class ChildClass extends BaseClass {
          /*这里重写父类的final方法将报致命错误*/
      public function moreTesting() {
         echo "ChildClass::moreTesting() called<br>";
      }
   }
?>
    尝试一下
    查看下面继承final类的示例：也会报致命错误。 
    <?php

   final class BaseClass {
      public function test() {
         echo "BaseClass::test() called<br>";
      }
      
      public function moreTesting() {
         echo "BaseClass::moreTesting() called<br>";
      }
   }
   
   /*这里继承final类将报致命错误*/
   class ChildClass extends BaseClass {
          
       
   }
?>
    尝试一下
上一节: