Synlighet

Synlighet

Synligheten för en egenskap, en metod eller (från och med PHP 7.1.0) en konstant kan definieras genom att förklara deklarationen med nyckelorden `public`, `protected` eller `private`. Klassmedlemmar som deklareras som `public` kan nås överallt. Medlemmar som deklareras som `protected` kan endast nås inom klassen själv och av arvande och föräldraklasser. Medlemmar som deklareras som `private` kan endast nås av klassen som definierar medlemmen.

Egenskapssynlighet

Klassens egenskaper kan definieras som `public`, `private`, eller `protected`. Egenskaper som deklareras utan någon explicit synlighetsnyckel definieras som `public`.

Exempel #1 Egenskapsdeklaration

<?php
/**
 * Definiera 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; // Fungerar
echo $obj->protected; // Fatal Error
echo $obj->private; // Fatal Error
$obj->printHello(); // Visar Public, Protected och Private


/**
 * Definiera MyClass2
 */
class MyClass2 extends MyClass
{
    // Vi kan omdeklarera de offentliga och skyddade egenskaperna, men inte de privata
    public $public = 'Public2';
    protected $protected = 'Protected2';

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

$obj2 = new MyClass2();
echo $obj2->public; // Fungerar
echo $obj2->protected; // Fatal Error
echo $obj2->private; // Undefined
$obj2->printHello(); // Visar Public2, Protected2, Undefined
?>

Metodsynlighet

Klassens metoder kan definieras som `public`, `private`, eller `protected`. Metoder som deklareras utan någon explicit synlighetsnyckel definieras som `public`.

Exempel #2 Metoddeklaration

<?php
/**
 * Definiera MyClass
 */
class MyClass
{
    // Deklarera en offentlig konstruktor
    public function __construct() { }

    // Deklarera en offentlig metod
    public function MyPublic() { }

    // Deklarera en skyddad metod
    protected function MyProtected() { }

    // Deklarera en privat metod
    private function MyPrivate() { }

    // Detta är offentligt
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // Fungerar
$myclass->MyProtected(); // Fatal Error
$myclass->MyPrivate(); // Fatal Error
$myclass->Foo(); // Public, Protected och Private fungerar


/**
 * Definiera MyClass2
 */
class MyClass2 extends MyClass
{
    // Detta är offentligt
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // Fatal Error
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Fungerar
$myclass2->Foo2(); // Public och Protected fungerar, inte 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
?>

Konstant Synlighet

Från och med PHP 7.1.0 kan klasskonstanter definieras som `public`, `private`, eller `protected`. Konstanter som deklareras utan någon explicit synlighetsnyckel definieras som `public`.

Exempel #3 Konstantdeklaration från och med PHP 7.1.0

<?php
/**
 * Definiera MyClass
 */
class MyClass
{
    // Deklarera en offentlig konstant
    public const MY_PUBLIC = 'public';

    // Deklarera en skyddad konstant
    protected const MY_PROTECTED = 'protected';

    // Deklarera en privat konstant
    private const MY_PRIVATE = 'private';

    public function foo()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE;
    }
}

$myclass = new MyClass();
MyClass::MY_PUBLIC; // Fungerar
MyClass::MY_PROTECTED; // Fatal Error
MyClass::MY_PRIVATE; // Fatal Error
$myclass->foo(); // Public, Protected och Private fungerar


/**
 * Definiera MyClass2
 */
class MyClass2 extends MyClass
{
    // Detta är offentligt
    function foo2()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE; // Fatal Error
    }
}

$myclass2 = new MyClass2;
echo MyClass2::MY_PUBLIC; // Fungerar
$myclass2->foo2(); // Public och Protected fungerar, inte Private
?>

Synlighet från andra objekt

Objekt av samma typ kommer att ha tillgång till varandras privata och skyddade medlemmar, även om de inte är samma instans. Detta beror på att implementeringsspecifika detaljer redan är kända när man befinner sig inom dessa objekt.

Exempel #4 Åtkomst till privata medlemmar av samma objekttyp

<?php
class Test
{
    private $foo;

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

    private function bar()
    {
        echo 'Accessed the private method.';
    }

    public function baz(Test $other)
    {
        // Vi kan ändra den privata egenskapen:
        $other->foo = 'hello';
        var_dump($other->foo);

        // Vi kan också anropa den privata metoden:
        $other->bar();
    }
}

$test = new Test('test');

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

Det ovanstående exemplet kommer att producera:

string(5) "hello"
Accessed the private method.

Sidslut

Orginalhemsidan på Engelska : https://www.php.net/manual/en/language.oop5.visibility.php
PHP
Språkreferens
Språkreferens#Klasser_och_Objekt