<?php
//Explanation and features
//1- we can call the static methode and property without creating instance
//from the class => syntax to call is : classname::methodename(),ore propName.
// static property save the new value in the function .
class carA {
static private $color="red";
public static function size (){return "big"};
}
class carB { $color private $color =" black" ;
public function size (){return "small"};
//to access a static property to a public function in the same class =>
static private $price= 3000;
public function price(){
return self::$price;
}
}
$carOb = new carB();
echo $carOb->color;//output=>black;
echo $carOb->size();//output=>small;
echo $carOb->price();//output=>3000;
//to access to the static( property and methodes) className::propName/methodeName
echo carA::$color; //output is : red;
echo carA::size(); //output is : big;
/*
1) Example demonstrating need for static variables
This function is quite useless since every time it is called
it sets $a to 0 and prints 0.
The $a++ which increments the variable serves no purpose
since as soon as the function exits the $a variable disappears.
To make a useful counting function which will not lose track of the current count,
the $a variable is declared static:
*/
function test()
{
$a = 0;
echo $a;
$a++;
}
/*
2) Example use of static variables
A static variable exists only in a local function scope,
but it does not lose its value when program execution leaves this scope.
*/
function newTest()
{
static $a = 0;
echo $a;
$a++;
}
//https://www.php.net/manual/en/language.oop5.static.php
self::staticMethod();<?php
class Car
{
public function test($var = 'Hello kinjal')
{
$this->var = $var;
return $this->var;
}
}
class Bike
{
public static function test($var)
{
$var = '<br>this is static function';
return $var;
}
}
$obj = new Car();
echo $obj->test();
echo Bike::test('this is non static'); //static function called using :: double colon
?>
<?php
function foo(){
static $int = 0; // correct
static $int = 1+2; // correct
static $int = sqrt(121); // wrong (as it is a function)
$int++;
echo $int;
}
?>
class Products {
protected $id;
public function setId($id)
{
return $this->id = $id;
}
public function getProduct()
{
$arr_list = [
[
'name'=>'Proton',
'year' => 1987
],
[
'name'=>'Produa',
'year' => 1990
],
];
return $arr_list;
}
public static function product_list()
{
//whatever data want to return
$arr_list = [
[
'name'=>'Proton',
'year' => 1987
],
[
'name'=>'Produa',
'year' => 1990
],
];
return $arr_list;
}
}
//static can call directly
$lists = Product::product_list();
//non static
$product = new Product();
$lists = $product->getProduct();
//when calling class must alert memory consume.