PHP 8.3.4 Released!

Görünürlük

Bir özelliğin ya da bir yöntemin (PHP 7.1.0 ve sonrası) görünürlüğü, bildirim sırasında önüne şu anahtar sözcüklerden biri getirilerek belirlenebilir: public, protected ya da private. public olarak bildirilmiş özelliklere ve yöntemlere her yerden erişilebilir. protected bildirimli özelliklere ve yöntemlere sadece tanımlandığı sınıfdan, ebeveyn sınıflardan ve miras alınarak private bildirimli özelliklere ve yöntemlere ise sadece özelliğin tanımlandığı sınıfın içinden erişilebilir.

Özelliklerin Görünürlüğü

Sınıf özellikleri public, protected ya da private olarak tanımlanabilir. Görünürlük belirtilmeden bildirilen özelliklerin görünürlüğünün public olduğu varsayılır.

Örnek 1 - Özellik bildirimi

<?php
/**
* Sınıfım tanımı
*/
class Sınıfım
{
public
$genel = 'Genel';
protected
$korumalı = 'Korumalı';
private
$özel = 'Özel';

function
selamVer()
{
echo
$this->genel;
echo
$this->korumalı;
echo
$this->özel;
}
}

$nesne = new Sınıfım();
echo
$nesne->genel; // Çalışır
echo $nesne->korumalı; // Ölümcül Hata
echo $nesne->özel; // Ölümcül Hata
$nesne->selamVer(); // Genel, Korumalı ve Özel görüntüler


/**
* ÖbürSınıfım tanımı
*/
class ÖbürSınıfım extends Sınıfım
{
// public ve protected özellikleri yeniden tanımlayabiliriz,
// ancak private olanlar tanımlanamaz
public $genel = 'Genel2';
protected
$korumalı = 'Öbür korumalı';

function
selamVer()
{
echo
$this->genel;
echo
$this->korumalı;
echo
$this->özel;
}
}

$nesne2 = new ÖbürSınıfım();
echo
$nesne2->genel; // Çalışır
echo $nesne2->korumalı; // Ölümcül Hata
echo $nesne2->özel; // Tanımsız

$nesne2->selamVer(); // Genel2, Öbür korumalı ve Undefined görüntülenir

?>

Yöntem Görünürlüğü

Sınıf yöntemleri public, protected ya da private olarak tanımlanmalıdır. Bunlardan herhangi biri kullanılmadan yapılmış yöntem tanımlarının public kullanılarak yapıldığı varsayılır.

Örnek 2 - Yöntem bildirimi

<?php
/**
* Sınıfım tanımı
*/
class Sınıfım
{
// public kurucu bildirimi
public function __construct() { }

// public yöntem bildirimi
public function Genel() { }

// protected yöntem bildirimi
protected function Korumalı() { }

// private yöntem bildirimi
private function Özel() { }

// Bu da public bir yöntem
function Falanca()
{
$this->Genel();
$this->Korumalı();
$this->Özel();
}
}

$sınıfım = new Sınıfım;
$sınıfım->Genel(); // Çalışır
$sınıfım->Korumalı(); // Ölümcül Hata
$sınıfım->Özel(); // Ölümcül Hata
$sınıfım->Falanca(); // Public, Protected ve Private çalışır


/**
* ÖbürSınıfım tanımı
*/
class ÖbürSınıfım extends Sınıfım
{
// Bu public bir yöntemdir
function Filanca()
{
$this->Genel();
$this->Korumalı();
$this->Özel(); // Ölümcül Hata
}
}

$öbürSınıfım = new Sınıfım;
$öbürSınıfım->Genel(); // Çalışır
$öbürSınıfım->Filanca(); // Genel ve Korumalı çalışır, Özel çalışmaz

class Bar
{
public function
dnm() {
$this->dnmÖzel();
$this->dnmGenel();
}

public function
dnmGenel() {
echo
"Bar::dnmGenel\n";
}

private function
dnmÖzel() {
echo
"Bar::dnmÖzel\n";
}
}

class
Foo extends Bar
{
public function
dnmGenel() {
echo
"Foo::dnmGenel\n";
}

private function
dnmÖzel() {
echo
"Foo::dnmÖzel\n";
}
}

$fo = new Foo();
$fo->dnm(); // Bar::dnmÖzel
// Foo::dnmGenel

?>

Sabit Görünürlüğü

PHP 7.1.0 ve sonrasında, sınıf sabitleri public, private veya protected olarak tanımlanabilir. Bu sözcükler olmaksızın tanımlanmış sabitlerin public olarak tanımlandıkları varsayılır.

Örnek 3 - PHP 7.1.0 ve sonrasında sabit bildirimleri

<?php
/**
* Tanımla: MyClass
*/
class MyClass
{
// public sabit bildirimi
public const MY_PUBLIC = 'genel';

// protected sabit bildirimi
protected const MY_PROTECTED = 'korumalı';

// private sabit bildirimi
private const MY_PRIVATE = 'özel';

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

$myclass = new MyClass();
MyClass::MY_PUBLIC; // Çalışır
MyClass::MY_PROTECTED; // Ölümcül hata
MyClass::MY_PRIVATE; // Ölümcül hata
$myclass->foo(); // genel, korumalı ve özel çalışır


/**
* Tanımla: MyClass2
*/
class MyClass2 extends MyClass
{
// public
function foo2()
{
echo
self::MY_PUBLIC;
echo
self::MY_PROTECTED;
echo
self::MY_PRIVATE; // Ölümcül hata
}
}

$myclass2 = new MyClass2;
echo
MyClass2::MY_PUBLIC; // Çalışır
$myclass2->foo2(); // genel ve korumalı çalışır, özel çalışmaz
?>

Diğer nesnelerden görünürlük

Aynı türdeki nesneler, aynı örnekler olmasalar bile, diğerlerinin özel ve korunan üyelerine erişime sahip olacaktır. Bunun sebebi, gerçeklenime özgü ayrıntıların bu nesnelerin içindeyken zaten biliniyor olmasıdır.

Örnek 4 - Aynı nesne türündeki özel üyelere erişim

<?php
class Test
{
private
$foo;

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

private function
bar()
{
echo
'Private yönteme erişildi.';
}

public function
baz(Test $other)
{
// private özelliği değiştirilebilir:
$other->foo = 'hello';
var_dump($other->foo);

// private yöntemi de çağırılabilir:
$other->bar();
}
}

$test = new Test('test');

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

Yukarıdaki örneğin çıktısı:

string(5) "hello"
Private yönteme erişildi.
add a note

User Contributed Notes 7 notes

up
61
pgl at yoyo dot org
8 years ago
Just a quick note that it's possible to declare visibility for multiple properties at the same time, by separating them by commas.

eg:

<?php
class a
{
protected
$a, $b;

public
$c, $d;

private
$e, $f;
}
?>
up
20
r dot wilczek at web-appz dot de
18 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
8
jc dot flash at gmail dot com
11 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
6
Joshua Watt
16 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
?>
up
2
bishop at php dot net
7 years ago
> Members declared protected can be accessed only within
> the class itself and by inherited classes. Members declared
> as private may only be accessed by the class that defines
> the member.

This is not strictly true. Code outside the object can get and set private and protected members:

<?php
class Sealed { private $value = 'foo'; }

$sealed = new Sealed;
var_dump($sealed); // private $value => string(3) "foo"

call_user_func(\Closure::bind(
function () use (
$sealed) { $sealed->value = 'BAZ'; },
null,
$sealed
));

var_dump($sealed); // private $value => string(3) "BAZ"

?>

The magic lay in \Closure::bind, which allows an anonymous function to bind to a particular class scope. The documentation on \Closure::bind says:

> If an object is given, the type of the object will be used
> instead. This determines the visibility of protected and
> private methods of the bound object.

So, effectively, we're adding a run-time setter to $sealed, then calling that setter. This can be elaborated to generic functions that can force set and force get object members:

<?php
function force_set($object, $property, $value) {
call_user_func(\Closure::bind(
function () use (
$object, $property, $value) {
$object->{$property} = $value;
},
null,
$object
));
}

function
force_get($object, $property) {
return
call_user_func(\Closure::bind(
function () use (
$object, $property) {
return
$object->{$property};
},
null,
$object
));
}

force_set($sealed, 'value', 'quux');
var_dump(force_get($sealed, 'value')); // 'quux'

?>

You should probably not rely on this ability for production quality code, but having this ability for debugging and testing is handy.
up
0
alperenberatdurmus at gmail dot com
11 months ago
Dynamic properties are "public".
<?php
class MyClass {
public function
setProperty($value) {
$this->dynamicProperty = $value;
}
}
$obj = new MyClass();
$obj->setProperty('Hello World');
echo
$obj->dynamicProperty; // Outputs "Hello World"
?>

This usage is the same as well:
<?php
class MyClass {
}
$obj = new MyClass();
$obj->dynamicProperty = 'Hello World';
echo
$obj->dynamicProperty; // Outputs "Hello World"
?>
up
0
kostya at eltexsoft dot com
2 years ago
I see we can redeclare private properties into child class
<?php
class A{
private
int $private_prop = 4;
protected
int $protected_prop = 8;
}

class
B extends A{
private
int $private_prop = 7; // we can redeclare private property!!!
public function printAll() {
echo
$this->private_prop;
echo
$this->protected_prop;
}
}

$b = new B;
$b->printAll(); // show 78
}
?>
To Top