类与对象(PHP 4)
在线手册:中文  英文

继承

通常需要这样一些类,这些类与其它现有的类拥有相同变量和函数。实际上,定义一个通用类用于所有的项目,并且不断丰富这个类以适应每个具体项目将是一个不错的练习。为了使这一点变得更加容易,类可以从其它的类中扩展出来。扩展或派生出来的类拥有其基类(这称为“继承”,只不过没人死)的所有变量和函数,并包含所有派生类中定义的部分。类中的元素不可能减少,就是说,不可以注销任何存在的函数或者变量。一个扩充类总是依赖一个单独的基类,也就是说,不支持多继承。使用关键字“extends”来扩展一个类。

<?php
class Named_Cart extends Cart {
    var 
$owner;

    function 
set_owner ($name) {
        
$this->owner $name;
    }
}
?>

上述示例定义了名为 Named_Cart 的类,该类拥有 Cart 类的所有变量和函数,加上附加的变量 $owner 和一个附加函数 set_owner()。现在,以正常的方式创建了一个有名字的购物车,并且可以设置并取得该购物车的主人。而正常的购物车类的函数依旧可以在有名字的购物车类中使用:

<?php
$ncart 
= new Named_Cart;    // 新建一个有名字的购物车
$ncart->set_owner("kris");  // 给该购物车命名
print $ncart->owner;        // 输出该购物车主人的名字
$ncart->add_item("10"1);  // (从购物车类中继承来的功能)
?>

这个也可以叫做“父-子”关系。创建一个类,父类,并使用 extends 来创建一个基于父类的新类:子类。甚至可以使用这个新的子类来创建另外一个基于这个子类的类。

Note:

类只有在定义后才可以使用!如果需要类 Named_Cart 继承类 Cart,必须首先定义 Cart 类。如果需要创建另一个基于 Named_Cart 类的 Yellow_named_cart 类,必须首先定义 Named_Cart 类。简捷的说:类定义的顺序是非常重要的。


类与对象(PHP 4)
在线手册:中文  英文

用户评论:

geilt at esotech dot org (2012-02-10 06:27:02)

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
?>

datahell at elxis dot org (2010-12-23 11:32:29)

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

admin at dmsoft-wy dot com (2010-09-27 17:46:46)

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.

bilalghouri at live dot com (2010-09-14 01:33:19)

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 -> '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..

f4bi0_ at hotmail dot com (2010-06-29 11:19:47)

<?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! ;)

Frank (2010-01-10 09:46:15)

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"
?>

Edward_nl (2006-03-03 02:54:48)

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

alan hogan (2005-11-26 17:48:15)

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 {
  public function 
af() { print 'a';}
  public function 
bark() {print ' arf!';}
}
class 
extends {
  public function 
bf() { print 'b';}
}
class 
extends {
  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 {
  public function 
af() { print 'a';}
  public function 
bark() {print ' arf!';}
}
class 
{
  public function 
bf() { print 'b';}
}
class 
extends B/*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
?>

Bash I. (2005-11-18 21:43:30)

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);
    }
    
?>

volte6 at nowhere dot com (2005-03-31 10:11:12)

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.

tomnezvigin at comcast dot net (2005-03-06 17:19:58)

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.

Msquared (2004-11-19 06:48:18)

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
]]

efredin at redtempest dot com (2004-03-02 17:35:11)

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 
extends A
{
    function 
bar()
    {
        echo 
$this->foo." : Running in B";
    }
}

$myClass = new B;
$myClass->bar();
?>

mazsolt at yahoo dot com (2003-07-04 08:49:36)

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: 


99
999

calimero at creatixnet dot com (2003-06-22 20:58:53)

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 {
    var 
$name='A';

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

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

class 
extends {
    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).

quinton at free dot fr (2003-06-10 13:07:10)

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);

?>

"inerte" is my hotmail.com username (2002-09-27 13:36:14)

[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 
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!

schultz at rancon dot de (2002-08-15 22:37:15)

This prints out 'ab'.  No need to create a new instance of a, therefor both methods still exists with same name.

<?php

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

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

$test_obj = new b();
?>

griffon9 at hotmail dot com (2002-07-18 04:42:37)

Just to clarify something about inheritance. The following code :

<?php
class a
{
     function 
call()
     {
          
$this->toto();
     }
     
     function 
toto()
     {
          echo(
'Toto of A');
     }
}
  
class 
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)

php_AT_undeen_DOT_com (2001-12-11 11:31:02)

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 
extends A
{
}

$b = new B();
?>

produces the output:
HEY! I'm A!

bpotier at edreamers dot org (2001-11-07 12:08:26)

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 {
  
// ...
}
// ...
?>

易百教程