THE DIFFERENCE BETWEEN CLASSES AND OBJECTS IN PHP

The standards for WordPress development are slowly moving from turns of procedural code that lack proper abstraction to more SOLID and object-oriented code.

That’s a step in the right direction, but let’s not forget two important things that often get left out of these discussions: putting code in a class does not make it “object-oriented,” and object-oriented PHP is not, by definition better.

Today, we will discuss what what an object is and what its role is. Then we can discuss what we mean by “true object-oriented programming” and whether it really matters if your code is “true OOP” or not.

Arrays vs Objects

PHP has two compounds (also known as composite) data types: objects and arrays. Compound data types require composition — the process of combining other data types into one “unit.” In purely object-oriented languages, we have to compose data types that in PHP are available to us as primitive types.

When explaining objects and object-oriented programming, I think it is really useful to start by talking about arrays, which are not objects. The fundamental difference between a PHP array and an object is that we can’t change the rules of an array. PHP the language defines what we can and can’t do with an array and there is no way for your PHP program to change that.

Objects on the other hand, have rules defined by the PHP program they are running in. These rules are what we call classes.

While every array plays by the same rule, each object plays by the rules of objects and by the rules of the class used to create them.

Instances

Sometimes the words “class” and “object” are used interchangeably, but they should not be. As I said above, classes are rules for creating objects, but those objects do not exist until they are instantiated.

Class instantiation happens using the new keyword. If I want an instance of the WP_Query class, I could create one like this:

PHP

1	$products = new WP_Query( [ 'post_type' => 'product' ] );

Instantiating a class and calling a function are very similar, but function calls are not preceded by the new keyword.

When a class is instantiated, its constructor is called immediately and any arguments injected into the class are passed to the constructor. Constructors are an example of a PHP magic method. They are a way to inject data directly into the object  and also to run code immediately on instantiation.

As you noticed, I passed an array of arguments to the WP_Query class when I instantiated the object. If you look inside WP_Query’s constructor, if the one argument it accepts isn’t empty, that argument is passed to the query method of that class.

The query method sets off the process that WP_Query is used for — querying the database to get posts. Separating that method out from the constructor is good design as it keeps the constructor from taking on too many responsibilities. It also allows us to control when the query is run. While most of the time it is fine to run the query right away, the flexibility that separating query() from __construct() is very useful.

While WP_Query has lots of rules, they apply to all objects or WP_Query, that does not mean all objects of WP_Query are the same. That’s because their properties will contain different information. For example, look at this code:

1 2 3

$products = new WP_Query( [ 'post_type' => 'product' ] );   $orders = new WP_Query( [ 'post_type' => 'shop_order' );

We now have two instances of the WP_Query class. Each one will contain totally different posts in their posts property, but the way that those posts got there and the way that they can be accessed or changed is the same.

What An Object Is An Instance Of

In the last section, I talked about objects that were instances of WP_Query. What we mean is that these objects were created using the WP_Query class. But, let’s not forget that classes can be subclassed. When an object is an instance of a class that extends another class, then it is considered an instance of both classes.

This is an important distinction because it determines how the function is_a() will function as well as type hinting rules. If I make a class that extends WP_Query, it will be considered an instance of WP_Query. This is one of the features of object inheritance that makes it so useful.

Let’s say you had an abstract class called “social” and two classes that extended it called “Facebook” and “Twitter”. You could identify the instance of these classes by checking if they were instanced of “social.”

What Is $this?

Inside of a class, you can access the current instance using the special variable $this. Outside of a class you can not use $this or PHP will throw an error. Inside of a class, you use $this to access properties or methods of that class.

The variable $this always refers to the current object, no matter which class in the inheritance hierarchy you are. On the other hand the keyword “self” refers to the current class, not the current instance. Static properties are not unique to a specific object, they are unique to a class.

“True” Object-Oriented Programming

A lot of time we see classes that don’t really represent a discernible object. Instead, they are a collection of related functions. In this case, the class acts as a namespace. This may or may not be a bad thing.

We always should test these situations on a case by case basis. In my opinion, it comes down to whether the code could be rewritten as a collection of functions that were not contained in a class. I say this because writing a class, just to avoid using unique function prefixes is no excuse to use a class, and is less performant and less flexible.

If the only utility of a class is avoiding using unique prefixes, then why not just group the functions into a file and use a namespace in that file?

But, keep in mind that classes have inheritance, visibility, and properties, which a group of functions do not. These are perfectly good reasons to use a class, even when it is not “true” object-oriented PHP.

In these situations, you are often dealing with a class where one instance is indiscernible from the next. Instantiating these classes into objects and tracking those objects is almost always a bad code smell and unnecessary. In these situations, it is often better to declare all methods of the class static, so instantiation is unneeded.

Many people will tell you that just because you’re using a class doesn’t mean you are using object-oriented programming. They are right. Just don’t forget that object-oriented programming is not categorically better than the alternatives.

Read More

THE DIFFERENCE BETWEEN CLASSES AND OBJECTS IN PHP

The standards for WordPress development are slowly moving from turns of procedural code that lack proper abstraction to more SOLID and object-oriented code.

That’s a step in the right direction, but let’s not forget two important things that often get left out of these discussions: putting code in a class does not make it “object-oriented,” and object-oriented PHP is not, by definition better.

Today, we will discuss what what an object is and what its role is. Then we can discuss what we mean by “true object-oriented programming” and whether it really matters if your code is “true OOP” or not.

Arrays vs Objects

PHP has two compounds (also known as composite) data types: objects and arrays. Compound data types require composition — the process of combining other data types into one “unit.” In purely object-oriented languages, we have to compose data types that in PHP are available to us as primitive types.

When explaining objects and object-oriented programming, I think it is really useful to start by talking about arrays, which are not objects. The fundamental difference between a PHP array and an object is that we can’t change the rules of an array. PHP the language defines what we can and can’t do with an array and there is no way for your PHP program to change that.

Objects on the other hand, have rules defined by the PHP program they are running in. These rules are what we call classes.

While every array plays by the same rule, each object plays by the rules of objects and by the rules of the class used to create them.

Instances

Sometimes the words “class” and “object” are used interchangeably, but they should not be. As I said above, classes are rules for creating objects, but those objects do not exist until they are instantiated.

Class instantiation happens using the new keyword. If I want an instance of the WP_Query class, I could create one like this:

PHP

1	$products = new WP_Query( [ 'post_type' => 'product' ] );

Instantiating a class and calling a function are very similar, but function calls are not preceded by the new keyword.

When a class is instantiated, its constructor is called immediately and any arguments injected into the class are passed to the constructor. Constructors are an example of a PHP magic method. They are a way to inject data directly into the object  and also to run code immediately on instantiation.

As you noticed, I passed an array of arguments to the WP_Query class when I instantiated the object. If you look inside WP_Query’s constructor, if the one argument it accepts isn’t empty, that argument is passed to the query method of that class.

The query method sets off the process that WP_Query is used for — querying the database to get posts. Separating that method out from the constructor is good design as it keeps the constructor from taking on too many responsibilities. It also allows us to control when the query is run. While most of the time it is fine to run the query right away, the flexibility that separating query() from __construct() is very useful.

While WP_Query has lots of rules, they apply to all objects or WP_Query, that does not mean all objects of WP_Query are the same. That’s because their properties will contain different information. For example, look at this code:

1 2 3

$products = new WP_Query( [ 'post_type' => 'product' ] );   $orders = new WP_Query( [ 'post_type' => 'shop_order' );

We now have two instances of the WP_Query class. Each one will contain totally different posts in their posts property, but the way that those posts got there and the way that they can be accessed or changed is the same.

What An Object Is An Instance Of

In the last section, I talked about objects that were instances of WP_Query. What we mean is that these objects were created using the WP_Query class. But, let’s not forget that classes can be subclassed. When an object is an instance of a class that extends another class, then it is considered an instance of both classes.

This is an important distinction because it determines how the function is_a() will function as well as type hinting rules. If I make a class that extends WP_Query, it will be considered an instance of WP_Query. This is one of the features of object inheritance that makes it so useful.

Let’s say you had an abstract class called “social” and two classes that extended it called “Facebook” and “Twitter”. You could identify the instance of these classes by checking if they were instanced of “social.”

What Is $this?

Inside of a class, you can access the current instance using the special variable $this. Outside of a class you can not use $this or PHP will throw an error. Inside of a class, you use $this to access properties or methods of that class.

The variable $this always refers to the current object, no matter which class in the inheritance hierarchy you are. On the other hand the keyword “self” refers to the current class, not the current instance. Static properties are not unique to a specific object, they are unique to a class.

“True” Object-Oriented Programming

A lot of time we see classes that don’t really represent a discernible object. Instead, they are a collection of related functions. In this case, the class acts as a namespace. This may or may not be a bad thing.

We always should test these situations on a case by case basis. In my opinion, it comes down to whether the code could be rewritten as a collection of functions that were not contained in a class. I say this because writing a class, just to avoid using unique function prefixes is no excuse to use a class, and is less performant and less flexible.

If the only utility of a class is avoiding using unique prefixes, then why not just group the functions into a file and use a namespace in that file?

But, keep in mind that classes have inheritance, visibility, and properties, which a group of functions do not. These are perfectly good reasons to use a class, even when it is not “true” object-oriented PHP.

In these situations, you are often dealing with a class where one instance is indiscernible from the next. Instantiating these classes into objects and tracking those objects is almost always a bad code smell and unnecessary. In these situations, it is often better to declare all methods of the class static, so instantiation is unneeded.

Many people will tell you that just because you’re using a class doesn’t mean you are using object-oriented programming. They are right. Just don’t forget that object-oriented programming is not categorically better than the alternatives.

Read More

PHP Object-Oriented Programming Beginner's Guide

Basic concepts around Object-Oriented Programming

Class vs Object

Class is like your house blueprint. Before your house is constructed, there is a house blueprint. It is not an actual house, but a plan how this house will look like, how many rooms it will have and so on. Then the house will be constructed by following the blueprint exactly. In this analogy, the house blueprint is a class and your actual house is an object. We can have unlimited objects of a class, just like we can build unlimited exact houses by following the same house blueprint.

A few key points to keep in mind:

• Class is generic, whereas Object is specific
• Class defines properties/functions of an Object
• Object is an instance of a Class
• You can instantiate an object, but not a Class

PHP Class

Class is consist of properties and methods. Below is a PHP class. In this simple class. $postCode is a property and ringBell() is a method. They are all prefixed with a visibility keyword (public).

Class House {

 public $postCode = “560121”;

 public function ringBell() {
  echo “Ding Dang Dong”;
 }
}
                    

To instantiate an object of a class, use the keyword new as below:

$house = new House();

Visibility

Each method and property has its visibility. There are three types of visibility in PHP. They are declared by keywords public, protected and private. Each one of them controls how a method/property can be accessed by outsiders.

Public: It allows anyone from outside access its method/property. This is the default visibility in PHP class when no keywords are prefixed to a method/property.

Protected: It only allows itself or children classes to access its method/property.

Private: It does not allow anyone except itself to access its method/property.

Inheritance

It lets subclass inherits characteristics of the parent class. Parent class decides what and how its properties/methods to be inherited by declared visibility.

class Shape {
 public function name() {
  echo "I am a shape";
 }
}

class Circle extends Shape {

}

$circle = new Circle();
$circle->name(); // I am a shape
                    

The key word here is extends. When Circle class extends from Shapeclass, it inherits all of the public and protected methods as well as properties from Shape class.

Polymorphism

The provision of a single interface to entities of different types. Basically it means PHP is able to process objects differently depending on their data type or class. This powerful feature allows you to write interchangeable objects that sharing the same interface.

interface Shape {
 public function name();
}

class Circle implements Shape {
 public function name() {
  echo "I am a circle";
 }
}

class Triangle implements Shape {
 public function name() {
  echo "I am a triangle";
 }
}

function test(Shape $shape) {
 $shape->name();
}

test(new Circle()); // I am a circle
test(new Triangle()); // I am a triangle
                    

Above example, test(Shape $shape) function declares(type hints) its only parameter to be Shape type. This function is not aware of Circle and Triangle classes. When either class is passed to this function as a parameter, it processes respectively.

Encapsulation

Encapsulation is used to hide the values or state of a structured data object inside a class, preventing unauthorized parties' direct access to them. It is a concept that motivates us to think through a method/class responsibility and hide its internal implementation/details accordingly. This will make it easy to modify the internal code in a long run without affecting other part of the system. Visibility is the mechanism for encapsulation.

class Person {
 private $name;

 public function setName($name) {
  $this->name = $name;
 }

 public function getName($name) {
  return $this->name;
 }
}

$robin = new Person();
$robin->setName('Robin');
$robin->getName();
                    

In this simple class above. Field $name is encapsulated (private). Users of the class is not aware how $name is stored in Person class. Right now the $name is stored in memory. We can modify internal code of Person class to store it to a flat file or event a database. Users of the class will not need to change any code, in fact they do not even know how $name is stored, because that is encapsulated and hided from them.

Abstraction

Abstraction is the concept of moving the focus from the details and concrete implementation of things, to the types of things (i.e. classes), the operations available (i.e. methods), etc, thus making the programming simpler, more general, and more abstract. It is like a generalization instead of a specification.

class TV {
 private $isOn = false;

 public function turnOn() {
  $this->isOn = true;
 }

 public function turnOff() {
  $this->isOn = false;
 }
}

$tv = new TV();
$tv->turnOn();
$tv->turnOff();
                    

Code above defined an TV class. We can not do much with it except turning it on and off. The class TV is an abstraction of a real TV in a very simple use case.

Interface vs Abstract class

Interface

Interface declares what methods a class must have without having to implement them. Any class that implements the interface will have to implement details of those declared methods. Interface is not a class, so you can not instantiate an interface. It is useful when you need to enforce some classes to do something.

interface Vehicle {
 public function startEngine();
}

class Car implements Vehicle {
 public function startEngine() {
  echo "Engine Started";
 }
}
                    

Vehicle is an interface with a declared method startEngine(). Carimplements Vechicle, so it has to implement what startEngine() method does.

Abstract class

Abstract class is able to enforce subclasses to implement methods similar to interface. When a method is declared as abstract in an abstract class, its derived classes must implement that method.

However it is very different from interface. You can have normal properties and methods as a normal class, because it is in fact a class, so it can be instantiated as a normal class.

abstract class Vehicle {
 abstract public function startEngine();

 public function stopEngine() {
  echo "Engine stoped";
 }
}

class Car extends Vehicle {
 public function startEngine() {
  echo "Engine Started";
 }
}
                    

Vehicle is an abstract class. Car extends Vechicle, so it has to implement what startEngine() method does, because this method is declared as abstract. However Car does not have to anything with method stopEngine(), it is inherited as a normal class does.

The End Guys.

Read More

PHP Object-Oriented Programming Beginner's Guide

Basic concepts around Object-Oriented Programming

Class vs Object

Class is like your house blueprint. Before your house is constructed, there is a house blueprint. It is not an actual house, but a plan how this house will look like, how many rooms it will have and so on. Then the house will be constructed by following the blueprint exactly. In this analogy, the house blueprint is a class and your actual house is an object. We can have unlimited objects of a class, just like we can build unlimited exact houses by following the same house blueprint.

A few key points to keep in mind:

• Class is generic, whereas Object is specific
• Class defines properties/functions of an Object
• Object is an instance of a Class
• You can instantiate an object, but not a Class

PHP Class

Class is consist of properties and methods. Below is a PHP class. In this simple class. $postCode is a property and ringBell() is a method. They are all prefixed with a visibility keyword (public).

Class House {

 public $postCode = “560121”;

 public function ringBell() {
  echo “Ding Dang Dong”;
 }
}
                    

To instantiate an object of a class, use the keyword new as below:

$house = new House();

Visibility

Each method and property has its visibility. There are three types of visibility in PHP. They are declared by keywords public, protected and private. Each one of them controls how a method/property can be accessed by outsiders.

Public: It allows anyone from outside access its method/property. This is the default visibility in PHP class when no keywords are prefixed to a method/property.

Protected: It only allows itself or children classes to access its method/property.

Private: It does not allow anyone except itself to access its method/property.

Inheritance

It lets subclass inherits characteristics of the parent class. Parent class decides what and how its properties/methods to be inherited by declared visibility.

class Shape {
 public function name() {
  echo "I am a shape";
 }
}

class Circle extends Shape {

}

$circle = new Circle();
$circle->name(); // I am a shape
                    

The key word here is extends. When Circle class extends from Shapeclass, it inherits all of the public and protected methods as well as properties from Shape class.

Polymorphism

The provision of a single interface to entities of different types. Basically it means PHP is able to process objects differently depending on their data type or class. This powerful feature allows you to write interchangeable objects that sharing the same interface.

interface Shape {
 public function name();
}

class Circle implements Shape {
 public function name() {
  echo "I am a circle";
 }
}

class Triangle implements Shape {
 public function name() {
  echo "I am a triangle";
 }
}

function test(Shape $shape) {
 $shape->name();
}

test(new Circle()); // I am a circle
test(new Triangle()); // I am a triangle
                    

Above example, test(Shape $shape) function declares(type hints) its only parameter to be Shape type. This function is not aware of Circle and Triangle classes. When either class is passed to this function as a parameter, it processes respectively.

Encapsulation

Encapsulation is used to hide the values or state of a structured data object inside a class, preventing unauthorized parties' direct access to them. It is a concept that motivates us to think through a method/class responsibility and hide its internal implementation/details accordingly. This will make it easy to modify the internal code in a long run without affecting other part of the system. Visibility is the mechanism for encapsulation.

class Person {
 private $name;

 public function setName($name) {
  $this->name = $name;
 }

 public function getName($name) {
  return $this->name;
 }
}

$robin = new Person();
$robin->setName('Robin');
$robin->getName();
                    

In this simple class above. Field $name is encapsulated (private). Users of the class is not aware how $name is stored in Person class. Right now the $name is stored in memory. We can modify internal code of Person class to store it to a flat file or event a database. Users of the class will not need to change any code, in fact they do not even know how $name is stored, because that is encapsulated and hided from them.

Abstraction

Abstraction is the concept of moving the focus from the details and concrete implementation of things, to the types of things (i.e. classes), the operations available (i.e. methods), etc, thus making the programming simpler, more general, and more abstract. It is like a generalization instead of a specification.

class TV {
 private $isOn = false;

 public function turnOn() {
  $this->isOn = true;
 }

 public function turnOff() {
  $this->isOn = false;
 }
}

$tv = new TV();
$tv->turnOn();
$tv->turnOff();
                    

Code above defined an TV class. We can not do much with it except turning it on and off. The class TV is an abstraction of a real TV in a very simple use case.

Interface vs Abstract class

Interface

Interface declares what methods a class must have without having to implement them. Any class that implements the interface will have to implement details of those declared methods. Interface is not a class, so you can not instantiate an interface. It is useful when you need to enforce some classes to do something.

interface Vehicle {
 public function startEngine();
}

class Car implements Vehicle {
 public function startEngine() {
  echo "Engine Started";
 }
}
                    

Vehicle is an interface with a declared method startEngine(). Carimplements Vechicle, so it has to implement what startEngine() method does.

Abstract class

Abstract class is able to enforce subclasses to implement methods similar to interface. When a method is declared as abstract in an abstract class, its derived classes must implement that method.

However it is very different from interface. You can have normal properties and methods as a normal class, because it is in fact a class, so it can be instantiated as a normal class.

abstract class Vehicle {
 abstract public function startEngine();

 public function stopEngine() {
  echo "Engine stoped";
 }
}

class Car extends Vehicle {
 public function startEngine() {
  echo "Engine Started";
 }
}
                    

Vehicle is an abstract class. Car extends Vechicle, so it has to implement what startEngine() method does, because this method is declared as abstract. However Car does not have to anything with method stopEngine(), it is inherited as a normal class does.

The End Guys.

Read More