下面小编就为大家分享一篇详谈PHP中public,private,protected,abstract等关键字的用法，具有很好的参考价值，希望对大家有所帮助，一起跟随小编过来看看吧。

PHP中常用的关键字

在PHP中包含了很多对函数和类进行限制的关键字，常用的通常有abstract,final,interface，public，protected,private,static等等，下面我们就将对这些进行分析整理各个的用法。

变量与方法的关键字public,private,protected

public的权限最大，既可以让子类使用，也可以支持实例化之后的调用，protected表示的是受保护的，访问的权限是只有在子类和本类中才可以被访问到private 表示的是私有，只能够是在当前的类中可以被访问到。

1. <?php 
2. // 
3. /** 
4. * Define MyClass 
5. */ 
6. class MyClass 
7. { 
8.  public $public = 'Public'; 
9.  protected $protected = 'Protected'; 
10.  private $private = 'Private'; 
11.  public function printHello() 
12.  { 
13.  echo $this->public; 
14.  echo $this->protected; 
15.  echo $this->private; 
16.  } 
17.  protected function pro_test(){ 
18.  var_dump(1); 
19.  } 
20. } 
21. $obj = new MyClass(); 
22. echo $obj->public; // 这行能被正常执行 
23. //echo $obj->protected; // 这行会产生一个致命错误 
24. //echo $obj->private; // 这行也会产生一个致命错误 
25. $obj->printHello(); // 输出 Public、Protected 和 Private 
26. $obj->pro_test();//直接报错 
27. ?> 

变量与方法的关键字static

static的作用就是能够实现值或者方法在类中不需实例化的情况下调用，同时static修饰的变量具有与值存储的功能，例如我们不使用static运行的结果如下：

1. <?php 
2. function test(){ 
3.  $var=1; 
4.  echo $var."</br>"; 
5.  $var++; 
6. } 
7. test();// 1 
8. test();// 1 
9. test();// 1 
10. ?> 

如果我们给变量加上static那么就会变成这样

1. <?php 
2. function test(){ 
3.  static $var=1; 
4.  echo $var."</br>"; 
5.  $var++; 
6. } 
7. test();// 1 
8. test();// 2 
9. test();// 3 
10. ?> 

这里可能不能够体会到PHP这样做的好处，那么我们就先来假设一下读者也熟悉JS，在JS中是没有static这个关键字的，所以如果我们要来实现一个具有能够保存每一次程序运算结果作为下一次运算的依据的一个程序我们需要这样来写。

1. var glo=0; 
2.  function test(){ 
3.  glo++; 
4.  document.writeln(glo); 
5.  } 
6.  test(); 
7.  test(); 
8.  test(); 

这样就会把glo泄漏到全局变量中，如果生成的变量比较多，就会导致内存泄露（内存泄漏所指代的就是变量占用过多的内存空间没有别释放）

1. <script> 
2.  var glo=0; 
3.  function test(){ 
4.  glo++; 
5.  document.writeln(glo); 
6.  } 
7.  test();// 1 
8.  test();// 2 
9.  test();// 3  
10. </script> 

所以相比于在没有定义static的语言中，它具有一个优势是保持变量，不泄露内存，也不容易导致全局变量被误用（因为作用域不在全局）

1. $age=0; 
2. $age++; 
3. function test1() { 
4.  static $age = 100; 
5.  $age++; 
6.  echo $age."</br>"; 
7. } 
8. function test2() { 
9.  static $age = 1000; 
10.  $age++; 
11.  echo $age."</br>"; 
12. } 
13. test1(); // 101 
14. test2(); // 1001 

class与方法的关键字final

final只能够用来修饰class与function，使用了final之后就不能够被继承，例如如下的代码就会直接报错

1. class BaseClass { 
2.  public $public = 'Public'; 
3.  function test() { 
4.  echo "BaseClass::test() called\n"; 
5.  } 
6.  final public function moreTesting() { 
7.  echo "BaseClass::moreTesting() called\n"; 
8.  } 
9. } 
10. class ChildClass extends BaseClass { 
11.  public function moreTesting() { 
12.  echo "ChildClass::moreTesting() called\n"; 
13.  } 
14. } 

特殊关键字interface,abstract

interface的意义在于规范编程的风格，设想一下就是如果是实现了一个接口那么我们在使用这个接口类的时候就必须要实现里面的方法，起到了统一命名的作用。

class是可以多继承接口的，接口与接口之间的单继承是通过extends来实现的，class与接口之间的关系确立是通过implements

示例代码：

1. <?php 
2. interface testA{ 
3.  function funcA(); 
4. } 
5. interface testB{ 
6.  function funcB(); 
7. } 
8. interface testC extends testA { 
9.  function funcC(); 
10. } 
11. class run implements testC ,testB { 
12.  public function funcA() 
13.  { 
14.  // TODO: Implement funcA() method. 
15.  } 
16.  public function funcB() 
17.  { 
18.  // TODO: Implement funcB() method. 
19.  } 
20.  public function funcC() 
21.  { 
22.  // TODO: Implement funcC() method. 
23.  } 
24. } 
25. ?> 

abstract的作用跟interface其实是一样的，但是在interface中所有的方法都是必须要实现的，但是在abstract修饰的类中，可以有一个或者是多个的abstract修饰方法，所以我们可以这样理解，interface就是abstract的一种特殊情况（当所有的方法都是抽象方法，都是必须要实现的）。abstract有以下的这些特征：

1. 只要类中有至少一个方法使用了abstract关键字，那么这个类是abstract，要加上相应的关键字

2. 抽象方法，只有方法的声明部分，没有方法体。

但是在我看来，abstract在实际的应用中有这样的几种场景

1. 多人编程的时候规范公共部分的命名规则（不做任何说明，原理跟interface一样）

2. 实现不让父级直接实例化使用

样式代码如下：

1. <?php 
2. abstract class shopping 
3. { 
4.  public function buy() 
5.  { 
6.  echo "buy"; 
7.  } 
8.  public function loan() 
9.  { 
10.  echo "loan"; 
11.  } 
12. } 
13. class leslieBuy extends shopping 
14. { 
15. } 
16. //$test1=new shopping;//直接语法错误 
17. $leslieSie = new leslieBuy; 
18. $leslieSie->loan();//打印出loan 
19. ?>

Tags: public private protected abstract

分享到：