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();
?>

function funcName ( ... arguments ... ) {
	... function process code ...
}

You can give the function any name you like as long as there’s not already an existing PHP function with the same name. The arguments of the function are variables where the function needs values for ( data that’s required for your function to run ). For example: a function that retrieves all data of a user would require the user’s ID to be given as argument to the function. Upon calling the function, these arguments should be given values to. A function is called by its name followed by values for the variables that need to be given as arguments to the specific function, between brackets.

funcName( … arguments … );

The function’s return can be of any type ( boolean, String, integer, anything ). However, do notice that returning a value is different from echoing a value. When a value is returned, it can be catched by a variable. When a value is echoed, it automaticly is displayed on the webpage. For example, a function that returns a value can be compared:

$num = 9;
if(sqrt($num) == 3) {
	echo “The number is 9.”;
}

The function sqrt is a premade function that returns the integer square root of the number given as argument to the function.