Factory pattern in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new instance of the Product class using the factory method.

PHP

<?php
class Product {
    public function getName() {
        return "Product";
    }
}

class Factory {
    public static function create() {
        return new [1]();
    }
}

$product = Factory::create();
echo $product->getName();
?>

Drag options to blanks, or click blank then click option'

AFactory

Bcreate

Cnew

DProduct

Attempts:

3 left

💡 Hint

Common Mistakes

Using the factory class name instead of the product class name.

Forgetting to use the 'new' keyword before the class name.

The factory method returns a new instance of the Product class, so 'Product' is the correct class name to instantiate.

2fill in blank

medium

Complete the factory method to return a new instance of the correct class based on the type parameter.

PHP

<?php
interface Vehicle {
    public function drive();
}

class Car implements Vehicle {
    public function drive() {
        return "Driving a car";
    }
}

class Bike implements Vehicle {
    public function drive() {
        return "Riding a bike";
    }
}

class VehicleFactory {
    public static function createVehicle($type) {
        if ($type === '[1]') {
            return new Car();
        } elseif ($type === 'bike') {
            return new Bike();
        }
        return null;
    }
}

$vehicle = VehicleFactory::createVehicle('car');
echo $vehicle->drive();
?>

Drag options to blanks, or click blank then click option'

Acar

Bbike

Cvehicle

Ddrive

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'bike' instead of 'car' in the if condition.

Using the class name instead of the string type.

The factory method checks if the type is 'car' to create a Car instance, so the string 'car' is the correct value.

3fill in blank

hard

Fix the error in the factory method to correctly instantiate the requested product.

PHP

<?php
abstract class Button {
    abstract public function render();
}

class WindowsButton extends Button {
    public function render() {
        return "Render Windows button";
    }
}

class MacButton extends Button {
    public function render() {
        return "Render Mac button";
    }
}

class ButtonFactory {
    public static function createButton($os) {
        switch ($os) {
            case 'windows':
                return new [1]();
            case 'mac':
                return new MacButton();
            default:
                throw new Exception("Unsupported OS");
        }
    }
}

$button = ButtonFactory::createButton('windows');
echo $button->render();
?>

Drag options to blanks, or click blank then click option'

AButton

BMacButton

CWindowsButton

DButtonFactory

Attempts:

3 left

💡 Hint

Common Mistakes

Instantiating the abstract Button class.

Using the MacButton class for the windows case.

To create a Windows button, the factory must instantiate the WindowsButton class.

4fill in blank

hard

Fill both blanks to complete the factory method that creates different notification objects.

PHP

<?php
interface Notification {
    public function send();
}

class EmailNotification implements Notification {
    public function send() {
        return "Sending Email Notification";
    }
}

class SMSNotification implements Notification {
    public function send() {
        return "Sending SMS Notification";
    }
}

class NotificationFactory {
    public static function createNotification($method) {
        if ($method [1] 'email') {
            return new EmailNotification();
        } elseif ($method [2] 'sms') {
            return new SMSNotification();
        }
        return null;
    }
}

$notification = NotificationFactory::createNotification('email');
echo $notification->send();
?>

Drag options to blanks, or click blank then click option'

A===

B==

C!=

D<>

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same equality operator for both conditions.

Using inequality operators instead of equality.

The factory method uses strict equality (===) to check for 'email' and loose equality (==) to check for 'sms'.

5fill in blank

hard

Fill all three blanks to complete the factory method that creates shape objects and calls their draw method.

PHP

<?php
interface Shape {
    public function draw();
}

class Circle implements Shape {
    public function draw() {
        return "Drawing Circle";
    }
}

class Square implements Shape {
    public function draw() {
        return "Drawing Square";
    }
}

class ShapeFactory {
    public static function createShape($type) {
        return match($type) {
            'circle' => new [1](),
            'square' => new [2](),
            default => throw new Exception("Unknown shape"),
        };
    }
}

$shape = ShapeFactory::createShape('[3]');
echo $shape->draw();
?>

Drag options to blanks, or click blank then click option'

ACircle

BSquare

Ccircle

Dsquare

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up class names and string types.

Using the wrong string for the shape type.

The factory creates a Circle or Square object based on the type string 'circle' or 'square'.

Practice

1. What is the main purpose of the Factory Pattern in PHP?

easy

A. To create objects without exposing the creation logic to the client

B. To store data in a database

C. To handle user input validation

D. To perform mathematical calculations

Solution

1. Step 1: Understand the role of the Factory Pattern

   The Factory Pattern is designed to create objects while hiding the details of how they are created.

2. Step 2: Compare options with the pattern's purpose

   Only To create objects without exposing the creation logic to the client describes creating objects without exposing creation logic, which matches the Factory Pattern.

3. Final Answer:

   To create objects without exposing the creation logic to the client -> Option A

4. Quick Check:

   Factory Pattern = Object creation hiding [OK]

Hint: Factory pattern hides object creation details [OK]

Common Mistakes:

• Confusing factory pattern with database operations
• Thinking it handles input validation
• Assuming it performs calculations

2. Which of the following is the correct way to define a factory method in PHP?

easy

A. public static function create() {}

B. function create() {}

C. public function create() {}

D. private function create() {}

Solution

1. Step 1: Identify typical factory method signature

   Factory methods are often static so they can be called without creating an instance.

2. Step 2: Check options for static keyword

   Only public static function create() {} uses public static function create(), which is the common factory method style.

3. Final Answer:

   public static function create() {} -> Option A

4. Quick Check:

   Factory method is usually static [OK]

Hint: Factory methods are usually static for easy access [OK]

Common Mistakes:

• Omitting static keyword for factory methods
• Using private visibility which blocks access
• Not specifying visibility (defaults to public but less clear)

3. What will be the output of the following PHP code?

class Book { }
class ProductFactory {
    public static function create($type) {
        if ($type === 'Book') {
            return new Book();
        }
        return null;
    }
}
$product = ProductFactory::create('Book');
echo get_class($product);

medium

A. null

B. ProductFactory

C. Book

D. Error: Class not found

Solution

1. Step 1: Analyze the factory method call

   The call ProductFactory::create('Book') checks if the type is 'Book' and returns a new Book object.

2. Step 2: Check the output of get_class

   Since the returned object is an instance of Book, get_class($product) returns "Book".

3. Final Answer:

   Book -> Option C

4. Quick Check:

   Factory returns Book object, get_class = Book [OK]

Hint: Factory returns object; get_class shows its class name [OK]

Common Mistakes:

• Expecting factory class name instead of product class
• Assuming null is returned
• Thinking code throws error due to missing class

4. Identify the error in this factory pattern implementation:

class Car {}
class VehicleFactory {
    public static function create($type) {
        if ($type = 'Car') {
            return new Car();
        }
        return null;
    }
}

medium

A. Missing return type declaration

B. Using assignment (=) instead of comparison (==) in the if condition

C. Class Car is not defined

D. Factory method should not be static

Solution

1. Step 1: Check the if condition syntax

   The condition uses = which assigns 'Car' to $type instead of comparing it.

2. Step 2: Understand impact of assignment in condition

   Assignment always returns true, so the if block always runs regardless of input, which is a logic error.

3. Final Answer:

   Using assignment (=) instead of comparison (==) in the if condition -> Option B

4. Quick Check:

   Use == for comparison, not = [OK]

Hint: Use == for comparison, not = assignment in conditions [OK]

Common Mistakes:

• Confusing = and == in if statements
• Thinking static method is wrong here
• Assuming missing return type causes error

5. You want to extend a factory to create different types of vehicles: Car, Bike, and Truck. Which approach best follows the Factory Pattern principles in PHP?

hard

A. Create separate factory classes for CarFactory, BikeFactory, and TruckFactory each with their own create method

B. Use global functions to create Car, Bike, and Truck objects directly

C. Create one class Vehicle with properties to switch between Car, Bike, and Truck behaviors

D. Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input

Solution

1. Step 1: Understand the Factory Pattern goal

   The pattern centralizes object creation in one place, hiding details from the client.

2. Step 2: Evaluate options for best factory design

   Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input uses one factory class with a method that creates different vehicle objects based on input, which is the classic factory pattern.

3. Step 3: Compare other options

   Create separate factory classes for CarFactory, BikeFactory, and TruckFactory each with their own create method splits factories, which is more like Abstract Factory or multiple factories, not simple Factory Pattern. Create one class Vehicle with properties to switch between Car, Bike, and Truck behaviors mixes behaviors in one class, breaking single responsibility. Use global functions to create Car, Bike, and Truck objects directly uses global functions, which is not object-oriented.

4. Final Answer:

   Create a VehicleFactory with a static create method that returns new Car, Bike, or Truck objects based on input -> Option D

5. Quick Check:

   Single factory method creates varied objects [OK]

Hint: One factory method returns different objects by input [OK]

Common Mistakes:

• Splitting factories unnecessarily
• Mixing multiple behaviors in one class
• Using global functions instead of classes