Object Oriented Concept — Part 1 MCQs with Explanations

You declare a class with the class keyword and an arbitrary class name. Class names can be any combination of numbers and letters, although they must not begin with a number.

An object is said to be an instance of its class. It is of the type defined by the class.

In PHP 4, all properties were declared with var keyword, which is identical in effect to using public. For the sake of backward compatibility, PHP 5 accepts var in place of public for properties.

Example: $product1->title=”My Life”;

Code that uses a class, function, or method is often described as the class’s, function’s, or method’s client or as client code.

A method declaration resembles a function declaration. The function keyword precedes a method name, followed by an optional list of argument variables in parentheses.

By declaring a method public, you ensure that it can be invoked from outside of the current object.

A class that inherits from another is said to be a subclass of it. This relationship is often described in terms of parents and children. A child class is derived from and inherits characteristics from the parent.

To check if an object is not an instanceof a class, the logical not operator can be used.

Example- parent::__construct()

The new unified constructors use the name __construct(). Using the old syntax, a call to a parent constructor would tie you to that particular class: parent::ShopProduct();

An accessor method is called getter. The common use of a mutator method is to initialise the value of member variables of a class.

The static keyword was introduced with PHP 5. It cannot be used in PHP 4 scripts.

Self is to classes what the $this pseudo-variable is to objects.

Making a method call using parent is the only circumstance in which you should use a static reference to a non-static method.

By definition, static methods are not invoked in the context of an object. For this reason, static methods and properties are often referred to as class variables and properties.

The PDO class provides a common interface to different database applications.

A constant property is declared with the const keyword. Like global constants, class constants cannot be changed once they are set.

Constants are not prefixed with a dollar sign like regular properties. By convention, they are often named using only uppercase characters

You should use constants when your property needs to be available across all instances of a class, and when the property value needs to be fixed and unchanging.

All scalar data i.e boolean, integer, float and string can be contained in constants.

An abstract class cannot be instantiated. Instead it defines (and, optionally, partially implements) the interface for any class that might extend it.

The introduction of abstract classes was one of the major changes ushered in with PHP 5. Its inclusion in the list of new features was another sign of PHP’s extended commitment to object-oriented design.

An abstract method cannot have an implementation. You declare it in the normal way, but end the declaration with a semicolon rather than a method body.

Classes defined as abstract may not be instantiated, and any class that contains at least one abstract method must also be abstract.

A class can implement an interface using the implements keyword in its declaration.

getCode() – Get the code integer that was passed to the constructor. getFile() – Get the file in which the exception was generated. getLine() – Get the line number at which the exception was generated.

The throw keyword is used in conjunction with an Exception object. It halts execution of the current method and passes responsibility for handling the error back to the calling code.

A final class cannot be subclassed.

The __set() method is invoked when client code attempts to assign to an undefined property. It is passed two arguments: the name of the property, and the value the client is attempting to set.

The __call() method is probably the most useful of all the interceptor methods. The __call() method can be useful for delegation. Delegation is the mechanism by which one object passes method invocations on to a second.

You can use this method to perform any final cleaning up that might be necessary. Imagine, for example, a class that saves itself to a database when so ordered. I could use the __destruct() method to ensure that an instance saves its data when it is deleted.

Clone operates on an object instance, producing a by-value copy.

By implementing a __toString() method, you can control how your objects represent themselves when printed. The method is invoked automatically when your object is passed to print or echo, and its return value is substituted.

__clone() is run on the copied object and not the original.

A final class cannot be subclassed. Less drastically, a final method cannot be overridden.

PHP supports five class property scopes: public, private, protected, final and static.

Class constants are created like: const NAME = ‘VALUE’;

In case of public methods, you can forgo explicitly declaring the scope and just declare the method like you would a function.

PHP supports six method scopes: public, private, final, static, protected and abstract.