Geek Files » PHP5 Tutorial

PHP5 Tutorials – Abstract Class and Interface

admin — Sun, 03 Feb 2008 08:26:29 +0000

In this post, we learn what is an abstract class and an interface.

What is an Abstract Class?
Private methods cannot be Abstract
What is an Interface?
Defining an Interface
Abstract Class v/s Interface

What is an Abstract Class?

An abstract class is a class with or without data members that provides some functionality and leaves the remaining functionality for its child class to implement. The child class must provide the functionality not provided by the abstract class or else the child class also becomes abstract.

Objects of an abstract and interface class cannot be created i.e. only objects of concrete class can be created

To define a class as Abstract, the keyword abstract is to be used e.g. abstract class ClassName { }

Example of Abstract Class

 
abstract class Furniture {
	private $height, width, length;
 
	public function setData($h, $w, $l) {
		$this->height = $h;
		$this->width = $w;
		$this->length = $l;
	}
 
        //this function is declared as abstract and hence the function
        //body will have to be provided in the child class
	public abstract function getPrice();
 
}
 
 
class BookShelf extends Furniture {
 
   private $price;
 
   public setData($h, $w, $l, $p) {
      parent::setData($h, $w, $l);
      $this->price = $p;
   }
 
 
   //this is the function body of the parent abstract method
   public function getPrice() {
      return $this->price;
   }
}

In the above example, the method getPrice() in class Furniture has been declared as Abstract. This means that its the responsibility of the child class to provide the functionality of getPrice(). The BookShelf class is a child of the Furniture class and hence provides the function body for getPrice().

Private methods cannot be abstract

If a method is defined as abstract then it cannot be declared as private (it can only be public or protected). This is because a private method cannot be inherited.

abstract class BaseClass {
 
   private abstract function myFun();
 
}
 
class DerivedClass extends BaseClass {
   public function myFun() {
	   //logic here
   }
}
 
$d = new DerivedClass(); //will cause error

What is an Interface?

An interface is a contract between unrelated objects to perform a common function. An interface enables you to specify that an object is capable of performing a certain function, but it does not necessarily tell you how the object does so, this means that it leaves for classes implementing an interface to define its behaviour.

To extend from an Interface, keyword implements is used.

We can have a class extend from more than one Interface.

 
interface Storable {
	function getContentsAsText();
}
 
class Document implements Storable {
	public function getContentsAsText() {
		return "This is Text of the Document\n";
	}
}
 
class Indexer {
	public function readAndIndex(Storable $s) {
		$textData = $s->getContentsAsText();
		//do necessary logic to index
		echo $textData;
	}
}
 
$p = new Document();
 
$i = new Indexer();
$i->readAndIndex($p);

In the above example, Document and the Indexer class are two independant classes. The Indexer class is designed to index the contents of any text. Using the Storable interface above, we declare a method getContentsAsText() in the Document class. Because the Indexer class is only concerned with the TEXT, hence we can call getContentsAsText() method on the object of Document. This way any class if it implements the method getContentsAsText() can get indexed

Difference between Abstract Class and Interface

Abstract Classes

An abstract class can provide some functionality and leave the rest for derived class
The derived class may or may not override the concrete functions defined in base class
The child class extended from an abstract class should logically be related

Interface

An interface cannot contain any functionality. It only contains definitions of the methods
The derived class must provide code for all the methods defined in the interface
Completely different and non-related classes can be logically be grouped together using an interface

Subscribe below for article updates

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Magic Methods – __autoload() method

admin — Sat, 03 Nov 2007 09:34:31 +0000

This tutorial will teach you how and when to use the magic method __autoload().

The magic method __autoload() function is a convenience that allows you to use classes without having to explicitly write code to include them.

The magic method __autoload() is not included in your class definition as this is to be called once in a script. The best place to put the autoload() file is in your configuration file which is loaded in all your other scripts.

Many people debate that the magic method __autoload() causes a performance overhead. Well, that is not the case. There is no performance penalty to pay. In fact, there may be performance improvements if not all classes are used all the time. This is explained below.

Using the magic method __autoload has the beneficial side effect of requiring strict naming conventions for files that hold class definitions.

Look at the example below:

include â€œcustomer.phpâ€;
include â€œorders.phpâ€;
 
$c = new Customer();

In the example displayed above, an instance of class Customer is created. Therefore, we only need the customers.php file. The file orders.php is not needed. This means that we should only have included the customer.php file. But, what if during execution on the basis of a condition, an instance of class Orders would have to be created. Therefore you need to include both the files i.e. customer.php and orders.php

But this causes performance issues. Each time the above script is executed, orders.php is included. To avoid this performance hit, we would have to do additional programming to ensure that the file orders.php is loaded only when needed.

This is the reason why magic method __autoload() should be used. Look at the example below:

function __autoload($class) {
   require $class . '.php'; //is substituted as require Customer.php (with capital 'C')
}
 
$c = new Customer();

In the above program, we don’t explicitly include customer.php and orders.php file. When an instance of the customer class is to be created, the PHP engine checks to see if the file Customer.php is loaded. It does not raise an warning on finding that Customer.php has not been loaded, it in turn calls the magic method __autoload(). The __autoload() magic method accepts a parameter which is the name of the class that needs to be loaded.

Therefore, on the line when an instance of the customer class is created i.e. object $c, magic method __autoload() is called with the parameter $class containing value ‘Customer’. Within the __autoload() method we call the ‘require’ method. The require method tries to load $class.’php’ file i.e. Customer.php. Therefore, as stated earlier, the __autoload() method has its beneficial side effect of requiring strict file naming convention.

The __autoload() method is called only once for each new class that needs to be loaded. Subsequent instantiation of the Customer class object will not call the __autoload() method again. Therefore, this offers performance improvements in your scripts because, unless the class is needed – files are not loaded. Therefore, the PHP engine does not have to parse and compile an unnecessary file.

Please feel free to leave behind any comments or questions that you might have.

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)