php中访问控制
By admin
- 9 minutes read - 1757 words访问控制 对属性或方法的访问控制，是通过在前面添加关键字 public、protected 或 private 来实现的。由 public 所定义的类成员可以在任何地方被访问；由 protected 所定义的类成员则可以被其所在类的子类和父类访问（当然，该成员所在的类也可以访问）；而由 private 定义的类成员则只能被其所在类访问。
对类成员的访问控制 类成员都必须使用关键字public、protected 或 private 进行定义
Example#1 声明类成员
public;
echo $this->protected; echo $this->private; } }
$obj = new MyClass(); echo $obj->public; // 这行能被正常执行 echo $obj->protected; // 这行会产生一个致命错误 echo $obj->private; // 这行也会产生一个致命错误 $obj->printHello(); // 输出 Public、Protected 和 Private
/**
- Define MyClass2 */ class MyClass2 extends MyClass { // 可以对 public 和 protected 进行重定义，但 private 而不能 protected $protected = ‘Protected2’;
function printHello() { echo $this->public; echo $this->protected; echo $this->private; } }
$obj2 = new MyClass2(); echo $obj->public; // 这行能被正常执行 echo $obj2->private; // 未定义 private echo $obj2->protected; // 这行会产生一个致命错误 $obj2->printHello(); // 输出 Public、Protected2，但不会输出 Private
class Bar { public function test() { $this->testPrivate(); $this->testPublic(); }
public function testPublic() { echo “Bar::testPublic\n”; }
private function testPrivate() { echo “Bar::testPrivate\n”; } }
class Foo extends Bar { public function testPublic() { echo “Foo::testPublic\n”; }
private function testPrivate() { echo “Foo::testPrivate\n”; } }
$myFoo = new foo(); $myFoo->test(); // Bar::testPrivate // Foo::testPublic ?>
Note: 为了兼容性考虑，在 PHP 4 中使用 var 关键字对变量进行定义的方法在 PHP 5 中仍然有效（只是作为 public 关键字的一个别名）。在 PHP 5.1.3 之前的版本，该语法会产生一个 E_STRICT 警告。
对方法的访问控制 类中的方法都必须使用关键字public、protected 或 private 进行定义。如果没有设置这些关键字，则该方法会被设置成默认的 public。
Example#2 声明类中的方法
MyPublic();
$this->MyProtected(); $this->MyPrivate(); } }
$myclass = new MyClass; $myclass->MyPublic(); // 这行能被正常执行 $myclass->MyProtected(); // 这行会产生一个致命错误 $myclass->MyPrivate(); // 这行会产生一个致命错误 $myclass->Foo(); // Public、Protected 和 Private 都被调用了
/**
- Define MyClass2 */ class MyClass2 extends MyClass { // This is public function Foo2() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); // 这行会产生一个致命错误 } }
$myclass2 = new MyClass2; $myclass2->MyPublic(); // 这行能被正常执行 $myclass2->Foo2(); // Public 和 Protected 都被调用了，但 Private 不会被调用 ?>
范围解析操作符（::） 构造函数和析构函数 ——————————————————————————– Last updated: Sun, 25 Nov 2007
add a note User Contributed Notes 访问控制 Jeffrey 09-Oct-2008 05:48 WHEN do I use public, protected or private keyword? Here’s the default behavior. var1; // get public data
$obj1->var1 = 35; // set public data $obj1->someFunction_1(); // call public function ?>
Now try extending the class…
var1; // get public data
$obj2->var1 = 45; // set public data $obj2->someFunction_1(); // call public function ?> odessa-gun at ya dot ru 06-Oct-2008 04:33 PHP 5.2.3, windows
The comment in this example is invalid
public;
echo $this->protected; echo $this->private; } } ?>
Just try this:
public;
echo $this->protected; echo $this->private; } }
?> wbcarts at juno dot com 10-Sep-2008 02:21 UNDERSTANDING PHP’s OBJECT VISIBILITY
Sometimes it’s good to see a list of many extended classes, one right after the other – just for the sole purpose of looking at their inherited members. Maybe this will help:
class MyClass_1{ public $pubVal = ‘Hello World!’; protected $proVal = ‘Hello FROM MyClass_1’; private $priVal = ‘Hello TO MyClass_1’;
public function __toString(){ return “MyClass_1[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
class MyClass_2 extends MyClass_1{ public function __toString(){ return “MyClass_2[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
class MyClass_3 extends MyClass_2{ private $priVal = ‘Hello TO MyClass_3’;
public function __toString(){ return “MyClass_3[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
class MyClass_4 extends MyClass_3{ protected $proVal = ‘Hello FROM MyClass_4’;
public function __toString(){ return “MyClass_4[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
class MyClass_5 extends MyClass_4{ public function __toString(){ return “MyClass_5[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
class MyClass_6 extends MyClass_5{ private $priVal = ‘Hello TO MyClass_6’;
public function __toString(){ return “MyClass_6[public=$this->pubVal, protected=$this->proVal, private=$this->priVal]”; } }
echo (new MyClass_1()) . ‘ ‘; echo (new MyClass_2()) . ‘ ‘; echo (new MyClass_3()) . ‘ ‘; echo (new MyClass_4()) . ‘ ‘; echo (new MyClass_5()) . ‘ ‘; echo (new MyClass_6()) . ‘ ‘;
The list of extended objects:
MyClass_1[public=Hello World!, protected=Hello FROM MyClass_1, private=Hello TO MyClass_1] MyClass_2[public=Hello World!, protected=Hello FROM MyClass_1, private=] MyClass_3[public=Hello World!, protected=Hello FROM MyClass_1, private=Hello TO MyClass_3] MyClass_4[public=Hello World!, protected=Hello FROM MyClass_4, private=] MyClass_5[public=Hello World!, protected=Hello FROM MyClass_4, private=] MyClass_6[public=Hello World!, protected=Hello FROM MyClass_4, private=Hello TO MyClass_6]
Notice in the class definitions, I made absolutly no attempt to change protected members to private, etc. – that gets too confusing and is not necessary – though I did redeclare a few members with the same var name and visibility strength. One other noteworthy: the output for MyClass_2, there seems to be a private property with value of empty string. Here, $priVal was not inherited from MyClass_1 because it is private in MyClass_1, instead, because of PHP’s relaxed syntax, it was actually created right there in MyClass2::__toString() method… not only that, it is not a private member either. Watch out for this kind of thing, as PHP can sometimes give confusing impressions. omnibus at omnibus dot edu dot pl 13-Dec-2007 06:34 Please note that if a class has a protected variable, a subclass cannot have the same variable redefined private (must be protected or weaker). It seemed to be logical for me as a subsubclass would not know if it could see it or not but even if you declare a subclass to be final the restriction remains. phpdoc at povaddict dot com dot ar 11-Oct-2007 12:52 Re: ference at super_delete_brose dot co dot uk
“If eval() is the answer, you’re almost certainly asking the wrong question.”
‘.$var.’;’); //wrong
$result = $this->$var; //right way
$var = “foo”; $this->var = “this will assign to member called ‘var’.”; $this->$var = “this will assign to member called ‘foo’.”; ?> Joshua Watt 29-May-2007 12:09 I couldn’t find this documented anywhere, but you can access protected and private member varaibles in different instance of the same class, just as you would expect
i.e.
prot = $a;
$this->priv = $b; }
public function print_other(A $other) { echo $other->prot; echo $other->priv; } }
class B extends A { }
$a = new A(“a_protected”, “a_private”); $other_a = new A(“other_a_protected”, “other_a_private”);
$b = new B(“b_protected”, “ba_private”);
$other_a->print_other($a); //echoes a_protected and a_private $other_a->print_other($b); //echoes b_protected and ba_private
$b->print_other($a); //echoes a_protected and a_private ?> ference at super_delete_brose dot co dot uk 22-May-2007 10:10 Sometimes you may wish to have all members of a class visible to other classes, but not editable – effectively read-only.
In this case defining them as public or protected is no good, but defining them as private is too strict and by convention requires you to write accessor functions.
Here is the lazy way, using one get function for accessing any of the variables:
a = ‘Value of $a’;
$this->b = ‘Value of $b’; $this->c = ‘Value of $c’; $this->d = ‘Value of $d’; $this->e = ‘Value of $e’; $this->f = ‘Value of $f’; }
/* Accessor for all class variables. */ public function get($what) { $result = FALSE; $vars = array_keys(get_class_vars(‘Foo’));
foreach ($vars as $var) { if ($what == $var) { eval(‘$result = $this->’.$var.’;’); return $result; } } return $result; } }
class Bar { private $a;
public function __construct() { $foo = new Foo();
var_dump($foo->get(‘a’)); // results in: string(11) “Value of $a” } }
$bar = new Bar();
?> nanocaiordo at gmail dot com 08-Apr-2007 06:49 If you always thought how can you use a private method in php4 classes then try the following within your class.
file = __FILE__;
if (PHPVERS >= 43) { $tmp = debug_backtrace(); for ($i=0; $ifile != $tmp[$i][‘file’]) { trigger_error(‘Call to a private method ‘.\__CLASS__.’::’.$func.’ in ‘.$tmp[$i][‘file’], E_USER_ERROR); } } } } } ?>
Then inside the private function add: private_func(\__FUNCTION__);
# your staff goes here } ?> Alex 14-Mar-2007 10:33 Uh… to atitthaker at gmail dot com — It is *meant* to be available under C as well, since A is a superclass of C, and any proctected methods in a superclass is always available to a subclass, no matter how many “generations” you have to traverse, it is available to C. atitthaker at gmail dot com 01-Mar-2007 01:34 access() ;
}
} class C extends B { function temp() { $this->access(); // access variable and prints “here” } }
$abc= new C(); $abc->temp(); ?>
Above code shall generate error as protected method of class A is accessible in class C which is directly not inheriting class A. stephane at harobed dot org 23-Aug-2006 02:22 A class A static public function can access to class A private function :
foo();
} }
$a = new A();
A::bar($a); ?>
It’s working. kakugo at kakugo dot com 13-Jul-2006 03:19 This refers to previous notes on protected members being manipulated externally:
It is obvious that if you were to allow methods the option of replacing protected variables with external ones it will be possible, but there is no reason not to simply use a protected method to define these, or not to write the code to allow it. Just because it is possible doesn’t mean it’s a problem, it simply does not allow you to be lax on the security of the class. LoN_Kamikaze at gmx dot de 28-Mar-2006 01:26 About the previous note:
Of course you cannot declare public attributes/methods private, because it can break code relying on access to such an attribute/method. But of course your children can override private with protected/public. c3 at epetersen dot org 06-Feb-2006 05:50 Note that you cannot change visibility in a child defined in the parent:
class A { public function f() {} }
class B extends A { private function f() {} }
Produces Fatal error: Access level to B::f() must be public (as in class A) in …
jfk, visibility != security. Visibility prevents programmers from doing dumb things like:
class A { private function __construct() {} final public static &factory() { return new A(); } } $x = new A();
The use of “protected” as an identifier is unfortunate tradition as it really means “only me and my decedents” (and in the odd case of PHP my ancestors too). r dot wilczek at web-appz dot de 05-Jan-2006 05:11 Beware: Visibility works on a per-class-base and does not prevent instances of the same class accessing each others properties!
bar, “\n”;
}
public function setBar($value) { // Neccessary method, for $bar is invisible outside the class $this->bar = $value; }
public function setForeignBar(Foo $object, $value) { // this does NOT violate visibility! $object->bar = $value; } }
$a = new Foo(); $b = new Foo(); $a->setBar(1); $b->setBar(2); $a->debugBar($b); // 2 $b->debugBar($a); // 1 $a->setForeignBar($b, 3); $b->setForeignBar($a, 4); $a->debugBar($b); // 3 $b->debugBar($a); // 4 ?> gugglegum at gmail dot com 02-Sep-2005 03:14 Private visibility actually force members to be not inherited instead of limit its visibility. There is a small nuance that allows you to redeclare private member in child classes.
prop; // “I am property of B!”
?> Miguel 21-Jul-2005 08:10 A note about private members, the doc says “Private limits visibility only to the class that defines the item” this says that the following code works as espected:
_myPrivate.”\n”;
} }
class B extends A { public function show() { $this->showPrivate(); } }
$obj=new B(); $obj->show(); // shows “private\n”; ?>
this works cause A::showPrivate() is defined in the same class as $_myPrivate and has access to it.