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 PHP 5 cannot find a 
    <link linkend="object.construct">__construct()</link> function for a given class, and the
    class did not inherit one from a parent class, it will
    search for the old-style constructor function, by the name of the class.
    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.
   </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
-->