|
Constructors are functions in a class that are
automatically called when you create a new instance of a
class with new. In PHP 3, a function
becomes a constructor when it has the same name as the class.
In PHP 4, a function becomes a constructor, when it has the
same name as the class it is defined in - the difference is
subtle, but crucial (see below).
// Works in PHP 3 and PHP 4. class Auto_Cart extends Cart { function Auto_Cart() { $this- add_item ("10", 1); } } |
This defines a class Auto_Cart that is a Cart plus a
constructor which initializes the cart with one item of
article number "10" each time a new Auto_Cart is being made
with "new". Constructors can take arguments and these
arguments can be optional, which makes them much more useful.
To be able to still use the class without parameters, all
parameters to constructors should be made optional by
providing default values.
// Works in PHP 3 and PHP 4. class Constructor_Cart extends Cart { function Constructor_Cart($item = "10", $num = 1) { $this- add_item ($item, $num); } } // Shop the same old boring stuff. $default_cart = new Constructor_Cart; // Shop for real... $different_cart = new Constructor_Cart("20", 17); |
You also can use the @ operator
to mute
errors occuring in the constructor, e.g.
@new.
|
class A { function A() { echo "I am the constructor of A. br \n"; } } class B extends A { function C() { echo "I am a regular function. br \n"; } } // no constructor is being called in PHP 3. $b = new B; |
In PHP 3, no constructor is being called in the above
example. The rule in PHP 3 is: 'A constructor is a function
of the same name as the class.'. The name of the class is B,
and there is no function called B() in class B. Nothing
happens.
This is fixed in PHP 4 by introducing another rule: If a
class has no constructor, the constructor of the base class
is being called, if it exists. The above example would have
printed 'I am the constructor of A. br ' in PHP 4.
class A { function A() { echo "I am the constructor of A. br \n"; } function B() { echo "I am a regular function named B in class A. br \n"; echo "I am not a constructor in A. br \n"; } } class B extends A { function C() { echo "I am a regular function. br \n"; } } // This will call B() as a constructor. $b = new B; |
In PHP 3, the function B() in class A will suddenly
become a constructor in class B, although it was never
intended to be. The rule in PHP 3 is: 'A constructor is a
function of the same name as the class.'. PHP 3 does not care
if the function is being defined in class B, or if it has
been inherited.
This is fixed in PHP 4 by modifying the rule to: 'A
constructor is a function of the same name as the class it is
being defined in.'. Thus in PHP 4, the class B would have no
constructor function of its own and the constructor of the
base class would have been called, printing 'I am the
constructor of A. br '.
|
注: There are no destructors in PHP 3 or PHP 4. You may use register_shutdown_function() instead to simulate most effects of destructors.
Destructors are functions that are called automatically
when an object is destroyed, either with unset() or
by simply going out of scope. There are no destructors in
PHP.