Object Oriented Programming ( OOP ) is programming with use of classes and objects. A class consists of constants, variables and methods ( functions to alter the class’s properties ). An object can be created from a class and can be altered by calling the class’s functions.
Why would I use classes & objects?
You may be asking yourself: why would I use OOP? That question has one simple answer: for writing your codes fast, efficient and keeping them clear.
Creating a class
As mentioned before, a class consists of constants, variables and methods. There’s one default method which ‘creates the object’. It is automaticly executed when an object of the class is created. In other words: it can be used to ‘initialize’ the object ( its default properties e.g. ). This method is called the construction ( __construct ) method.
class ClassName {
public function __construct( ... arguments ... ) {
}
}
What you may have noticed is that there’s the keyword ‘public’ before the function. This indicates that the function may be used/called from anywhere ( also from outside the class ). There are 3 types of keywords that indicate how a function may be accessed:
- Public May be accessed from anywhere: inside the class, outside the class or from a
parent class
- Protected May be accessed from inside the class OR from a parent class.
- Private May be accessed ONLY from inside the class.
Alright, knowing that, let’s go back to the construction method. The construction method may or may not need certain information to create the object and its properties. These need to be given as arguments to the class ( or: to the construction method of the class ).
For example: for creating a Product object, we may need the id, name and price of the product.
class Product {
private static $id, $name, $price;
public function __construct( $product_id, $product_name, $product_price ) {
}
}
The construction method now asks for the id, name and price of the product upon creating an object of the class (a Product object).
Using & Creating class variables and methods
To access variables and methods of the current class we use:
$this->variable_name or $this->function_name(… arguments …). In the example of the product class, we can now set the class variables equal to the ones given as arguments to the construction method:
class Product {
private static $id, $name, $price;
public function __construct( $product_id, $product_name, $product_price ) {
$this->id = $product_id;
$this->name = $product_name;
$this->price = $product_price;
}
}
Now we can create any other functions for the class ourselves, just the same way as the construction method was formed. For example a function to ‘buy’ the product could be created:
class Product {
private static $id, $name, $price;
public function __construct( $product_id, $product_name, $product_price ) {
$this->id = $product_id;
$this->name = $product_name;
$this->price = $product_price;
}
public function buy() {
echo “Successfully bought the product ‘”.$this->name.”’ for $”.$this->price.”!”;
}
}
How to create an object of a class?
So far we know how to create a class, but not yet how to create an actual object of the class. It’s however not so hard to do. An object of a class is created using the keyword new followed by the name of the class and brackets which may contain arguments that are required for the class ( by the construction method of the class ). An object is usually created inside of a variable:
$myObject = new ClassName( … arguments … );
We’ll continue with the Product class we’ve been creating. The construction method requires 3 variables to be given values to: product_id, product_name and product_price. These need to be given values to when we want to create an object ( product ) of the class. We do this by giving them as arguments.
$product = new Product( 1, “Example Product”, 9.95 );
This will create an object of the class and set the variable id equal to 1, name equal to “Example Product” and price equal to 9.95. We’ve created a ‘product’! Now we may use any of the public variables and functions of the class. For example the buy function we made.
$product = new Product( 1, “Example Product”, 9.95 );
$product->buy();
This will output:
Successfully bought the product ‘Example Product’ for 9.95!
Note: the script of the class we created needs to be included in the script that creates the object of the class and needs to be put BEFORE it, so that the class is recognized when it’s created. Usually the code of a class definition is put in a separate file ( e.g. ClassName.class.php ) and then included into the file that uses the class. For example, assuming we put our class code inside the file Product.class.php:
<?php
include(“Product.class.php”);
$product = new Product( 1, “Example Product”, 9.95 );
$product->buy();
?>
Extending classes
Classes can also be extended. When this happens, we create a new class based on an earlier created class. The new (parent) class may use any methods and variables of the earlier created class ( the ‘main’ class ).
class MainClass {
}
class ParentClass extends MainClass {
}
For example:
<?php
class Product {
protected $id, $name, $price; //protected: can be accessed from parent class too
public function __construct() { }
public function buy() {
echo “Successfully bought the product ‘”.$this->name.”’ for $”.$this->price.”!”;
}
}
class Game extends Product {
protected $rank;
public function __construct($game_id, $game_name, $game_price, $game_rank) {
//may use any variables from the parent class (‘Product’)
$this->id = $game_id;
$this->name = $game_name;
$this->price = $game_price;
//may also create and use its own, new variables
$this->rank = $game_rank;
}
}
$test_game = new Game(1, “Test Game”, 19.95, 3);
//when creating an object of the Game class, the methods of the ‘main’ class may be used
$test_game->buy();
?>