PHP Traits

PHP only supports single inheritance—a child class can inherit from only one parent. To overcome this limitation and allow developers to reuse methods freely across several independent classes, PHP introduced **Traits**.

What is a Trait?

A trait is a mechanism for code reuse in single inheritance languages. It is like a "mini-class" that contains methods you can "inject" into other classes. Traits are defined using the trait keyword.

<?php
    trait Message {
        public function msg1() {
            echo "OOP is fun! ";
        }
    }
?>

Using a Trait

To use a trait in a class, you use the use keyword inside the class body. Once used, all the methods of the trait become available in that class as if they were defined there.

<?php
    trait Welcome {
        public function sayHello() {
            echo "Hello World! ";
        }
    }

    class User {
        use Welcome;
    }

    $obj = new User();
    $obj->sayHello(); // Outputs: Hello World!
?>

Key Advantage: Traits allow you to share common functionality between classes that don't belong to the same inheritance hierarchy (e.g., both a User and a Post class might need a Logger trait).

Multiple Traits

A class can use more than one trait by listing them after the use keyword, separated by commas.

<?php
    trait Trait1 {
        public function msg1() { echo "Message 1 "; }
    }

    trait Trait2 {
        public function msg2() { echo "Message 2 "; }
    }

    class MyClass {
        use Trait1, Trait2;
    }

    $obj = new MyClass();
    $obj->msg1();
    $obj->msg2();
?>

Trait Precedence

When there are methods with the same name, PHP follows a specific order of priority (precedence):

Class Methods: Methods defined in the current class always have the highest priority.
Trait Methods: Trait methods override methods inherited from a parent class.
Inherited Methods: Methods from a parent class have the lowest priority.

Remember: Think of it as "The closer the definition is to the instance, the higher the priority."

Why Use Traits?

Horizontal Reuse: Reuse code across different classes without forced inheritance.
Avoid Bloated Parents: Prevent your parent classes from becoming "God classes" that contain too much logic.
Modularity: Group related methods into logical units (e.g., Timestampable, Sluggable).
Solves Single Inheritance: Mix and match behaviors from multiple sources easily.

Pro Tip: Traits can also contain properties and static methods, but they are most commonly used for groups of standard instance methods.

Summary

trait keyword defines a set of reusable methods.
use keyword imports the trait into a class.
Traits cannot be instantiated on their own.
A class can use multiple traits.
Traits help achieve horizontal code reuse.

« Previous Lesson Next Lesson »