php-doc-en/language/oop5/decon.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
 <sect1 xml:id="language.oop5.decon" xmlns="http://docbook.org/ns/docbook">
  <title>Constructors and Destructors</title>

  <sect2 xml:id="language.oop5.decon.constructor">
   <title>Constructor</title>
   <methodsynopsis xml:id="object.construct">
    <type>void</type><methodname>__construct</methodname>
    <methodparam choice="opt"><type>mixed</type><parameter>args</parameter><initializer>""</initializer></methodparam>
    <methodparam choice="opt"><parameter>...</parameter></methodparam>
   </methodsynopsis>
   <para>
    PHP 5 allows developers to declare constructor methods for classes.
    Classes which have a constructor method call this method on each
    newly-created object, so it is suitable for any initialization that the
    object may need before it is used.
   </para>
   <note>
    <simpara>
     Parent constructors are not called implicitly if the child class defines
     a constructor.  In order to run a parent constructor, a call to
     <function>parent::__construct</function> within the child constructor is
     required. If the child does not define a constructor then it may be inherited
     from the parent class just like a normal class method (if it was not declared
     as private).
    </simpara>
   </note>
   <example>
    <title>using new unified constructors</title>
    <programlisting role="php">
<![CDATA[
<?php
class BaseClass {
   function __construct() {
       print "In BaseClass constructor\n";
   }
}

class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();
       print "In SubClass constructor\n";
   }
}

class OtherSubClass extends BaseClass {
    // inherits BaseClass's constructor
}

// In BaseClass constructor
$obj = new BaseClass();

// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();

// In BaseClass constructor
$obj = new OtherSubClass();
?> 
]]>
    </programlisting>
   </example>
   <para>
    For backwards compatibility, if a
    class did not inherit a <link linkend="object.construct">__construct()</link> from a parent class,
    either __construct() or the 
    old-style constructor function with the name of the class will be used as constructor function,
    whichever comes first.
    Effectively, it means that the only case that would have compatibility
    issues is if the class had a method named 
    <link linkend="object.construct">__construct()</link> which was used for different semantics,
    and which came lexically before the old-style constructor.
   </para>
   <para>
    Unlike with other methods, PHP will not generate an
    <constant>E_STRICT</constant> level error message when
    <link linkend="object.construct">__construct()</link> is overridden with different parameters
    than the parent <link linkend="object.construct">__construct()</link> method has.
   </para>
   <para>
    As of PHP 5.3.3, methods with the same name as the last element of a
    namespaced class name will no longer be treated as constructor. This
    change doesn't affect non-namespaced classes.
   </para>
   <example>
    <title>Constructors in namespaced classes</title>
    <programlisting role="php">
<![CDATA[
<?php
namespace Foo;
class Bar {
    public function Bar() {
        // treated as constructor in PHP 5.3.0-5.3.2
        // treated as regular method as of PHP 5.3.3
    }
}
?>
]]>
    </programlisting>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.decon.destructor">
   <title>Destructor</title>
   <methodsynopsis xml:id="object.destruct">
    <type>void</type><methodname>__destruct</methodname>
    <void />
   </methodsynopsis>
   <para>
    PHP 5 introduces a destructor concept similar to that of other
    object-oriented languages, such as C++. The destructor method will be
    called as soon as there are no other references to a particular object,
    or in any order during the shutdown sequence.
   </para>
   <example>
    <title>Destructor Example</title>
    <programlisting role="php">
<![CDATA[
<?php
class MyDestructableClass {
   function __construct() {
       print "In constructor\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "Destroying " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?> 
]]>
    </programlisting>
   </example>
   <para>
    Like constructors, parent destructors will not be called implicitly by
    the engine. In order to run a parent destructor, one would have to
    explicitly call <function>parent::__destruct</function> in the destructor
    body. Also like constructors, a child class may inherit the parent's
    destructor if it does not implement one itself.
   </para>
   <para>
    The destructor will be called even if script execution is stopped using
    <function>exit</function>. Calling <function>exit</function> in a destructor
    will prevent the remaining shutdown routines from executing.
   </para>
   <note>
    <para>
     Destructors called during the script shutdown have HTTP headers already
     sent. The working directory in the script shutdown phase can be different
     with some SAPIs (e.g. Apache).
    </para>
   </note>
   <note>
    <para>
     Attempting to throw an exception from a destructor (called in the time of
     script termination) causes a fatal error.
    </para>
   </note>
  </sect2>

 </sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->