Skip to content
Advertisement

PHP Overriding methods rules

I just read from the book:
“In PHP 5, except for constructors, any derived class must use the same signature when overriding a method”
From the PHP manual in the comments:
“In the overriding, the method names and arguments (arg’s) must be same.
Example:
class P { public function getName(){} }
class C extends P{ public function getName(){} } “

So why I’m able to replace method with other arguments and their quantity? Is this legal or will trigger errors in the future or I’m just missing something?

PHP Version 5.5.11

class Pet {
    protected $_name;
    protected $_status = 'None';
    protected $_petLocation = 'who knows';

// Want to replace this function
    protected function playing($game = 'ball') {
        $this->_status = $this->_type . ' is playing ' . $game;
        return '<br>' . $this->_name . ' started to play a ' . $game;
    }

    public function getPetStatus() {
        return '<br>Status: ' . $this->_status;
    }
}


class Cat extends Pet {

    function __construct() {
        $this->_type = 'Cat';
        echo 'Test: The ' . $this->_type . ' was born ';
    }

// Replacing with this one    
    public function playing($gameType = 'chess', $location = 'backyard') {
        $this->_status = 'playing ' . $gameType . ' in the ' . $location;
        return '<br>' . $this->_type . ' started to play a ' . $gameType . ' in the ' . $location;
    }
}

$cat = new Cat('Billy');
echo $cat->getPetStatus();
echo $cat->playing();
echo $cat->getPetStatus();

This will output:

Test: The Cat was born
Status: None
Cat started to play a chess in the backyard
Status: playing chess in the backyard

Advertisement

Answer

The rule is that a method signature must be compatible with the method it overrides. Let’s look at the two methods in your hierarchy:

protected function playing($game = 'ball');

public function playing($gameType = 'chess', $location = 'backyard');

The changes:

  1. Visibility: protected -> public; increasing the visibility is compatible (the opposite will cause errors).

  2. Arguments: no change (same number of required arguments and maximum number of arguments)

User contributions licensed under: CC BY-SA
1 People found this is helpful
Advertisement