Traits are for sharing common behavior across unrelated classes (e.g., User, Product, and Order can all Log), avoiding misuse of inheritance and overcoming PHP’s single-inheritance limitation.

When I first learned PHP Traits, my immediate reaction was:

“Why do we need Traits? Can’t inheritance already solve code reuse?”

It’s a reasonable question.

Most tutorials introduce Traits by saying:

“If multiple classes need the same code, put that code inside a Trait and use it.”

But inheritance already allows us to share code between classes, so why introduce an entirely new language feature?

The answer lies in understanding the difference between inheritance and horizontal code reuse.

Let’s explore.

What Inheritance Solves

Inheritance is designed to model an “is-a” relationship.

Consider this example:

class Animal
{
    public function eat()
    {
        echo "Eating...";
    }
}

class Dog extends Animal
{
}

class Cat extends Animal
{
}

This makes perfect sense because:

A Dog is an Animal
A Cat is an Animal

The child classes inherit behavior from their parent.

Now both Dog and Cat can use the eat() method:

$dog = new Dog();
$dog->eat();

$cat = new Cat();
$cat->eat();

This is exactly what inheritance was designed for.

The Problem With Using Inheritance Only For Code Reuse

Imagine we have several completely unrelated classes:

class User
{
}

class Product
{
}

class Order
{
}

Now suppose all of them need logging functionality.

A beginner might try something like this:

class Logger
{
    public function log($message)
    {
        echo $message;
    }
}

class User extends Logger
{
}

class Product extends Logger
{
}

class Order extends Logger
{
}

Technically, it works.

But conceptually, it is wrong.

Ask yourself:

Is a User a Logger?
Is a Product a Logger?
Is an Order a Logger?

Of course not.

We’re abusing inheritance simply because we want to reuse code.

The hierarchy no longer represents reality.

This is where Traits become useful.

Enter Traits

A Trait allows us to package reusable behavior and inject it into multiple classes.

trait LoggerTrait
{
    public function log($message)
    {
        echo $message;
    }
}

Now any class can use it:

class User
{
    use LoggerTrait;
}

class Product
{
    use LoggerTrait;
}

class Order
{
    use LoggerTrait;
}

Usage:

$user = new User();
$user->log("User created");

The important thing is that:

User remains a User
Product remains a Product
Order remains an Order

No fake inheritance hierarchy is created.

The Bigger Reason: PHP Supports Only Single Inheritance

One of the strongest reasons Traits exist is because PHP allows only one parent class.

For example:

class Animal
{
    public function eat()
    {
    }
}

class Dog extends Animal
{
}

This is valid.

But what if Dog also needs logging functionality?

You might think:

class Logger
{
    public function log()
    {
    }
}

class Dog extends Animal, Logger
{
}

Unfortunately, PHP does not support multiple inheritance.

A class can extend only one parent.

So Dog must choose:

class Dog extends Animal
{
}

class Dog extends Logger
{
}

It cannot inherit from both.

Traits solve this limitation.

trait LoggerTrait
{
    public function log()
    {
    }
}

class Dog extends Animal
{
    use LoggerTrait;
}

Now Dog gets:

eat() from Animal
log() from LoggerTrait

This is one of the primary motivations behind Traits.

Think of Traits as Abilities

A useful mental model is:

Inheritance describes what something is.

Traits describe what something can do.

Inheritance

Dog IS-A Animal
Cat IS-A Animal

Traits

Dog CAN Log
User CAN Log
Order CAN Log

The same capability can be added to completely unrelated classes.

This keeps your design cleaner and more flexible.

Using Multiple Traits

Another advantage is that a class can use multiple Traits.

Example:

trait LoggerTrait
{
    public function log()
    {
    }
}

trait Timestampable
{
    public function updateTimestamp()
    {
    }
}

trait SoftDelete
{
    public function delete()
    {
    }
}

A class can combine them:

class User
{
    use LoggerTrait;
    use Timestampable;
    use SoftDelete;
}

This gives the User class multiple reusable behaviors without creating complicated inheritance chains.

How Traits Work Internally

Many developers assume Traits are some special kind of object.

They are not.

Traits are closer to code inclusion.

Consider:

trait LoggerTrait
{
    public function log()
    {
        echo "Hello";
    }
}

class User
{
    use LoggerTrait;
}

PHP roughly treats it as if you had written:

class User
{
    public function log()
    {
        echo "Hello";
    }
}

The Trait’s methods are inserted into the class during compilation.

This is why Traits:

Are not parent classes
Are not objects
Cannot be instantiated directly

They are simply a mechanism for reusing methods.

Traits vs Inheritance vs Interfaces

A common source of confusion is deciding when to use each.

Let’s compare them.

Inheritance

Use inheritance when there is a genuine parent-child relationship.

Example:

class Animal
{
}

class Dog extends Animal
{
}

Dog truly is an Animal.

Interface

Use an interface when you want to define a contract.

Example:

interface Loggable
{
    public function log($message);
}

Every implementing class must provide its own implementation.

class User implements Loggable
{
    public function log($message)
    {
        echo $message;
    }
}

Interfaces define what must be done.

They do not provide implementation.

Trait

Use a Trait when multiple classes need the same implementation.

trait LoggerTrait
{
    public function log($message)
    {
        echo $message;
    }
}

Traits provide reusable code.

A Real-World Example

Many frameworks use Traits extensively.

Consider common features like:

Logging
Soft Deletes
Timestamp Handling
UUID Generation
API Token Management

These features may be needed by many unrelated classes.

Forcing all those classes into a single inheritance hierarchy would create poor design.

Traits allow these capabilities to be mixed in wherever needed.

Final Rule of Thumb

A simple guideline I follow is:

Use Inheritance

When there is a true “is-a” relationship.

Dog is an Animal
Car is a Vehicle

Use Interfaces

When classes must follow the same contract.

All payment gateways must implement processPayment()

Use Traits

When unrelated classes need the same implementation.

User can Log
Order can Log
Product can Log

Conclusion

Traits were not introduced because inheritance was insufficient for parent-child relationships.

Inheritance already handles that well.

Traits were introduced because developers often needed to share behavior across unrelated classes, and PHP’s single inheritance model made that difficult.

In short:

Inheritance models relationships.
Interfaces define contracts.
Traits share implementations.

If you remember only one thing, remember this:

Inheritance answers “What is this object?”

Traits answer “What abilities does this object have?”

That distinction explains why PHP Traits exist even though inheritance already provides code reuse.