PHP Keywords: private, protected and public

Date:

9 March 2019

Welcome to my series on every PHP keyword and its usage. Today's items: private, protected and public.

These keywords are collectively known as visibility, and describe where a class constant, property or method can be accessed from.

• A private constant, property or method can only be accessed from within the class that defines it.
• A protected constant, property or method can only be accessed from within the class that defines it, or a descendant of that class.
• A public constant, property or method can be accessed from anywhere.

By default, all constants, properties and methods are public unless specified otherwise.

As a general rule, it's best to give everything the lowest visibility possible. It's a lot easier to refactor when you know that the only code calling a method is in the current class.

Notes:

• Visibility works the same way for static and instance properties/methods, and an instance of a class can call that class' private constants, static properties and static methods.
• Constants, properties and methods with private visibility cannot be overridden.
• Visibility isolates calls between classes, not between instances. An object can call another object's private method, provided that they are the same type of object.
• Traits are not inherited so much as applied. This means that a private constant, property or method in the trait will be copied onto any object using that trait, and can be called directly from the object.

Usage

<?php
class Example
{
	private const PRIVATE_CONSTANT = "private";
	protected const PROTECTED_CONSTANT = "protected";
	public const PUBLIC_CONSTANT = "public";
	
	private static $privateStaticProperty = "private";
	protected static $protectedStaticProperty = "protected";
	public static $publicStaticProperty = "public";
	
	private $privateProperty = "private";
	protected $protectedProperty = "protected";
	public $publicProperty = "public";
	
	private static function privateStaticMethod(){}
	protected static function protectedStaticMethod(){}
	public static function publicStaticMethod(){}
	
	private function privateMethod(){}
	protected function protectedMethod(){}
	public function publicMethod(){}
	
	public static function callPrivateStatic()
	{
		// This class has access to its own private constants, static
		// properties and static methods
		echo self::PRIVATE_CONSTANT;
		echo self::$privateStaticProperty;
		self::privateStaticMethod();
	}
	
	public static function callProtectedStatic()
	{
		// This class has access to its own protected constants, static
		// properties and static methods
		echo self::PROTECTED_CONSTANT;
		echo self::$protectedStaticProperty;
		self::protectedStaticMethod();
	}
	
	public static function callPublicStatic()
	{
		// This class has access to its own public constants, static properties
		// and static methods
		echo self::PUBLIC_CONSTANT;
		echo self::$publicStaticProperty;
		self::publicStaticMethod();
	}
	
	public function callPrivate()
	{
		// This class has access to its own private properties and methods
		echo $this->privateProperty;
		$this->privateMethod();
	}
	
	public function callProtected()
	{
		// This class has access to its own protected properties and methods
		echo $this->protectedProperty;
		$this->protectedMethod();
	}
	
	public function callPublic()
	{
		// This class has access to its own public properties and methods
		echo $this->publicProperty;
		$this->publicMethod();
	}
}

class ExampleChild extends Example
{
	public static function callProtectedStatic()
	{
		// This class has access to, and can override, its ancestors' protected
		// constants, static properties and methods
		echo parent::PROTECTED_CONSTANT;
		echo parent::$protectedStaticProperty;
		parent::protectedStaticMethod();
	}
	
	public static function callPublicStatic()
	{
		// This class has access to, and can override, its ancestors' public
		// constants, static properties and methods
		echo parent::PUBLIC_CONSTANT;
		echo parent::$publicStaticProperty;
		parent::publicStaticMethod();
	}
	
	public function callProtected()
	{
		// This class has access to, and can override, its ancestors' protected
		// properties and methods
		echo $this->protectedProperty;
		$this->protectedMethod();
	}
	
	public function callPublic()
	{
		// This class has access to, and can override, its ancestors' public
		// properties and methods
		echo $this->publicProperty;
		$this->publicMethod();
	}
}

class Other
{
	public static function callPublicStatic()
	{
		// This class has access to Example's public constants, static
		// properties and static methods
		echo Example::PUBLIC_CONSTANT;
		echo Example::$publicStaticProperty;
		Example::publicStaticMethod();
	}
	
	public function callPublic()
	{
		// This class has access to Example's public properties and methods
		$example = new Example();
		echo $example->publicProperty;
		$example->publicMethod();
	}
}

// The global scope also has access to Example's public constants, static
// properties, properties, static methods and methods.
echo Example::PUBLIC_CONSTANT;
echo Example::$publicStaticProperty;
Example::publicStaticMethod();
$example = new Example();
echo $example->publicProperty;
$example->publicMethod();