php.lab

⌂ Home ▲ Previous: Classes ▼ Next: Magic methods

Class members

Example: Class members

<?php

class SomeClass
{
    const SOME_CONSTANT = 'apple';

    public $someProperty = 'orange';

    public function someMethod()
    {
        return 'strawberry';
    }
}

$someObject = new SomeClass();

print('Statically accessed constant value: ' . SomeClass::SOME_CONSTANT . PHP_EOL);
print('Dynamically accessed property value: ' . $someObject->someProperty . PHP_EOL);
print('Dynamically called method result: ' . $someObject->someMethod() . PHP_EOL);

Result (PHP 8.4):

Statically accessed constant value: apple
Dynamically accessed property value: orange
Dynamically called method result: strawberry

Source code: Example

Example: Class static members

<?php

class SomeClass
{
    const SOME_CONSTANT = 'pear';

    public static $someStaticProperty = 'lemon';

    public static function someStaticMethod()
    {
        return 'blackberry';
    }
}

$someObject = new SomeClass();

print('Statically accessed constant value: ' . SomeClass::SOME_CONSTANT . PHP_EOL);
print('Statically accessed static property value: ' . SomeClass::$someStaticProperty . PHP_EOL);
print('Statically called static method result: ' . SomeClass::someStaticMethod() . PHP_EOL);
print('Dynamically called static method result: ' . $someObject->someStaticMethod() . PHP_EOL);

Result (PHP 8.4):

Statically accessed constant value: pear
Statically accessed static property value: lemon
Statically called static method result: blackberry
Dynamically called static method result: blackberry

Source code: Example

Visibility

The visibility of a property, a method or (as of PHP 7.1.0) a constant can be defined by prefixing the declaration with the keywords public, protected or private. Class members declared public can be accessed everywhere. Members declared protected can be accessed only within the class itself and by inheriting and parent classes. Members declared as private may only be accessed by the class that defines the member.

Example: Class member visibility

<?php

class SomeClass
{
    public const SOME_PUBLIC_CONSTANT = 'public';
    protected const SOME_PROTECTED_CONSTANT = 'protected';
    private const SOME_PRIVATE_CONSTANT = 'private';

    public $somePublicProperty = 'public';
    protected $someProtectedProperty = 'protected';
    private $somePrivateProperty = 'private';

    public function somePublicMethod()
    {
        return 'public';
    }

    protected function someProtectedMethod()
    {
        return 'protected';
    }

    private function somePrivateMethod()
    {
        return 'private';
    }

    function someMethod()
    {
        print(
            "# From the base class:\n"
            . "\n* constants:\n"
            . self::SOME_PUBLIC_CONSTANT . PHP_EOL
            . self::SOME_PROTECTED_CONSTANT . PHP_EOL
            . self::SOME_PRIVATE_CONSTANT . PHP_EOL
            . "\n* properties:\n"
            . $this->somePublicProperty . PHP_EOL
            . $this->someProtectedProperty . PHP_EOL
            . $this->somePrivateProperty . PHP_EOL
            . "\n* methods:\n"
            . $this->somePublicMethod() . PHP_EOL
            . $this->someProtectedMethod() . PHP_EOL
            . $this->somePrivateMethod(). PHP_EOL
            . PHP_EOL
        );
    }
}

class OtherClass extends SomeClass
{
    function otherMethod()
    {
        print(
            "# From the derived class:\n"
            . "\n* constants:\n"
            . self::SOME_PUBLIC_CONSTANT . PHP_EOL
            . self::SOME_PROTECTED_CONSTANT . PHP_EOL
            . "\n* properties:\n"
            . $this->somePublicProperty . PHP_EOL
            . $this->someProtectedProperty . PHP_EOL
            . "\n* methods:\n"
            . $this->somePublicMethod() . PHP_EOL
            . $this->someProtectedMethod() . PHP_EOL
            . PHP_EOL
        );
    }
}

$someObject = new SomeClass();
$someObject->someMethod();

$otherObject = new OtherClass();
$otherObject->otherMethod();

print(
    "# From the outside:\n"
    . "\n* constants:\n"
    . SomeClass::SOME_PUBLIC_CONSTANT . PHP_EOL
    . "\n* properties:\n"
    . $someObject->somePublicProperty . PHP_EOL
    . "\n* methods:\n"
    . $someObject->somePublicMethod() . PHP_EOL
    . PHP_EOL
);

Result (PHP 8.4):

# From the base class:

* constants:
public
protected
private

* properties:
public
protected
private

* methods:
public
protected
private

# From the derived class:

* constants:
public
protected

* properties:
public
protected

* methods:
public
protected

# From the outside:

* constants:
public

* properties:
public

* methods:
public

Source code: Example

Visibility from other objects

Objects of the same type will have access to each others private and protected members even though they are not the same instances. This is because the implementation specific details are already known when inside those objects.

Example: Accessing private members of the same object type

<?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)
    {
        // We can change the private property:
        $other->foo = 'hello';
        var_dump($other->foo);

        // We can also call the private method:
        $other->bar();
    }
}

$test = new Test('test');

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

The above example will output:

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

php.lab

Class members

Visibility

Visibility from other objects

Dynamic and static context

Class members static access

Class members dynamic access

Object & class context

Object context

Class context

Accessing class members by self, parent and static keywords

Nullsafe properties and methods

Class constants

Class name resolution

Class constant visibility modifiers

Class constant type declarations

Properties

Static properties

Property definition

Property visibility modifiers

Asymmetric property visibility

Property type declarations

Property access

Readonly properties

Dynamic properties

Methods

Static methods

Method visibility modifiers

Method type declarations

Class properties and methods names

Property hooks

Backed hooks

Virtual properties

References

Serialization

Accessing class members by `self`, `parent` and `static` keywords