php之关键字

Private, Public 和 Protected 在PHP4中，你可以在对象的外面操作它任意的方法和变量--因为方法和变量是公用的。在PHP5引用了3种模式来控制对变量、方法的控制权限：Public(公用的)、Protected(受保护)和Private(私有)

Public:方法和变量可以在任意的时候被访问到，子类可以重定义覆盖

Private:只能在类的内部被访问，子类也不能访问，子类可以重定义，各自独立

Protected:只能在类的内部、子类中被访问，不能重定义覆盖

Static: 类的静态成员和方法都不能被子类重定义

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为final，则子类无法覆盖该方法； 如果一个类被声明为final，则不能被继承。

static : 声明类的成员和方法为静态。作用：不需要实例化就可以被访问。使用:: 符号，外部使用方式为Class::$member和Class::method；内部使用方式self::$member和self::method。子类的使用方式parent::$member和parent::method 使用注意：

1. 类的静态成员不能被类的实例访问，即不能用箭头-<访问，而静态方法可以被类的实例访问。

2. 类的静态成员和方法都不能被子类重定义。意味着只能被本类使用，起到保护作用。 3. 类的静态方法内部不能使用$this伪变量，因为$this是指向类的实例的，会与static的作用发生矛盾。

const: 定义类的常量。使用注意：不能被类的实例访问。 <?php class

MyClass {

const constant = 'constant value';

function showConstant() { echo self::constant . "\n"; } }

echo MyClass::constant . "\n";

// echo $class::constant; is not allowed(这个是实例后访问)

声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法除外）。

为了兼容PHP4，如果没有指定“可见性”，属性和方法默认为public。

由于静态方法不需要通过对象即可调用，所以伪变量$this在静态方法中不可用。

1，static关键字在类中是，描述一个静态成员的；

2，static能够限制外部的访问，因为static后的成员是属于类的，是不属于任何对象实例，其他类是无法访问的，只对类的实例共享；

3，类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数；

4，类的静态方法能访问类的静态的属性。另外说明的是，static的成员，必须使用self来访问，使用this会出错。

final:PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为final，则子类无法覆盖该方法； 如果一个类被声明为final，则不能被继承。

const

const是一个定义常量的关键字，能够定义一个常量，如果在程序中改变了它的值，那么会出现错误。

例子4：Public, protected and private <?php class foo { private $x; public function public_foo() { print("I'm public"); } protected function protected_foo() { $this->private_foo(); //Ok because we are in the same class we can call private methods print("I'm protected"); } private function private_foo() { $this->x = 3; print("I'm private"); } } class foo2 extends foo { public function display() { $this->protected_foo(); $this->public_foo(); // $this->private_foo();// Invalid! the function is private in the base class } } $x = new foo(); $x->public_foo(); //$x->protected_foo();//Invalid cannot call protected methods outside the class and derived classes //$x->private_foo();//Invalid private methods can only be used inside the class $x2 = new foo2(); $x2->display(); ?> 提示：变量总是私有形式，直接访问一个私有变量并不是一个好的OOP思想，应该用其他的方法来实现 set/get 的功能

(1) static
static关键字在类中是，描述一个成员是静态的，static能够限制外部的访问，因为static后的成员是属 于类的，是不属于任何对象实例，其他类是无法访问的，只对类的实例共享，能一定程序对该成员尽心保护。类的静态变量，非常类似全局变量，能够被所有类的实 例共享，类的静态方法也是一样的，类似于全局函数。类的静态方法能访问类的静态的属性。另外说明的是，static的成员，必须使用self来访问，使用 this会出错。
(关于this和self的异同，请参考： http://blog.csdn.net/heiyeshuwu/archive/2004/11/03/165828.aspx )

(2)const
const是一个定义常量的关键字，类似于C中的#define，能够定义一个常量，如果在程序中改变了它的值，那么会出现错误。

例子：

public：方法或者属性在任何作用域都可以访问到，而且这是默认的，如果没有为一个属性或方法指定访问修饰符,它将是public。

protected：方法或者属性只能从类或者继承类的一个成员中访问到。

private：方法或者属性只能从类的一个成员中访问到，而且无法从继承类的成员中访问到。经过private便签标记的方法或者属性可以在继承类中重新定义。每一个类只能看到它自己定义的私有方法。

view plaincopy to clipboardprint?

1. <?php   
2. class MyClass{   
3. public $public = 'Public';   
4. protected $protected = 'Protected';   
5. private $private = 'Private';   
6. function printHello()   
7. {   
8. echo $this->public;   
9. echo $this->protected;   
10. echo $this->private;   
11. }   
12. }   
13. $obj = new MyClass();   
14. echo $obj->public; // Works   
15. echo $obj->protected; // Fatal Error   
16. echo $obj->private; // Fatal Error                //私有和受保护的属性都不能直接引用   
17. $obj->printHello(); // Shows Public, Protected and Private   
18. /**
19. * Define MyClass2
20. */  
21. class MyClass2 extends MyClass{   
22. // We can redeclare the public and protected method, but not private   
23. protected $protected = 'Protected2';   
24. function printHello()   
25. {   
26. echo $this->public;   
27. echo $this->protected;   
28. echo $this->private;   
29. }   
30. }   
31. $obj2 = new MyClass2();   
32. echo $obj->public; // Works   
33. echo $obj2->private; // Undefined                  //私有属性可以重新定义，但MyClass2里面没有定义   
34. echo $obj2->protected; // Fatal Error                 //受保护的属性不能重新定义   
35. $obj2->printHello(); // Shows Public, Protected2, not Private   
36. ?>  
    

每个修饰符的定义：

public:公共成员即可以通过对象外部使用，也可以使用特殊变量$this从内部的方法访问。如果另外一个类继承了这个公共变量，这个规则同样适用，而且从这个类的对象的外部和内部的方法都可以访问。

protected:保护成员只能从对象内部的方法访问。如果另外一个类继承了一个保护的成员，同样的规则也适用，而且它可以从继承类实例化的对象的方法中通过特殊的$this变量访问到。

private:与私有成员和保护成员类似，因为它们都只能从对象内部的方法访问。但是，私 有成员不能从继承类实例化的对象方法访问。因为私有属性在继承的类中是看不到的。而且两个相关的类可以分别声明一个名字相同的私有变量。也就是两个类都只 能看到自己的私有属性，私有成员之间是没有关系的。