PHP Australia Conference 2015

Sichtbarkeit

Die Sichtbarkeit einer Eigenschaft oder Methode kann definiert werden, indem man der Deklaration eines der Schlüsselwörter public, protected oder private. voranstellt. Auf public deklarierte Elemente kann von überall her zugegriffen werden. Protected beschränkt den Zugang auf Elternklassen und abgeleitete Klassen (sowie die Klasse, die das Element definiert). Private grenzt die Sichtbarkeit einzig auf die Klasse ein, die das Element definiert.

Sichtbarkeit von Membern

Klasseneigenschaften müssen als public, private oder protected definiert werden. Wenn sie mit var deklariert werden, werden sie als public definiert.

Beispiel #1 Eigenschaftendeklaration

<?php
/**
 * Definiere MyClass
 */
class MyClass
{
    public 
$public 'Public';
    protected 
$protected 'Protected';
    private 
$private 'Private';

    function 
printHello()
    {
        echo 
$this->public;
        echo 
$this->protected;
        echo 
$this->private;
    }
}

$obj = new MyClass();
echo 
$obj->public// Funktioniert
echo $obj->protected// Fataler Fehler
echo $obj->private// Fataler Fehler
$obj->printHello(); // Zeigt Public, Protected und Private


/**
 * Definiere MyClass2
 */
class MyClass2 extends MyClass
{
    
// Wir können die public- und protected-Methoden neu deklarieren, 
    // aber nicht die private-Methode
    
protected $protected 'Protected2';

    function 
printHello()
    {
        echo 
$this->public;
        echo 
$this->protected;
        echo 
$this->private;
    }
}

$obj2 = new MyClass2();
echo 
$obj2->public// Funktioniert
echo $obj2->private// Undefiniert
echo $obj2->protected// Fataler Fehler
$obj2->printHello(); // Zeigt Public, Protected2, Undefined

?>

Hinweis: Die PHP-4-Methode, Variablen mit dem Schlüsselwort var zu deklarieren, wird aus Gründen der Abswärtskompatibilität weiterhin unterstützt (als Synonym für das public-Schlüsselwort). In PHP 5 vor 5.1.3 hat dessen Verwendung eine E_STRICT-Warnung erzeugt.

Sichtbarkeit von Methoden

Klassenmethoden müssen mit public, private oder protected definiert werden. Methoden ohne jede explizite Deklaration sind als public definiert.

Beispiel #2 Methodendeklaration

<?php
/**
 * Definiere MyClass
 */
class MyClass
{
    
// Deklariert einen public Konstruktor
    
public function __construct() { }

    
// Deklariere eine public Funktion
    
public function MyPublic() { }

    
// Deklariere eine protected Funktion
    
protected function MyProtected() { }

    
// Deklariere eine private Funktion
    
private function MyPrivate() { }

    
// Dies ist public
    
function Foo()
    {
        
$this->MyPublic();
        
$this->MyProtected();
        
$this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // Funktioniert
$myclass->MyProtected(); // Fataler Fehler
$myclass->MyPrivate(); // Fataler Fehler
$myclass->Foo(); // Public, Protected und Private funktionieren


/**
 * Definiere MyClass2
 */
class MyClass2 extends MyClass
{
    
// Dies ist public
    
function Foo2()
    {
        
$this->MyPublic();
        
$this->MyProtected();
        
$this->MyPrivate(); // Fataler Fehler
    
}
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Funktioniert
$myclass2->Foo2(); // Public und Protected funktionieren, Private nicht

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
?>

Sichtbarkeit von anderen Objekten

Objekte des gleichen Types haben untereinander Zugriff auf die als private und protected markierten Member, obwohl es sich nicht um die gleichen Instanzen handelt. Dies liegt daran, dass die Details über die Implementierung innerhalb solcher Objekte bekannt sind.

Beispiel #3 Zugriff auf als private markierte Member des gleichen Objekttyps

<?php
class Test
{
    private 
$foo;

    public function 
__construct($foo)
    {
        
$this->foo $foo;
    }

    private function 
bar()
    {
        echo 
'Zugriff auf die private Methode';
    }

    public function 
baz(Test $other)
    {
        
// Ändern der privaten Eigenschaft ist möglich:
        
$other->foo 'Hallo';
        
var_dump($other->foo);

        
// Aufruf der privaten Methode ist ebenfalls möglich:
        
$other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

string(5) "Hallo"
Zugriff auf die private Methode
+
add a note add a note

User Contributed Notes 18 notes

up
67
wbcarts at juno dot com
2 years ago
INSIDE CODE and OUTSIDE CODE

<?php

class Item
{
 
/**
   * This is INSIDE CODE because it is written INSIDE the class.
   */
 
public $label;
  public
$price;
}

/**
* This is OUTSIDE CODE because it is written OUTSIDE the class.
*/
$item = new Item();
$item->label = 'Ink-Jet Tatoo Gun';
$item->price = 49.99;

?>

Ok, that's simple enough... I got it inside and out. The big problem with this is that the Item class is COMPLETELY IGNORANT in the following ways:
* It REQUIRES OUTSIDE CODE to do all the work AND to know what and how to do it -- huge mistake.
* OUTSIDE CODE can cast Item properties to any other PHP types (booleans, integers, floats, strings, arrays, and objects etc.) -- another huge mistake.

Note: we did it correctly above, but what if someone made an array for $price? FYI: PHP has no clue what we mean by an Item, especially by the terms of our class definition above. To PHP, our Item is something with two properties (mutable in every way) and that's it. As far as PHP is concerned, we can pack the entire set of Britannica Encyclopedias into the price slot. When that happens, we no longer have what we expect an Item to be.

INSIDE CODE should keep the integrity of the object. For example, our class definition should keep $label a string and $price a float -- which means only strings can come IN and OUT of the class for label, and only floats can come IN and OUT of the class for price.

<?php

class Item
{
 
/**
   * Here's the new INSIDE CODE and the Rules to follow:
   *
   * 1. STOP ACCESS to properties via $item->label and $item->price,
   *    by using the protected keyword.
   * 2. FORCE the use of public functions.
   * 3. ONLY strings are allowed IN & OUT of this class for $label
   *    via the getLabel and setLabel functions.
   * 4. ONLY floats are allowed IN & OUT of this class for $price
   *    via the getPrice and setPrice functions.
   */

 
protected $label = 'Unknown Item'; // Rule 1 - protected.
 
protected $price = 0.0;            // Rule 1 - protected.

 
public function getLabel() {       // Rule 2 - public function.
   
return $this->label;             // Rule 3 - string OUT for $label.
 
}

  public function
getPrice() {       // Rule 2 - public function.   
   
return $this->price;             // Rule 4 - float OUT for $price.
 
}

  public function
setLabel($label)   // Rule 2 - public function.
 
{
   
/**
     * Make sure $label is a PHP string that can be used in a SORTING
     * alogorithm, NOT a boolean, number, array, or object that can't
     * properly sort -- AND to make sure that the getLabel() function
     * ALWAYS returns a genuine PHP string.
     *
     * Using a RegExp would improve this function, however, the main
     * point is the one made above.
     */

   
if(is_string($label))
    {
     
$this->label = (string)$label; // Rule 3 - string IN for $label.
   
}
  }

  public function
setPrice($price)   // Rule 2 - public function.
 
{
   
/**
     * Make sure $price is a PHP float so that it can be used in a
     * NUMERICAL CALCULATION. Do not accept boolean, string, array or
     * some other object that can't be included in a simple calculation.
     * This will ensure that the getPrice() function ALWAYS returns an
     * authentic, genuine, full-flavored PHP number and nothing but.
     *
     * Checking for positive values may improve this function,
     * however, the main point is the one made above.
     */

   
if(is_numeric($price))
    {
     
$this->price = (float)$price; // Rule 4 - float IN for $price.
   
}
  }
}

?>

Now there is nothing OUTSIDE CODE can do to obscure the INSIDES of an Item. In other words, every instance of Item will always look and behave like any other Item complete with a label and a price, AND you can group them together and they will interact without disruption. Even though there is room for improvement, the basics are there, and PHP will not hassle you... which means you can keep your hair!
up
21
what at ever dot com
5 years ago
If you have problems with overriding private methods in extended classes, read this:)

The manual says that "Private limits visibility only to the class that defines the item". That means extended children classes do not see the private methods of parent class and vice versa also.

As a result, parents and children can have different implementations of the "same" private methods, depending on where you call them (e.g. parent or child class instance). Why? Because private methods are visible only for the class that defines them and the child class does not see the parent's private methods. If the child doesn't see the parent's private methods, the child can't override them. Scopes are different. In other words -- each class has a private set of private variables that no-one else has access to.

A sample demonstrating the percularities of private methods when extending classes:

<?php
abstract class base {
    public function
inherited() {
       
$this->overridden();
    }
    private function
overridden() {
        echo
'base';
    }
}

class
child extends base {
    private function
overridden() {
        echo
'child';
    }
}

$test = new child();
$test->inherited();
?>

Output will be "base".

If you want the inherited methods to use overridden functionality in extended classes but public sounds too loose, use protected. That's what it is for:)

A sample that works as intended:

<?php
abstract class base {
    public function
inherited() {
       
$this->overridden();
    }
    protected function
overridden() {
        echo
'base';
    }
}

class
child extends base {
    protected function
overridden() {
        echo
'child';
    }
}

$test = new child();
$test->inherited();
?>
Output will be "child".
up
2
php at stage-slash-solutions dot com
3 years ago
access a protected property:

<?php

//Some library I am not allowed to change:

abstract class a
{
  protected
$foo;
}

class
aa extends a
{
  function
setFoo($afoo)
  {
     
$this->foo = $afoo;
  }
}

?>

if you get an instance of aa and need access to $foo:

<?php
class b extends a
{
  function
getFoo($ainstance)
  {
      return
$ainstance->foo;
  }
}

$aainstance=someexternalfunction();
$binstance=new b;
$aafoo=$binstance->getFoo($aainstance);
?>
up
5
stephane at harobed dot org
8 years ago
A class A static public function can access to class A private function :

<?php
class A {
    private function
foo()
    {
        print(
"bar");
    }

    static public function
bar($a)
    {
       
$a->foo();
    }
}

$a = new A();

A::bar($a);
?>

It's working.
up
6
omega at 2093 dot es
2 years ago
This has already been noted here, but there was no clear example. Methods defined in a parent class can NOT access private methods defined in a class which inherits from them. They can access protected, though.

Example:

<?php

class ParentClass {

    public function
execute($method) {
       
$this->$method();
    }
   
}

class
ChildClass extends ParentClass {

    private function
privateMethod() {
        echo
"hi, i'm private";
    }
   
    protected function
protectedMethod() {
        echo
"hi, i'm protected";
    }
   
}

$object = new ChildClass();

$object->execute('protectedMethod');

$object->execute('privateMethod');

?>

Output:

hi, i'm protected
Fatal error: Call to private method ChildClass::privateMethod() from context 'ParentClass' in index.php on line 6

In an early approach this may seem unwanted behaviour but it actually makes sense. Private can only be accessed by the class which defines, neither parent nor children classes.
up
1
briank at kappacs dot com
2 years ago
To make (some) object members read-only outside of the class (revisited using PHP 5 magic __get):

<?php

class ReadOnlyMembers {

    private
$reallyPrivate;
    private
$justReadOnly;

    function
__construct () {
       
$this->reallyPrivate = 'secret';
       
$this->justReadOnly = 'read only';
    }

    function
__get ($what) {
        switch (
$what) {
        case
'justReadOnly':
            return
$this->$what;

        default:
           
# Generate an error, throw an exception, or ...
           
return null;
        }
    }

    function
__isset ($what) {
       
$val = $this->__get($what);
        return isset(
$val);
    }

}

$rom = new ReadOnlyMembers();

var_dump($rom->justReadOnly);           // string(9) "read only"

$rom->justReadOnly = 'new value';       // Fatal error

var_dump($rom->reallyPrivate);          // Fatal error

?>
up
2
imran at phptrack dot com
5 years ago
Some Method Overriding rules :

1. In the overriding, the method names and arguments (arg’s) must be same.

Example:
class p { public function getName(){} }
class c extends P{ public function getName(){} }

2. final methods can’t be overridden.

3. private methods never participate in the in the overriding because these methods are not visible in the child classes.

Example:
class a {
private  function my(){   
    print "parent:my";
}
public function getmy(){
$this->my();
}
}
class b extends a{
    private  function my(){
        print "base:my";       
}
}
$x = new b();
$x->getmy(); // parent:my

4. While overriding decreasing access specifier is not allowed

class a {
public  function my(){   
    print "parent:my";
}

}
class b extends a{
    private  function my(){
        print "base:my";       
}
}
//Fatal error:  Access level to b::my() must be public (as in class a)
up
2
andrei at leapingbytes dot net
1 year ago
Interestingly enough, PHP does very reasonable job in regards to interaction between classes and plain functions (even ones defined in the same file as the class)

<?php

class Test {
    private function
foo() {
        echo
"Foo" . PHP_EOL;
    }
    protected function
bar() {
        echo
"bar" . PHP_EOL;
    }

    static function
foobar($test) {
       
$test->bar(); // works
       
$test->foo(); // works
   
}   
}

function
simple_function() {
   
$test = new Test();

   
$test->bar(); // does not work

   
$test->foo(); // does not work
   
   
Test::foobar($test); // works
}

simple_function();
?>
up
2
Marce!
5 years ago
Please note that protected methods are also available from sibling classes as long as the method is declared in the common parent. This may also be an abstract method.

In the below example Bar knows about the existence of _test() in Foo because they inherited this method from the same parent. It does not matter that it was abstract in the parent.

<?php
abstract class Base {
    abstract protected function
_test();
}

class
Bar extends Base {
   
    protected function
_test() { }
   
    public function
TestFoo() {
       
$c = new Foo();
       
$c->_test();
    }
}

class
Foo extends Base {
    protected function
_test() {
        echo
'Foo';
    }
}

$bar = new Bar();
$bar->TestFoo(); // result: Foo
?>
up
1
jc dot flash at gmail dot com
2 years ago
if not overwritten, self::$foo in a subclass actually refers to parent's self::$foo
<?php
class one
{
    protected static
$foo = "bar";
    public function
change_foo($value)
    {
       
self::$foo = $value;
    }
}

class
two extends one
{
    public function
tell_me()
    {
        echo
self::$foo;
    }
}
$first = new one;
$second = new two;

$second->tell_me(); // bar
$first->change_foo("restaurant");
$second->tell_me(); // restaurant
?>
up
2
IgelHaut
2 years ago
<?php
class test {
    public
$public = 'Public var';
    protected
$protected = 'protected var';
    private
$private = 'Private var';
   
    public static
$static_public = 'Public static var';
    protected static
$static_protected = 'protected static var';
    private static
$static_private = 'Private static var';
}

$class = new test;
print_r($class);
?>

The code prints
test Object ( [public] => Public var [protected:protected] => protected var [private:test:private] => Private var )

Functions like print_r(), var_dump() and var_export() prints public, protected and private variables, but not the static variables.
up
1
alexaulbach at mayflower dot de
1 year ago
<?php

error_reporting
(E_ALL | E_STRICT E_ERROR | E_WARNING | E_PARSE | E_COMPILE_ERROR);

class
A
{
        private
$private = 1;
        public
$public = 1;

        function
get()
        {
                return
"A: $this->private , $this->public\n";
        }

}

class
B extends A
{

        function
__construct()
        {
               
$this->private = 2;
               
$this->public = 2;
        }

        function
set()
        {
               
$this->private = 3;
               
$this->public = 3;
        }

        function
get()
        {
                return
parent::get() . "B: $this->private , $this->public\n";
        }

}

$B = new B;

echo
$B->get();
echo
$B->set();
echo
$B->get();
?>

?>

Result is
A: 1 , 2
B: 2 , 2
A: 1 , 3
B: 3 , 3

This is correct code and does not warn you to use any private.

"$this->private" is only in A private. If you write it in class B it's a runtime declaration of the public variable "$this->private", and PHP doesn't even warn you that you create a variable in a class without declaration, because this is normal behavior.
up
2
r dot wilczek at web-appz dot de
8 years ago
Beware: Visibility works on a per-class-base and does not prevent instances of the same class accessing each others properties!

<?php
class Foo
{
    private
$bar;

    public function
debugBar(Foo $object)
    {
       
// this does NOT violate visibility although $bar is private
       
echo $object->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
?>
up
1
hasan4it at gmail dot com
6 months ago
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();

print_r($obj)

it gives me the value of all variables
How can I hide this?
up
0
thcdesigning at gmail dot com
10 months ago
Private or not private?
I get baffled whenever I see this kind of an example.

<?php

class vessel{
    private
$things = array();
    
    public function
setThing($things){
           
$this->things = $things;
    }

    public function
getThing($obj){
        return
$obj->things;
    }
}

class
smallVessel{
    private
$things = array();
    
    public function
setThing($things){
           
$this->things = $things;
    }

    public function
getThing($obj){
        return
$obj->things;
    }
}

$basket = new vessel();
$bucket = new vessel();
$bowl = new smallVessel();

$basket->setThing(array('wine' , 'water' , 'sugar'));

// returns the contents inside basket unexpectedly
print_r($bucket->getThing($basket));

// returns error, quite rightly so!
print_r($bowl ->getThing($basket));
up
-1
aluciffer at hotmail dot com
1 year ago
As far as it regards the properties of objects, visibility is, yes, as the examples show.
Private, protected methods are not accessible via syntax $a->protectedVar, however their values are still (php 5.3.26) accessible through a number of other methods (serializing, converting to array, and nevertheless using the ReflectionClass methods).
As it was pointed out and such as in the example below:
<?php

echo "PHP Version: ".phpversion()."\n";

class
Foo
{
   private  
$bar  = "value of private var";
   protected
$bar2 = "value of protected var";
   public   
$bar3 = "value of public var";
}

$obj = new Foo;

echo
serialize($obj) . "\n";

print_r($obj);

print_r((array)$obj);

echo (
$obj->bar3) . "\n";
echo (
$obj->bar2) . "\n";
echo (
$obj->bar) . "\n";

?>

It will output:

PHP Version: 5.3.26
O:3:"Foo":3:{s:8:"Foobar";s:20:"value of private var ";s:7:"*bar2";s:22:"value of protected var";s:4:"bar3";s:19:"value of public var";}
Foo Object
(
    [bar:Foo:private] => value of private var
    [bar2:protected] => value of protected var
    [bar3] => value of public var
)

Array
(
    [Foobar] => value of private var
    [*bar2] => value of protected var
    [bar3] => value of public var
)
value of public var

While the last two lines, accessing directly the private and protected object properties (bar2 and bar), will throw out fatal errors like:
PHP Fatal error:  Cannot access private property Foo::$bar
and
PHP Fatal error:  Cannot access protected property Foo::$bar2
up
0
a dot schaffhirt at sedna-soft dot de
5 years ago
If you miss the "package" keyword in PHP in order to allow access between certain classes without their members being public, you can utilize the fact, that in PHP the protected keyword allows access to both subclasses and superclasses.

So you can use this simple pattern:

<?php
   
abstract class Dispatcher {
        protected function &
accessProperty (self $pObj, $pName) {
            return
$pObj->$pName;
        }
        protected function
invokeMethod ($pObj, $pName, $pArgs) {
            return
call_user_func_array(array($pObj, $pName), $pArgs);
        }
    }
?>

The classes that should be privileged to each other simply extend this dispatcher:

<?php
   
class Person extends Dispatcher {
        private
$name;
        protected
$phoneNumbers;
       
        public function
__construct ($pName) {
           
$this->name = $pName;
           
$this->phoneNumbers = array();
        }
        public function
addNumber (PhoneNumber $pNumber, $pLabel) {
           
$this->phoneNumbers[$pLabel] = $pNumber;

           
// this does not work, because "owner" is protected:
            // $pNumber->owner = $this;

            // instead, we get a reference from the dispatcher:
           
$p =& $this->accessProperty($pNumber, "owner");

           
// ... and change that:
           
$p = $this;                                   
        }
        public function
call ($pLabel) {
           
// this does not work since "call" is protected:
            // $this->phoneNumbers[$pLabel]->call();
           
            // instead, we dispatch the call request:
           
$this->invokeMethod($this->phoneNumbers[$pLabel], "call", array());
        }
    }
   
    class
PhoneNumber extends Dispatcher {
        private
$countryCode;
        private
$areaCode;
        private
$number;
        protected
$owner;
       
        public function
__construct ($pCountryCode, $pAreaCode, $pNumber) {
           
$this->countryCode = $pCountryCode;
           
$this->areaCode = $pAreaCode;
           
$this->number = $pNumber;
        }

        protected function
call () {
            echo(
"calling " . $this->countryCode . "-" . $this->areaCode . "-" . $this->number . "\n");
        }
    }

   
$person = new Person("John Doe");
   
$number1 = new PhoneNumber(12, 345, 67890);
   
$number2 = new PhoneNumber(34, 5678, 90123);
   
$person->addNumber($number1, "home");
   
$person->addNumber($number2, "office");
   
$person->call("home");
?>

Without this pattern you would have to make $owner and call() public in PhoneNumber.

Best regards,
up
1
Joshua Watt
7 years ago
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.

<?php
class A
{
    protected
$prot;
    private
$priv;
   
    public function
__construct($a, $b)
    {
       
$this->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
?>
To Top