Factory pattern in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this PHP factory pattern code?

Consider the following PHP code using a simple factory pattern. What will it print?

PHP

<?php
interface Animal {
    public function speak();
}

class Dog implements Animal {
    public function speak() {
        return "Woof!";
    }
}

class Cat implements Animal {
    public function speak() {
        return "Meow!";
    }
}

class AnimalFactory {
    public static function createAnimal(string $type): Animal {
        return match($type) {
            'dog' => new Dog(),
            'cat' => new Cat(),
            default => throw new Exception("Unknown animal type"),
        };
    }
}

try {
    $animal = AnimalFactory::createAnimal('dog');
    echo $animal->speak();
} catch (Exception $e) {
    echo $e->getMessage();
}
?>

A Meow!

B Woof!

C Unknown animal type

D Fatal error

💡 Hint

Look at which animal type is passed to the factory and what speak() returns for that animal.

The factory creates a Dog object because 'dog' is passed. Dog's speak() returns "Woof!" so that is printed.

❓ Predict Output

intermediate

What happens if an unknown type is passed to the factory?

What will be the output of this PHP code when the factory is called with 'bird'?

PHP

<?php
interface Animal {
    public function speak();
}

class Dog implements Animal {
    public function speak() {
        return "Woof!";
    }
}

class Cat implements Animal {
    public function speak() {
        return "Meow!";
    }
}

class AnimalFactory {
    public static function createAnimal(string $type): Animal {
        return match($type) {
            'dog' => new Dog(),
            'cat' => new Cat(),
            default => throw new Exception("Unknown animal type"),
        };
    }
}

try {
    $animal = AnimalFactory::createAnimal('bird');
    echo $animal->speak();
} catch (Exception $e) {
    echo $e->getMessage();
}
?>

A Unknown animal type

B Meow!

C Woof!

D Fatal error

💡 Hint

Check what the factory does when the type is not 'dog' or 'cat'.

The factory throws an Exception with message "Unknown animal type" when the type is not recognized. The catch block prints this message.

🔧 Debug

advanced

Why does this factory code cause a fatal error?

Look at this PHP code snippet. It tries to create an animal using the factory but causes a fatal error. What is the cause?

PHP

<?php
interface Animal {
    public function speak();
}

class Dog implements Animal {
    public function speak() {
        return "Woof!";
    }
}

class AnimalFactory {
    public static function createAnimal(string $type) {
        if ($type == 'dog') {
            return new Dog();
        }
        // Missing return for other types
    }
}

$animal = AnimalFactory::createAnimal('cat');
echo $animal->speak();
?>

A Syntax error: missing semicolon

B Outputs 'Woof!'

C Fatal error: Uncaught Error: Call to a member function speak() on null

D Exception thrown: Unknown animal type

💡 Hint

What happens if the factory method does not return anything?

If the factory method returns nothing (null), then $animal is null. Calling speak() on null causes a fatal error.

🧠 Conceptual

advanced

What is the main benefit of using the factory pattern here?

Given the PHP factory pattern example creating different Animal objects, what is the main advantage of using this pattern?

A It prevents any exceptions from being thrown

B It makes the code run faster by avoiding object creation

C It forces all animals to have the same speak() output

D It hides the creation logic and allows easy addition of new animal types without changing client code

💡 Hint

Think about how the client code uses the factory and what changes if new animals are added.

The factory pattern hides the creation details and lets you add new animal classes without modifying the code that uses them.

📝 Syntax

expert

Which option correctly implements a PHP factory method with typed return and exception handling?

Choose the correct PHP factory method code that returns an Animal instance or throws an Exception for unknown types.

A

public static function create(string $type): Animal {
    if ($type === 'dog') return new Dog();
    elseif ($type === 'cat') return new Cat();
    else throw new Exception('Unknown type');
}

B

public static function create(string $type): Animal {
    if ($type === 'dog') return new Dog();
    elseif ($type === 'cat') return new Cat();
    else return 'Unknown type';
}

C

public static function create(string $type) {
    if ($type === 'dog') return new Dog();
    elseif ($type === 'cat') return new Cat();
    else throw new Exception('Unknown type');
}

D

public static function create(string $type): Animal {
    switch ($type) {
        case 'dog': return new Dog();
        case 'cat': return new Cat();
        default: echo 'Unknown type';
    }
}

💡 Hint

Check the return type and how unknown types are handled.

Option A correctly declares the return type Animal and throws an Exception for unknown types. Others either return wrong types or do not declare return type.