Gain insights into object-oriented programming in PHP. Discover classes, objects, methods, inheritance, and more. Build dynamic server-side applications using OOP techniques and PHP database management.

php-lamp.tar.gz

php-db

php-db-challenge

php-composer

php-package-install

php-redirect

Object-oriented programming is perhaps the dominant development paradigm for leading languages including Java, C#, and Python. The rich class and inheritance framework wasn’t fully implemented in modern PHP until 2015, and best practices for object-oriented programming are still emerging.

This course is an introduction to object-oriented programming in PHP. You’ll start with the basics of the OOP paradigm and get familiar with classes, objects, methods, and properties. You’ll then chain methods and properties using the this keyword before working with access modifiers and magic methods. With these basics down, you’ll take a deep dive into object-oriented programming in PHP, including inheritance, abstraction, polymorphism, and namespaces. After exploring exception handling, you’ll use these object-oriented techniques to build, manage, and edit a PHP database.

By the end of this course, you’ll be prepared to build dynamic server-side applications using object-oriented programming in PHP.

Object-Oriented Programming in PHP

**Autoloading** allows us to use PHP classes without the need to `require` or `include` them and is considered a hallmark of modern programming.

# Autoloading Packagist code libraries

Previously, we saw that all it takes to autoload Packagist libraries is to add the following line (at the top of our scripts) that requires the Composer built-in autoloader:
```
require_once __DIR__ . '/vendor/autoload.php';
```
However, when we’re working with our own classes (or with non-Packagist classes), we may need to be somewhat more savvy.

**Composer autoloading** can work in two main ways—through direct autoloading of classes or through PHP Standard Recommendation (PSR) standards.

# Autoloading classes with the `composer`

The simplest way is to autoload each class separately. For this purpose, all we need to do is define the array of paths to the classes that we want to autoload in the `composer.json` file.
For example:

```
{ 
   "autoload": { 
      "classmap": [
           "path/to/FirstClass.php",
           "path/to/SecondClass.php"
      ] 
   } 
}
```

Update the `composer` autoloader from the command-line:

```
$ php composer.phar dump-autoload -o
```

Now, we have to include the autoloader at the top of our scripts (for example, index.php):

```
<?php
require "vendor/autoload.php";
```

We can autoload directories that contain classes in the same way that we autoload classes by using the `classmap` key of the `autoload`:

```
{ 
   "autoload": { 
      "classmap": [
           "path/to/FirstClass.php",
           "path/to/directory"
      ] 
   } 
}
```

To autoload directories, we need to use namespaces.

As we can see, `classmap` autoloading is not much different than the long list of `requires` that we used in older PHP scripts. A better way to autoload is by using the PSR-4 standard.

# Autoloading with PSR-4

**PSR-4** is the newest standard of autoloading in PHP. It compels us to use namespaces. We need to take the following steps in order to autoload our classes with PSR-4:

* Put the classes that we want to autoload in a dedicated directory. For example, it is customary to convene the classes that we write into a directory called `src/`.

* Give the classes a namespace. We must give all the classes in the `src/` directory the same namespace. For example, let’s give the namespace `Acme` to the classes. This is what the `Page` class is going to look like:


Learn about autoloading our own classes as well as other non-Packagist classes with the Composer autoloader.

Introduction

Classes and Objects

Using the $this Keyword for Chaining Methods and Properties

Access Modifiers

Magic Methods and Constants Unveiled

Inheritance in Object-oriented Programming

Abstract Classes and Interfaces

Polymorphism and Type Hinting

Static Methods & Properties and Traits

Namespaces & Dependency Injection

Exception Handling

PHP Database

Model-view-controller (MVC)

Conclusion

Appendix

Autoloading PHP Classes the Composer Way

Autoloading Packagist code libraries