what is the difference between extends and normal calling? - php

Question

What is the difference between two codes?
Extends;
<?php
require_once 'example.class.php';
Class First extends Example
{}
?>
Normal calling;
<?php
require_once 'example.class.php';
Class First
{
public $example;
function __construct()
{
$this->example = new Example();
}
}
?>
I know some difference for example using protected pharase.
But this is not enough in my opinion.

Answer 1

The first one, the object First will have the same properties/functions of Example class. Like:
class Example
{
public function a()
{
}
}
class First extends Example
{
public function b()
{
}
}
if you instance two objects $ex1, $ex2:
$ex1 = new Example();
$ex1->a(); // this is valid
$ex1->b(); // this is invalid because Example doesn't have "b" function
$ex2 = new First();
$ex2->a(); // this is valid
$ex2->b(); // this is valid too, because First inherits Example members + its own
on the second code, you're creating an instance of example so you must access that variable to be able to call Example method.
one better example:
class Person
{
public $name;
public function say($message)
{
echo $this->name . " says " . $message;
}
}
class Teacher extends Person
{
public function say($message)
{
// note that Teacher has a name even this is not declared here.
echo $this->name . " says " . $message;
}
public function teach($what)
{
// note that Teacher has a name even this is not declared here.
echo $this->name . " is teaching " . $what;
}
}
See the output:
$john = new Person();
$john->name = "John Doe";
$john->say("hello world!");
/*
$john->teach("Portuguese"); // invalid, person doesn't teach anything.
*/
$chuck = new Teacher();
$chuck->name = "Chuck Norris";
$chuck->say("hello universe!");
$chuck->teach("Fighting"); // valid because Teacher has method "teach"

Answer 2

Extends
This is object inheritance. First inherits Example members, so First is Example.
An instance of First can call a method of Example and one of itself.
Creating an instance of Example
This just creating an object of Example. First methods can use other objects in order to achieve its goals.
I believe you need to get more in touch with object-oriented programming in order to learn more about its concepts and you'll understand things like this.

Answer 3

In the first example, First extends Example so it has all its methods and properties.
In your second example you are just setting a property to be an object of the class Example. At least I assume that is what you want to do because the way you wrote it, $example is only defined in the scope of the constructor so it is never available anywhere.
I assume that for your second example you would want something like:
Class First
{
protected $example;
function __construct()
{
$this->example = new Example();
}
}

Answer 4

jeroen is correct, but it also determines which attributes of the Example class can be accessed from the First class. For example, if the Example class has 2 methods which are private or protected, and you don't extend, the First class will not be able to access them.
Consider the following:
class Example
{
public $foo;
protected $bar;
}
Class First extends Example
{
public function __construct()
{
$this->foo = 'FOO1'; // Works because public scope
$this->bar = 'BAR1'; // Works even though scope is protected, because we extended the class
}
}
Class Second
{
public example;
function __construct()
{
$this->example = new Example();
$this->example->foo = 'FOO1'; // Works because public scope
$this->example->bar = 'BAR2'; // Fails because protected scope and we did not extend the class
}
}
// However, from the calling code, I am also limited
$first = new First();
$first->foo = 'NEW_FOO1'; // Works because public scope
$first->bar = 'NEW_BAR1'; // Fails because protected scope
$second = new Second();
$second->example->foo = 'NEW_FOO2'; // Works because public scope
$second->example->bar = 'NEW_BAR2'; // Fails because protected scope