Object Oriented Concept — Part 2 MCQs with Explanations

A double underscore followed by the construct keyword. Its syntax is function __construct ([ argument1, argument2,…..]) { Class Initialization code }.

Using instanceof keyword we can determine whether an object is an instance of a class. $manager = new Employee() … if ($manager instanceof Employee) echo “True”;

The class_exist() function returns true or false according to whether the class exists within the currently executing script content.

The is_a() function returns true if object belongs to a class type or if it belongs to a class that is a child of that class. Or else false is returned.

Yes they are nothing but variables.

The advanced OOP features are: Object cloning, Inheritance, Interfaces, Abstract classes, and Namespaces.

You can clone an object by prefacing it with the clone keyword.

Following is a basic example of method chaining in php: $a = new Order(); $a->CreateOrder()->sendOrderEmail()->createShipment();

A package is a set of related classes, usually grouped together in some way. Packages can be used to separate parts of a system from one another.

If you named a class ShoppingBasket, it would become instantly available across your system.

A namespace is a bucket in which you can place your classes, functions and variables.

The namespace declaration must be the first statement in its file.

Example – namespace com\getinstance\util;

Use keyword allows you to alias other namespaces within the current namespace. Example – namespace main; use comgetinstanceutil; utilDebug::helloWorld();

The only difference between the include() and require() statements lies in their handling of errors. A file invoked using require() will bring down your entire process when you meet an error. The same error encountered via a call to include() will merely generate a warning and end execution of the included file.

require() and require_once() are actually statements, not functions. This means that you can omit the brackets when using them.

When the PHP engine encounters an attempt to instantiate an unknown class, it invokes the __autoload() function, passing it the class name as a string. It is up to the implementer to define a strategy for locating and including the missing class file.

__autoload is a powerful tool, but it does have some limitations. In particular, you can only define it once in a process. If you need to change your autoload function dynamically you should look at the spl_autoload_register function, which supports that functionality.

The class_exists() function accepts a string representing the class to check for and returns a Boolean true value if the class exists and false otherwise.

This function accepts any object as an argument and returns its class name as a string.

As of PHP 5.3 is_a() no longer deprecated.

The function get_class_methods returns an array therefore we cannot use echo.

There is another method which you can use – method_exists() for similar purpose.

method_exists() returns true for private and protected methods as well as for public ones. Remember that the fact that a method exists does not mean that it will be callable.

The class functions also allow us to chart inheritance relationships.This function requires either an object or a class name, and it returns the name of the superclass, if any. If no such class exists, that is, if the class we are testing does not have a parent, then the function returns false.

is_subclass_of() will tell you only about class inheritance relationships. It will not tell you that a class implements an interface.

Procedural code takes the form of a sequential series of commands and method calls. The controlling code tends to take responsibility for handling differing conditions. This top-down control can result in the development of duplications and dependencies across a project. Object-oriented code tries to minimize these dependencies by moving responsibility for handling tasks away from client code and toward the objects in the system.

Such a design decision does have its own consequences, however.

Ideally, you should create components that share a clear responsibility. If your code spreads related routines widely, you will find them harder to maintain as you have to hunt around to make changes. Our ParamHandler classes collect related procedures into a common context.

Tight coupling is by no means unique to procedural code, though the sequential nature of such code makes it prone to the problem.

Orthogonality, it is argued, promotes reuse in that components can be plugged into new systems without needing any special configuration. Such components will have clear inputs and outputs independent of any wider context.

Polymorphism is the maintenance of multiple implementations behind a common interface.

Encapsulation simply means the hiding of data and functionality from a client.

Duplication is one of the great evils in code. Take a look at the instances of repetition in your system. Perhaps they belong together. If you change something fundamental about one routine, will the similar routines need amendment? If this is the case, they probably belong in the same class.

The UML emerged as a standard only after long years of intellectual and bureaucratic sparring among the great and good of the object oriented design community.

The other two sections are optional when no more information than the class name is known.

The {abstract} syntax is an example of a constraint. There is no special structure for the text between the braces; it should simply provide a short clarification of any conditions that may apply to the element.

Attributes describe a class’s properties. Attributes are listed in the section directly beneath the class name.

The visibility symbol is followed by the name of the attribute.

In the case of aggregation, the contained objects are a core part of the container, but they can also be contained by other objects at the same time.