Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
PHP · Question Set
Object-Oriented PHP interview questions for placements and exams.
Questions
15
Included in this set
Subject
PHP
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for PHP.
An abstract class cannot be instantiated directly. It can contain abstract methods that must be defined by child classes. Abstract classes are useful when creating a base class for related objects. Example: abstract class Animal { abstract function sound(); } class Dog extends Animal { function sound(){ echo 'Bark'; } }
abstract class Shape { abstract function area(); }Polymorphism means one interface, many implementations. In PHP, it allows different classes to define methods with the same name but different behaviors. It improves code flexibility. Example: interface Shape { public function draw(); } class Circle implements Shape { function draw(){ echo 'Drawing Circle'; } } class Square implements Shape { function draw(){ echo 'Drawing Square'; } }
interface Shape { function draw(); }In PHP, the 'extends' keyword allows one class to inherit properties and methods from another class. Example: class ParentClass {} class ChildClass extends ParentClass {}
class Vehicle {}
class Car extends Vehicle {}Method overriding means redefining a parent class method inside a child class with the same name and parameters. The child version replaces the parent one when called from the child object.
class ParentClass { function greet(){ echo 'Hi'; } }
class Child extends ParentClass { function greet(){ echo 'Hello'; } }The __construct() method is called automatically when a class object is created. It is used to initialize values. Example: class Car { function __construct(){ echo 'Car ready'; } }
class Car {
function __construct(){ echo 'Object created'; }
}Access modifiers control visibility. Public means accessible everywhere. Protected means within the class and subclasses. Private means only inside the same class.
class Test { public $a; protected $b; private $c; }Static properties and methods belong to the class itself, not to instances. You can access them using ClassName::method().
class Math { static $pi=3.14; static function add($a,$b){ return $a+$b; } }
echo Math::$pi;$this refers to the current object instance inside a class. It is used to access class properties or methods of that object.
class User { public $name; function say(){ echo $this->name; } }An interface defines a set of methods that must be implemented by any class using it. It helps in achieving multiple inheritance in PHP.
interface Animal { public function sound(); }
class Dog implements Animal { public function sound(){ echo 'Bark'; } }Traits allow code reusability in multiple classes. They provide a way to use common methods across unrelated classes.
trait Logger { function log(){ echo 'Logging...'; } }
class App { use Logger; }A constructor (__construct) runs automatically when an object is created, often to initialize values. A destructor (__destruct) runs when an object is destroyed or the script ends, used for cleanup like closing database connections. Example: class FileHandler { function __construct(){ echo 'Opening file'; } function __destruct(){ echo 'Closing file'; } }
class Demo { function __construct(){} function __destruct(){} }In PHP, the keyword 'class' is used to define a class, and 'new' is used to create an object from that class. Example: class Car { public $name; } $car = new Car();
class Car { public $brand; }
$car = new Car();Encapsulation means binding data and methods together while restricting direct access to some data. It is achieved using private and protected access modifiers. This helps maintain control over how data is accessed or changed. Example: class BankAccount { private $balance = 0; public function deposit($amount){ $this->balance += $amount; } public function getBalance(){ return $this->balance; } }
class BankAccount { private $balance; }Cloning creates a new object with the same properties as another object. PHP provides the clone keyword for this. You can also define a __clone() method to modify behavior after cloning. Example: class User { public $name; } $u1 = new User(); $u1->name = 'John'; $u2 = clone $u1; $u2->name = 'Sam'; Now $u1 and $u2 are separate objects.
$obj2 = clone $obj1;
Late static binding allows a child class to reference static methods or properties defined in the parent class using the static keyword instead of self. It ensures that methods refer to the class where they are actually called, not where they are defined. Example: class A { static function who(){ echo __CLASS__; } static function test(){ static::who(); } } class B extends A { static function who(){ echo __CLASS__; } } B::test(); // Outputs B
class Base { static function who(){} static function call(){ static::who(); } }For complete preparation, combine this set with full subject-wise practice for PHP. You can also explore other subjects and sets from the links below.