class Fruit {
 private $color;

 public function eat() {
  //chew
 }

  public function setColor($c) {
   $this->color = $c;
  }
 }

 class Apple extends Fruit {
  public function eat() {
   //chew until core
  }
 }

 class Orange extends Fruit {
  public function eat() {
   //peel
   //chew
  }
 }

Now taste an apple

$apple = new Apple();
$apple->eat();

What’s the taste of it? Obviously it’s apple

Now eat a fruit

$fruit = new Fruit();
$fruit->eat();

What’s the taste of it? It doesn’t make any sense. does it? Which means the class fruit should not be Instantiable . This is where the abstract class comes into play

abstract class Fruit {
 private $color;

 abstract public function eat()

 public function setColor($c) {
  $this->color = $c;
 }
}

function MyPow($r, $w){
 if($w==0)
  return 1;
 else
  return MyPow($r, $w-1) * $r;
}

echo MyPow(10, 2);

Also this functionality substitutes by the pow() function in PHP.

The E_DEPRECATED error level is used to indicate that a function or feature has been deprecated.

E_USER_DEPRECATED

The E_USER_DEPRECATED level is intended for indicating deprecated features in user code, similarly to the E_USER_ERROR and E_USER_WARNING levels.

class A {
    public function who() {
        echo __CLASS__;
    }
    public function test() {
        $this->who();
    }
}

class B extends A {
    public function who() {
        echo __CLASS__;
    }
}
$obj = new B;
$obj->test();

Out put of the above snippet is? B This is mainly because we have the object instance named as $this is for the class B, though the function is instantiated inside class A. But, If you need the expected output which is “A”, we can call them statically as follows

class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        self::who();
    }
}

class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();

Out put -> A

Main limitation of self:: or __CLASS__ are resolved using the class in which the function belongs, as in where it was defined. By introducing late static binding this limitation has been resolved as follows,

class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        static::who(); // Here comes Late Static Bindings
    }
}

class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();

Out put -> B

<?php
function setcase(&$value, &$key){
$value = strtoupper($value);
}
$type = array('internal','external');
$format[] = array('rss','html','xml');
$format[] = array('csv','jason');
$map = array_combine($type, $format);
array_walk_recursive($map, 'setcase');
print_r($map);
?>

Only scalar values will be converted to upper cases. ‘ internal’ and ‘external’ are not passed into the user defined function.

Array
(
    [internal] => Array
        (
            [0] => RSS
            [1] => HTML
            [2] => XML
        )

    [external] => Array
        (
            [0] => CSV
            [1] => JASON
        )

)

preg_match(‘/http://([wW]+?).com/i’,'http://phpinterviewquestions.com’,$out);
echo $out[1];

Abstract class: abstract classes are the class where one or more methods are abstract but not necessarily all method has to be abstract. Abstract methods are the methods, which are declare in its class but not define. The definition of those methods must be in its extending class.

Interface: Interfaces are one type of class where all the methods are abstract. That means all the meth

Directory

stdClass

__PHP_Incomplete_Class

exception

php_user_filter

Best way to check your reserved classes is,
var_dump (get_declared_classes ());

Standard Defined Classes

These classes are defined in the standard set of functions included in the PHP build.

Directory
The class from which dir is instantiated.
stdClass
Created by typecasting to object.
__PHP_Incomplete_Class
Possibly created by unserialize().

Predefined classes as of PHP 5

These additional predefined classes were introduced in PHP 5.0.0.

exception
php_user_filter

Closure

The predefined final class Closure was introduced in PHP 5.3.0. It is used for internal implementation of anonymous functions.

The class has a constructor forbidding the manual creation of the object (issues E_RECOVERABLE_ERROR) and the __invoke method with the calling magic.

Abstract class: abstract classes are the class where one or more methods are abstract but not necessarily all method has to be abstract. Abstract methods are the methods, which are declare in its class but not define. The definition of those methods must be in its extending class.

Interface: Interfaces are one type of class where all the methods are abstract. That means all the methods only declared but not defined. All the methods must be define by its implemented class.