Interface vs abstract class vs trait in PHP - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of using interface and abstract class methods

What will be the output of this PHP code?

PHP

<?php
interface Flyer {
    public function fly();
}
abstract class Bird {
    abstract public function sing();
    public function walk() {
        echo "Walking\n";
    }
}
class Sparrow extends Bird implements Flyer {
    public function fly() {
        echo "Flying\n";
    }
    public function sing() {
        echo "Singing\n";
    }
}
$sparrow = new Sparrow();
$sparrow->walk();
$sparrow->fly();
$sparrow->sing();
?>

A

Walking
Flying
Singing

B

Flying
Walking
Singing

C

Singing
Walking
Flying

D

Walking
Singing
Flying

💡 Hint

Remember the order of method calls in the code.

The code calls walk(), then fly(), then sing() in that order, so the output matches option A.

🧠 Conceptual

intermediate

Key difference between interface and abstract class

Which statement correctly describes a key difference between an interface and an abstract class in PHP?

A An interface can have method implementations, but an abstract class cannot.

B An abstract class can have properties and method implementations, but an interface cannot have properties or method implementations.

C An interface can have properties, but an abstract class cannot.

D Both interface and abstract class can be instantiated directly.

💡 Hint

Think about what you can put inside an abstract class versus an interface.

Abstract classes can have properties and method implementations. Interfaces cannot have properties or method implementations.

❓ Predict Output

advanced

Trait method conflict resolution output

What will be the output of this PHP code using traits with conflicting method names?

PHP

<?php
trait A {
    public function hello() {
        echo "Hello from A\n";
    }
}
trait B {
    public function hello() {
        echo "Hello from B\n";
    }
}
class MyClass {
    use A, B {
        B::hello insteadof A;
        A::hello as helloFromA;
    }
}
$obj = new MyClass();
$obj->hello();
$obj->helloFromA();
?>

A

Hello from B
Hello from B

B

Hello from A
Hello from B

C

Hello from A
Hello from A

D

Hello from B
Hello from A

💡 Hint

Look at which trait's method is used instead of the other and which is aliased.

The code uses B's hello() method instead of A's, but also aliases A's hello() as helloFromA. So calling hello() prints B's message, and helloFromA() prints A's message.

🔧 Debug

advanced

Identify the error in trait usage

What error will this PHP code produce?

PHP

<?php
trait Logger {
    public function log(string $msg) {
        echo $msg . "\n";
    }
}
class User {
    use Logger;
    public function log(int $msg) {
        echo "User log: " . $msg . "\n";
    }
}
$user = new User();
$user->log("Hello");
?>

A Output: Hello

B Output: User log: Hello

C Fatal error: Declaration of User::log(int $msg) must be compatible with Logger::log(string $msg)

D Fatal error: Trait method Logger::log has not been applied, because there is a collision with User::log

💡 Hint

Check method signatures when overriding trait methods.

The User class tries to override the trait method log() but changes the parameter type from string to int, which is incompatible and causes a fatal error.

🚀 Application

expert

Choosing the right structure for code reuse

You want to create reusable logging functionality that can be added to multiple unrelated classes without forcing them into a common parent class. Which PHP feature is best suited for this?

A Use a trait containing the logging methods and include it in all classes.

B Use an abstract class with the logging methods and extend it in all classes.

C Use a final class with static logging methods and call them from all classes.

D Use an interface declaring logging methods and implement it in all classes.

💡 Hint

Think about how to add the same code to many classes without inheritance.

Traits allow code reuse by including methods directly into classes without inheritance, making them ideal for adding logging to unrelated classes.