OOPS in PHP part II

Final Class & Method:

method::The final keyword  allows you to mark methods so that an inheriting class can not overload them.

class myclass

final function getbaseclassname(){

return _class_;

}

After declaring a class as final ,it can't inherited.

The final keyword is used to prevent a class from being inherited and to prevent inherited method from being overridden.

Class Constants :

Class constants can be useful if you need to define some constant data within a class.

A class constant is declared inside a class with the const keyword.

We can access a constant from outside the class by scope resolution operator(::).

class Goodbye {
  const LEAVING_MESSAGE = "Thank you for visiting W3Schools.com!";
}

echo Goodbye::LEAVING_MESSAGE;

Or, we can access a constant from inside the class by using the self keyword followeed by resolution, like self::LEAVING_MESSAGE

PHP 8.1 Final Class Constants: 

 

 PHP 8.1 supports the final flag on class constants.

the final flag was not allowed on class constants, which would have protected class constants from being overridden by sub classes. Attempting to use the final flag on class constants resulted in a fatal error.

 

https://php.watch/versions/8.1/final-class-const

Overloading:

Function overloading or method overloading is a feature that allows creating several methods with the same name which differ from each other in the type of the input parameters. It is simply defined as the ability of one function to perform different tasks.

For example, doTask() and doTask(object O) are overloaded methods. To call the latter, an object must be passed as a parameter, whereas the former does not require a parameter, and is called with an empty parameter field. It is a form of static polymorphism which .The decision to call an implementation or another is taken at coding time.

Function overriding

Function overriding occurs when you extend a class and rewrite a function which existed in the parent class:

Traits:

One of the problems of PHP as a programming language is the fact that you can only have single inheritance.


To overcome this proublem traits introduces in php 5.4 and onwords,


A Trait is simply a group of methods that you want include within another class. A Trait, like an abstract class, cannot be instantiated on it’s own.




 trait Sharable {  
   public function share($item){   
   return ‘share this item’;   
   }  
 }  
 //use it on your own class like below ,  
 class Post {  
  use Sharable;  
 }  
 class Comment {  
  use Sharable;  
 }   

We can use multiple traits at the same time, 

like With in class,


class {


use Sharable,traits2,traits3;


}


A Trait is basically just a way to “copy and paste” code during run time.




Method Overriding in Traits: 

In inheritance We can override the function with in child class , That is the feature of inheritance. But if you are using traits, then you can not override the function.

The order of using the function is , 

First it will check the function abc in child class  if exists it would be used, if not there then check in traits if found then traits function would be used, if not available in traits then it fill find in base class,

So precedence would be : child class -> traits -> base class

 class Abc {  
  public function abc(){  
  echo "I am From Abc Class";   
  }  
 }  
 traits test{  
  public function abc(){  
  echo "I am From Traits test";  
  }  
 }  
 Class xyz extends Abc{  
  use test;  
  public function abc(){  
  echo "I am From Xyz Class";  
  }  
 }  
 $d = new xyz();  
 $d-abc();  

Late Static Binding : 

Compile-time and run-time, When Code compile it checks all the code and checks errors if exists if all is good then go running.
We can access the static variable by self keyword which is in the same class only,

Now Talk about the late static Binding means assign the value at the run time instead of compile time.
As given example, When it compiles it and finds the static::$variable name then,, the compiler left them blank to assign the value at run time.

 
 class DB{  
  protected static $table = 'base_table';  
  public function select(){  
  echo "Select * from".static::$table;   
  }  
  public function insert(){  
  echo "INSERT INTO".static::$table;   
  }  
 }  
 class UserAccounts extends DB{  
  protected static $table = 'users';  
 }  
 $accounts = new UserAcconts();  
 $accounts->select();  
 //output would be   
 select * from users;  

When we create an instance of the class then it will catch the variable of the derived class not from the base class. In Modern frameworks like CakePHP, YII also uses the same concept to write the models.

Static Members , function & class

Members(Variables) : We can access the variables by $this,self & static keyword

$this is used within the class when creating the instance of the class.

Static variables are related to the class not the instance of the class.

class Abc{

public static $name = 'Aman';

}

echo Abc::name; //aman

So we can access the variables and methods without creating the instance of the class by static Keyword.