PHP 5.6.0 released

extends sözcüğü

Çoğunlukla başka başka sınıflar içinde benzer değişkenler ve işlevler kullanmak gerekir. Aslında, belli projelerin ihtiyaçlarına göre uyarlanabilecek genel bir sınıf tanımınız olsa fena olmazdı. Bunu sağlamak için, sınıflar başka sınıfları genişleterek tanımlanabilir. Genişletilmiş veya türetilmiş sınıflar ana sınıfla ortak değişken ve işlevlere (aslında bunlar kalıtsal niteliklerdir) ek olarak kendi işlev ve değişkenleri olan sınıflardır. Miras alınan değişken ve işlevleri tanımsız yapmak mümkün değildir. Bir türetilmiş sınıf daima tek bir ana sınıfa bağımlıdır, yani çoklu kalıtım desteklenmemektedir. Sınıflar extends anahtar sözcüğü kullanılarak türetilirler.

<?php
class Sahipli_Sepet extends Sepet {
    var 
$sahibi;

    function 
sahip_ata ($isim) {
        
$this->sahibi $isim;
    }
}
?>

Bu örnekte, Sepet sınıfının tüm değişken ve işlevlerine ek olarak $sahibi değişkenine ve sahip_ata işlevine sahip Sahipli_Sepet sınıfı tanımlanmaktadır. Böylece sahipli bir sepet oluşturabilir ve sepetleri sahibine göre bir araya toplayabilirsiniz. Ayrıca, normal sepetin işlevlerini sahipli sepette de kullanabilirsiniz:

<?php
$ssepet 
= new Sahipli_Sepet// sahipli bir sepet oluşturalım
$ssepet->sahip_ata("enis");  // sepetin sahibi
print $ssepet->sahibi;       // sepet sahibinin ismini basar
$ssepet->mal_ekle("10"1);  // (işlevsellik Sepet sınıfının mirasıdır)
?>

Buna ebeveyn-çocuk ilişkisi de denir. İlk oluşturduğunuz sınıfa ebeveyn sınıf dersek, extends sözcüğünü kullanarak ondan türettiğiniz sınıflar çocuk sınıflar olur. Bu yeni çocuk sınıfları başka çocuk sınıfları (yani ilk sınıfın torunlarını) türetmek için kullanabilirsiniz.

Bilginize:

Sınıfların kullanılmadan önce tanımlanmış olmaları gerekir. Sahipli_Sepet sınıfını Sepet sınıfından türetmek için önce Sepet sınıfını tanımlamanız gerekir. Kurumsal_Sahipli_Sepet sınıfını Sahipli_Sepet sınıfından türetmek için de önce Sahipli_Sepet sınıfını tanımlamanız gerekir. Kısaca: Sınıfların tanımlanma sırası önemlidir.

add a note add a note

User Contributed Notes 21 notes

up
8
f4bi0_ at hotmail dot com
4 years ago
<?php
// what if we want to extend more then one class?

Abstract class ExtensionBridge
{
   
// array containing all the extended classes
   
private $_exts = array();
    public
$_this;
       
    function
__construct(){$_this = $this;}
   
    public function
addExt($object)
    {
       
$this->_exts[]=$object;
    }
   
    public function
__get($varname)
    {
        foreach(
$this->_exts as $ext)
        {
            if(
property_exists($ext,$varname))
            return
$ext->$varname;
        }
    }
   
    public function
__call($method,$args)
    {
        foreach(
$this->_exts as $ext)
        {
            if(
method_exists($ext,$method))
            return
call_user_method_array($method,$ext,$args);
        }
        throw new
Exception("This Method {$method} doesn't exists");
    }
   
   
}

class
Ext1{
private
$name="";
private
$id="";
public function
setID($id){$this->id = $id;}
public function
setName($name){$this->name = $name;}
public function
getID(){return $this->id;}
public function
getName(){return $this->name;}
}

class
Ext2{
private
$address="";
private
$country="";
public function
setAddress($address){$this->address = $address;}
public function
setCountry($country){$this->country = $country;}
public function
getAddress(){return $this->address;}
public function
getCountry(){return $this->country;}
}

class
Extender extends ExtensionBridge
{
    function
__construct()
    {
       
parent::addExt(new Ext1());
       
parent::addExt(new Ext2());
    }
   
    public function
__toString()
    {
        return
$this->getName().', from: '.$this->getCountry();
    }
}

$o = new Extender();
$o->setName("fabio");
$o->setCountry("brazil");
echo
$o;
?>
don't hesitate to email me, happy coding! ;)
up
4
bilalghouri at live dot com
3 years ago
One thing I figured out after a long time about extending a parent class that, if the child class does not have any construct function, it will use its parent's construct.

for example:

<?php
class Main
{
    public
$a;
   
    public function
__construct()
    {
        echo
'::Parent Class initiated::';
       
       
$this -> a = 'we are in the parent class';
    }
}

class
Child extends Main
{
    public function
getA()
    {
        return
$this -> a;
    }
}

$main = new Main();
$main -> child = new Child;

echo
$main -> child -> getA();

//Output - ::Parent Class initiated::::Parent Class initiated::we are in the parent class
?>

However, If we have a constructor in the child class as well:

<?php
class Child extends Main
{
    public function
__construct()
    {
       
    }
    public function
getA()
    {
        return
$this -> a;
    }
}
?>

Then :

<?php
$main
= new Main();
$main -> child = new Child;

echo
$main -> child -> getA();

// Output - ::Parent Class initiated::
?>

Note that the parent variable 'a' is not inherited by the child class if the constructor from the parent class isnt called.
This behaviour of extension made me waste a lot of my precious time, as I could not understand why some of my child classes were inheriting parent variables and some were not.
Hope this helps someone..
up
5
geilt at esotech dot org
2 years ago
I have found this the best way to grab a parents variables and such (that I love to set in the constructor, like standardized table names, etc.). I just call the parents constructor in the child constructor, then change variables inside the child constructor that needs to be customized for that class, or just leave it alone to make sure I understand I am using the parents constructor in the child constructor. (it's a good note and practice of mine.).

<?php
class MyParentClass
{
   
$this->table_one = "my_table";
   
$this->table_two = "variable_table";
}

class
MyChildClass extends MyParentClass
{
    public function
construct()
    {
       
parent::__construct();

       
$this->table_two = "newly_defined_table";

    }
    public function
action()
   {
     
$table1 = $this->table_one;
     
$table2 = $this->table_two;

      return
$table1 . " - " . $table2;
   }
}

$myChildClass = new MyChildClass;

echo
$myChildClass->action();

//Displays my_table - newly_defined_table
?>
up
2
"inerte" is my hotmail.com username
11 years ago
[Editor's note: For an alternative to multiple inheritance, see the dynamic binding via object aggregation in the corresponding section of the manual.]

Multiple Inheritance is not supported but it is easy to emulate it:

<?php
class multipleInheritance
{
    function
callClass($class_to_call)
    {
        return new
$class_to_call();
    }
}

class
A
{
    function
insideA()
    {
        echo
"I'm inside A!<br />";
    }
}

class
B
{

    function
insideB()
    {
        echo
"I'm inside B!<br />";
    }
}

class
C extends multipleInheritance
{
    function
insideC()
    {
       
$a = parent::callClass('A');
       
$a->insideA();
       
$b = parent::callClass('B');
       
$b->insideB();
    }
}

$c = new C();
$c->insideC();
?>

---
This will succesfully echo:
I'm inside A!
I'm inside B!
up
3
Edward_nl
8 years ago
If you are using a child-class. Remember to call the constructor of the parent class aswell before you start using it. Otherwise you might get different results then you expected. It is stated in this document, but I got confused by the given example. So, here is my example:

<?php
error_reporting
(E_ALL);

class
test {
  var
$var;

  function
test() {
   
$this->var = 3;
  }
}

class
testing extends test {
   function
testing() {
    
parent::test();
   }

   function
My_test() {
     return
$this->var;
   }
}

$p = new testing();
echo
$p->My_test();
// Returns 3
up
4
mazsolt at yahoo dot com
11 years ago
Just a simple example about inheritance:

<?php
class a1{
  var
$a=10;
  function
a1($a){
    
$this->a=$a;
  }
}

class
a2 extends a1{
  var
$x=11;
  function
a2($x,$y){
    
$this->x=$x;
    
parent::a1($y); // or a1::a1($y) or $this->a1($y)
 
}
}

class
a3 extends a2{
  var
$q=999;
}

$x=new a3(99,9);
echo
$x->a,"<br>",$x->x,"<br> ",$x->q;
?>

The output will be:

9
99
999
up
2
griffon9 at hotmail dot com
12 years ago
Just to clarify something about inheritance. The following code :

<?php
class a
{
     function
call()
     {
         
$this->toto();
     }
    
     function
toto()
     {
          echo(
'Toto of A');
     }
}
 
class
b extends a
{
     function
toto()
     {
          echo(
'Toto of B');
     }
}

$b=new b;
$b->call();

?>

...will correctly display "toto of B" (that is, the function declared in the parent is correctly calling the redefined function in the child)
up
1
volte6 at nowhere dot com
9 years ago
When declaring a class that relies upon another file ( because it extends the class defined in that file ), you should ALWAYS require_once() that file at the top.
This applies even when planning on looping through and including everything in the folder. Use require_once() in your loop, and at the top of the file that NEEDS the include.
up
2
admin at dmsoft-wy dot com
3 years ago
You don't need to include_once the parent class if it's already declared.  You do have to load the parent first and then the child.
up
1
calimero at creatixnet dot com
11 years ago
Just a quick note to make things more clear : while multiple inheritance is not allowed, several levels of single inheritance  ARE ALLOWED indeed. Just test this example :

<?php
class A {
    var
$name='A';

    function
disp() {
        echo
$this->name;
    }
}

class
B extends A {
    var
$name='B';
}

class
C extends B {
    var
$name='C';
}

$truc = new C() ;
$truc->disp(); // Will output C
?>

This is especially important to keep in mind while building a huge object hierarchy. for example :

+GenericObject
->+ Person
->->Employee
->+Computer
->->+WorkStation
->->-> PPC
->->-> Intel
->->+Server
->->->LDAPServer
->->->IntranetWebServer

.. and so on. Multiple level hierarchy relationship are possible in a tree-like structure (each child has one and only one parent, except for the root object).
up
2
datahell at elxis dot org
3 years ago
If you have a class that extends an other and both classes have a function with the same name then visibility to both classes should be the same, else you will have a fatal error.

An other interested part in the example bellow is that if visibility of the showName method is private then $this->name() will execute the showName method on class test. If it is public or protected it will execute method showName on class extendTest.

<?php
class test {

    public function
__construct() {
    }

    public function
name() {
       
$this->xname('John');
    }

    private function
showName($name) {
        echo
'my name in test is '.$name;
    }
}

class
extendTest extends test {

    public function
__construct() {
       
parent::__construct();
    }

    private function
showName($name) {
        echo
'my name in extendTest is '.$name;
    }
}

$test = new extendTest();
$test->name();
?>

result: my name in test is John

If we change visibility of the showName method to public or protected then the result of the above will be:
my name in extendTest is John
up
0
Frank
4 years ago
Just a quick example of how PHP will handle a parent calling a function named in both the parent and the child class.  You would think it might use the function the way it is defined in the parent, but it does use the function that is defined in the child.

<?php
class One{
    function
showOne(){
        echo
'Function One prints';
    }
    function
hitFunction(){
       
$this->showOne();
    }
}
class
Two extends One{
    function
showOne(){
        echo
'Function Two prints';
    }
}

$thistwo = new Two;
$thistwo->hitFunction(); //prints "Function Two prints"
?>
up
0
Bash I.
8 years ago
Here is a simple idea that I use when I need my abstract classes (the inherited classes) implemented before my functional classes.

<?php
   
    $_CLASSES
= array_merge (
       
glob ("classes/*/*.abstract.php"),
       
glob ("classes/*/*.class.php")
    );
   
    foreach (
$_CLASSES AS $_CLASS) {
        require (
$_CLASS);
    }
   
?>
up
0
tomnezvigin at comcast dot net
9 years ago
This may seem obvious, but check this scenario. You have a class folder:

+ class
--classA.php
--classB.php
--classC.php
--mainClass.php

Here... classA, classB, classC all extend the mainClass.

If you try to create a function that automatically includes all of the classes in a folder, normally, they are included alphabetically.

When you try to instantiate classC, for example, you will get an error:

"Cannot inherit from undefined class mainClass"

EVEN IF you instantiate the mainClass before you instantiate all of the other classes.

In other words, make sure your primary class is included before all others.
up
0
Msquared
9 years ago
Multiple inheritence is often more trouble than it's worth.  For example, you have a class foo that inherits from both class bar and class baz.  Classes bar and baz both have a fubar() method.  When you create a foo object and call its fubar() method, which fubar() method is called: bar's or baz's?

It seems to me that using aggregate to glue one class's methods and data to another object is a bit like Ruby's fixins, but I could be wrong...

[[Editor's note:
The aggregate_* functions have been dropped, as of PHP 5
-S
]]
up
0
efredin at redtempest dot com
10 years ago
It is possible to override a method innherited from a parent class by simply re-defining the method (for those of us who enjoy using abstract classes).

<?php
class A
{
    var
$foo;

    function
A()
    {
       
$this->foo = "asdf";
    }
   
    function
bar()
    {
        echo
$this->foo." : Running in A";
    }
}

class
B extends A
{
    function
bar()
    {
        echo
$this->foo." : Running in B";
    }
}

$myClass = new B;
$myClass->bar();
?>
up
0
quinton at free dot fr
11 years ago
a nice example using extends and multiple classes  and constructors.

<?php

class CoreObject {
  var
$name;
 
  function
CoreObject($name){
   
$this->_constructor($name);
  }
 
  function
_constructor($name){
   
$this->name = $name;
  }

  function
show(){
   
printf("%s::%s\n", $this->get_class(), $this->name);
  }
 
  function
get_class(){
      return
get_class($this);
  }
}

class
Container extends CoreObject{
var
$members;
function
Container($name){
  
$this->_constructor($name);
}

function &
add(&$ref){
  
$this->members[] = $ref;
   return (
$ref);
}

  function
show(){
  
parent::show();
   foreach(
$this->members as $item){
    
$item->show();
   }
}
function
apply(){
}
}

class
Person extends CoreObject{
  function
Person($name){
   
$this->_constructor($name);
  }
}

class
Family extends Container {

var
$members;
function
Family($name){
  
$this->_constructor($name);
}
}

echo
"<pre>\n";

$family = new Family('my family');
$family->add(new Person('father'));
$family->add(new Person('mother'));
$family->add(new Person('girl'));
$family->add(new Person('boy'));

$family->show();

print_r($family);

?>
up
0
schultz at rancon dot de
12 years ago
This prints out 'ab'.  No need to create a new instance of a, therefor both methods still exists with same name.

<?php

class a {
  function
samename(){
    echo
'a';
  }
}

class
b extends a{
  function
samename(){
    echo
'b';
  }
  function
b(){
   
a::samename();
   
b::samename();
  }
}

$test_obj = new b();
?>
up
0
php_AT_undeen_DOT_com
12 years ago
if the class B that extends class A does not have a constuctor function (i.e. a function named B), then the constructor function of A will be used instead, you don't need to make a constructor in B just to call the constructor of A.

For example:

<?php
class A
{
  function
A()
    {
      echo
"HEY! I'm A!\n";

    }
}

class
B extends A
{
}

$b = new B();
?>

produces the output:
HEY! I'm A!
up
0
bpotier at edreamers dot org
12 years ago
Just one thing that may seem obvious but not mentionned in this page is that you need to include/require the file containing the parent class or else you'll get an error:

<?php
require(dirname(__FILE__).'/'.'myParent.php');
// ...
myChild extends myParent {
 
// ...
}
// ...
?>
up
-1
alan hogan
8 years ago
Just a note:  It is possible to have a class inherit from multiple other classes, but only in a one-at-a-time linear hierarchy.

So this works, and C gets A and B functions:

<?php
class A {
  public function
af() { print 'a';}
  public function
bark() {print ' arf!';}
}
class
B extends A {
  public function
bf() { print 'b';}
}
class
C extends B {
  public function
cf() { print 'c';}
  public function
bark() {print ' ahem...'; parent::bark();}
}

$c = new C;
$c->af(); $c->bf(); $c->cf();
print
"<br />";
$c->bark();
/**results:**/
//abc
//ahem... arf!
?>

This does NOT work:

<?php
class A {
  public function
af() { print 'a';}
  public function
bark() {print ' arf!';}
}
class
B {
  public function
bf() { print 'b';}
}
class
C extends B, A /*illegal*/ {
  public function
cf() { print 'c';}
  public function
bark() {print ' ahem...'; parent::bark();}
}

$c = new C;
$c->af(); $c->bf(); $c->cf();
print
"<br />";
$c->bark();
//Parse Error
?>
To Top