Traits in PHP: What They Are & Examples

PHP introduced traits to solve a problem with code reuse. Before traits, developers used inheritance and interfaces to share functionality between classes. But, PHP only allows single inheritance, which means a class can extend only one other class.

In this article, we will cover the following topics:

• Understand what traits are in PHP.
• Learn how to use multiple traits in one class.
• Override methods from traits.
• See examples.

Let’s move on to the following section to understand what they are and how they work.

What Are Traits in PHP?

Traits in PHP are a way to reuse code in multiple classes. That doesn’t use inheritance. They allow you to define methods that can be shared across different classes.

A trait looks like a class but cannot be instantiated. Instead, classes use the use keyword to include a trait’s methods. This helps avoid code duplication and keeps class structures simple.

Here is a quick example:

trait Processor {
    public function process($task) {
        echo "Processing: $task";
    }
}

class CPU {
    use Processor;
}

$cpu = new CPU();
$cpu->process("Data calculation");

Output:

Processing: Data calculation

So, traits solve the problem of single inheritance, which allows classes to use methods based on multiple traits.

How to Define and Use Traits in PHP?

A trait is defined by the trait keyword, similar to a class but without the ability to be instantiated.

Here is an example:

trait Garden {
    public function build($message) {
        echo "View: $message";
    }
}

Here is how to use it. Just a class includes it with the use keyword.

class City {
    use Garden;
}

$city= new City();
$city->build("Perfect Beautiful Garden");

Let’s move on to the following section to understand how to use multiple traits in one class.

Multiple Traits in One Class

A class can include multiple traits and list them with the use keyword, separated by commas. This allows the class to reuse methods from different traits without inheritance.

Here is an example:

trait Computation {
    public function compute($task) {
        echo "Computing: $task";
    }
}

trait Optimization {
    public function optimize($process) {
        echo "Optimizing: $process";
    }
}

class Manipulate{
    use Computation, Optimization;
}

$manip= new Manipulate();
$manip->compute("Matrix multiplication");
$manip->optimize("Cache management");    

Here is the output:

Computing: Matrix multiplicationOptimizing: Cache management

In the following section, you will learn how to override methods from traits.

Overriding Methods From Traits

The class can override the trait’s methods by defining them in the class. The class method takes priority over the trait method.

For example:

trait Sound {
    public function makeSound($noise) {
        echo "Trait Sound: $noise";
    }
}

class Lion {
    use Sound;

    public function makeSound($noise) {
        echo "Class Sound: $noise";
    }
}

$lion = new Lion();
$lion->makeSound("Roar!"); 

Output:

Class Sound: Roar!

Here, the makeSound method in the Lion class replaces the one from the Sound trait.

But how can traits enforce method implementation?

Traits can require a class to implement specific methods. That defines abstract methods inside the trait. Any class using the trait must provide an implementation for these methods.

For example:

trait Sound {
    abstract public function getSoundPrefix(); // Must be implemented in the class

    public function makeSound($noise) {
        echo $this->getSoundPrefix() . ": " . $noise;
    }
}

class Parrot {
    use Sound;

    public function getSoundPrefix() {
        return "Parrot Sound";
    }
}

$parrot = new Parrot();
$parrot->makeSound("Squawk!"); 

Output:

Parrot Sound: Squawk!

Let’s take a look at the Trait constructor.

PHP Trait Constructor

Traits in PHP can include constructors, but they work differently than class constructors. If a trait has a constructor and a class using that trait also has a constructor, the class constructor takes priority.

For example:

trait Engine {
    public function start() {
        echo "Engine started.\n";
    }
}

class Vehicle {
    use Engine;

    public function __construct() {
        echo "Vehicle assembled.\n";
        $this->start(); // Calling trait method
    }
}

$car = new Vehicle();

Here is the output:

Vehicle assembled.
Engine started.

PHP Trait Properties

Traits can also contain properties, though they behave a bit differently from properties in classes. Property can be accessed by the class that uses the trait when you define it inside a trait.

Here’s a simple example of how to use properties in traits:

trait Fruits {
    // Defining a property for fruit attributes
    public $fruitAttribute = "Fruit properties not set.\n";

    public function describe() {
        echo $this->fruitAttribute;
    }
}

class Apple {
    use Fruits;

    public function __construct() {
        // Changing the fruit attribute value
        $this->fruitAttribute = "Apple is sweet and red.\n";
        $this->describe();
    }
}

$apple = new Apple();

Here is the output:

Apple is sweet and red.

In the following question, we will answer when you should use traits instead of inheritance.

When Should You Use Traits Instead of Inheritance in PHP?

Traits are helpful when you want to share methods across multiple classes. That can happen without the restrictions of single inheritance. Here’s when to consider using traits over inheritance:

• Traits allow you to reuse code even when classes do not share a common ancestor but need similar functions.
• Inheritance can lead to complex and deep hierarchies that are hard to maintain. Traits provide a simpler and more flexible way to reuse methods and keep the class structure shallow.
• Traits allow you to combine different functionalities from multiple sources. A class can use several traits to gain diverse behaviors, while inheritance only allows for a single base class.
• Traits help separate concerns. That organizes methods into smaller and reusable pieces. For example, a class can use a DatabaseTrait for DB operations and a LoggableTrait for logging. That does not need to mix them in a single parent class.

Wrapping Up

You learned in this article how PHP traits offer a great way to reuse code across multiple classes without the need for inheritance. Here’s a quick recap of what we covered:

• Traits allow you to share methods between classes. So you don’t need to create complex inheritance hierarchies.
• You define traits with the trait keyword, and classes include them with the use keyword.
• A class can use multiple traits to combine different functionalities. That keeps the class structure simple.
• A class can override a trait’s method if it has its own method with the same name.
• Traits are useful when you need to share functionality across unrelated classes. They also help avoid deep inheritance hierarchies.

FAQ’s

trait Computation {
    public function compute($task) {
        echo "Computing: $task";
    }
}

trait Optimization {
    public function optimize($process) {
        echo "Optimizing: $process";
    }
}

class Manipulate {
    use Computation, Optimization;
}

trait Sound {
    public function makeSound($noise) {
        echo "Trait Sound: $noise";
    }
}

class Lion {
    use Sound;
    public function makeSound($noise) {
        echo "Class Sound: $noise";
    }
}

trait Engine {
    public function start() {
        echo "Engine started.\n";
    }
}

class Vehicle {
    use Engine;
    public function __construct() {
        echo "Vehicle assembled.\n";
        $this->start();
    }
}