Concept & Definitions

Concept	Definition
NAMESPACE	Namespace solves name collisions between your code and PHP/External librarys' classes, functions and constants. It is a string words separated with backslash It actually updates the class name Once introduced, class will be identified as Namespace + \ + Class To use class now, you need to write ‘Namespace + \ + Class’ Shortcut to above is using ‘use’ statement # Example PHP file. namespace My\Namespace; class MyClass {   public static function myMethod() {     ..   } } # Calling myMethod before introducing namespace. MyClass::myMethod() # Calling myMethod after introducing namespace. My\Namespace\MyClass::myMethod()
USE STATEMENT	use Statement imports the specified namespace (or class) to the current scope. It is class references for the shortcut class-name used in the file When PHP encounters shortcut class-name in file, it checks all (end of the) use statements if it has the references If u miss using using correct use statement, PHP will try to load that class from namespace mentioned in current file It does not include anything, read collection # Example PHP file. namespace My\Namespace; use OtherNamespace\MyClass1; use OtherNamespace\MyClass2 as MyAlias; # PHP internally converts. MyClass1::myMethod(); to OtherNamespace\MyClass1::myMethod(); MyAlias::myMethod(); to OtherNamespace\MyClass2::myMethod(); UnknownClass::myMethod(); to My\Namespace\UnknownClass::myMethod();
ENCAPSULATION	With respect to a class encapsulation refers to the wrapping of data with the methods that operate on that data. This way data is correctly accessed in a certain way, typically, only the object's own methods can directly inspect or manipulate its data, consequently one cannot randomly change the aspect of the program. Example, a person's email can only be set via a setEmail($email) method. The method may contain validation for email so that accidently one just cannot set any value for email, say $user->email = 'myemail.com'; It could lead to some logical issue in the system possibly failure in sending system generated emails.
SELF (Keyword)	self (also 'parent' and 'static') keyword is used to access properties or methods within the class definition. Sometimes, late static binding is required where self keyword is ignored; learn static keyword. class Father {   public function sayHello() {     echo self::class . ' said Hello!'; // Is supported by ClassName::class magic constant.     // This is similar to __CLASS__ . ' said Hello!';   }   public function getAge() {     return $this->age;     // self->age will throw error as Father->age holds no sense.   } } $father = new Father(); $father->sayHello(); // Father said Hello!
STATIC (Keyword)	By declaring methods or properties static you can access them (via Scope Resolution Operator (::)) without needing the class object. Consequently, the pseudo-variable $this is not available within the methods declared as static. ClassName::methodName(); Note: Object operator (->) does not work $father->getGender(); static (also 'self' and 'parent') keyword is used to access properties or methods within the class definition. Additionally, static keyword resolves the limitation of referencing the class that was initially called at runtime, this is also called Late Static Binding. Fact: It was decided not to introduce a new keyword but rather use static that was already reserved. self:: says - I will execute in the context of the class whom I physically belong to. Whereas, static:: says - I will execute in the runtime context. Limitation, class Father {   public static $temp = 100;   private static $gender;   public function sayHello() {     echo static::class . ' said Hello!';     echo self::class . ' said Hello!';   }   public function saySorry() {     echo self::class . ' said Sorry!';     echo static::class . ' said Sorry!'; // Here comes the Late Static Binding.   }   public static function getGender() {     return self::$gender;     // Important: $gender must be a static property.     // Accessing $gender via $this ($this->gender) is invalid.   } } Class Son extends Father {   public function sayHello() {     echo static::class . ' said Hello!';     echo self::class . ' said Hello!';     // This is similar to __CLASS__ . ' said Hello!';   } } $son = new Son(); echo $son::$temp; // 100 $son->sayHello(); // Son said Hello! // Son said Hello! $son->saySorry(); // Parent said Hello! // Son said Hello!

♪ ♫  Finding this helpful? Please put in comments what more could be added here..