|
|
 |
第 18章クラスとオブジェクト (PHP 4)
クラスは、変数およびこれらの変数で動作する関数の集まりです。
クラスは次のような構文により定義されます。
この例は、買い物カゴの中の物の連想配列と、買い物カゴにアイテムを加えたり
除いたりする二つの関数からなる Cart という名前のクラスを
定義します。
| 警告 |
複数のファイルや複数のPHPブロックで分割してクラスを定義定義することは
できません。以下の例は動作しません。
|
以下の注意書きはPHP 4に関するものです。
| 注意 |
名前stdClassは、Zendにより内部的に使用され、保
存されています。PHPでstdClassという名前のクラ
スを使用することはできません。
|
| 注意 |
関数__sleepおよび__wakeupは、
PHPクラス内で使用される特殊な関数です。これらの関数に付随する特殊
な機能を使用する場合以外は、クラス内でこれらの名前を付けた関数を
使用することはできません。詳細な情報については、以下を参照下さい。
|
| 注意 |
PHP は、__で始まる全ての関数名を特殊な関数として予約しています。
ドキュメントに記載された特殊関数の機能を使用する場合以外は、__を
有する関数名を使用しないことを推奨します。
|
PHP 4では、変数varについては定数による初期化の
みが可能です。定数以外で初期化を行う場合には初期化関数が必要です。
この初期化関数は、オブジェクトがクラスから構築される際に自動的に
コールされます。このような関数はコンストラクタと呼ばれます。(以下
参照)
クラスは型、つまり、実際の変数の雛型です。new演
算子により所望の型の変数を作成する必要があります。
この例は、クラスCartのオブジェクト$cartおよび
$another_cartを作成します。
$cartオブジェクトの関数 add_item()が商品番号10の商品一つが
カートに追加されています。商品番号0815の商品3つが$another_cart
に追加されています。
$cartと$another_cartは共に関数 add_item()、
remove_item() と変数items を有しています。これらは、異なる関数およ
び変数です。オブジェクトは、ファイルシステムのディレクトリに似たよ
うなものであると考えられます。ファイルシステムでは、別のディレクト
リに置く限り、二つの異なるREADME.TXTを保持することが可能です。ディ
レクトリではトップディレクトリから各ファイルにアクセスするには、フ
ルパス名を入力する必要がありますが、これと全く同様にコールしたい関
数の完全な名前を指定する必要があります。PHPの用語では、最上位のディ
レクトリはグローバル名前空間であり、パス名のセパレータは、->
となります。つまり、$cart->items と
$another_cart->items は、
二つの異なる変数です。$cart->itemsという名前の変数は、
$cart->$itemsではない、つまり、
PHPの変数名はドル記号を一つだけ
有することに注意して下さい。
クラス定義の内部では、プログラムでアクセス可能なオブジェクト名を知
ることはできません。Cartクラスが書かれている時点では、そのオブジェ
クトが後で$cartという名前となるか
$another_cartとなるかはわかり
ません。つまり、Cartクラスの中では$cart->itemsと書くことは
できないのです。代わりに、クラスの中からそのクラス内の関数や変数にア
クセスするために、疑似変数$thisを使用することが可能です。
$thisは、「自分自身の」または「カレントのオブジェクト」と
読み変えることができます。つまり、
'$this->items[$artnr] += $num' は、
「同じクラス内の配列 items の$artnrカウンタに
$numを追加する」または「カレントオブジェクト内の配列
items の $artnr カウンタに $num を
追加する」と読み変えることが可能です。
注意:
クラスとオブジェクトを処理する優れた関数がいくつかあります。
クラス/オブジェクト関数
をざっとみてみると良いでしょう。
 add a note
User Contributed Notes
クラスとオブジェクト (PHP 4)
alberto dot delatorre at gmail dot com
11-Feb-2005 11:11
If you have a class hierarchy as this:
<?php
abstract class A{
public function load(){
$this->_load();
}
protected abstract function _load();
}
class B extends A{
protected function _load(){
echo "loaded";
}
}
$b = new B();
$b->load();
?>
you encountered that you will have a 'calling an abstract method' in the line with '$this->_load'. To avoid this, just make another reference to $this and then call the method you'd want, this way:
<?php
abstract class A{
public function load(){
$aux_this=&$this;
$aux_this->_load();
}
protected abstract function _load();
}
class B extends A{
protected function _load(){
echo "loaded";
}
}
$b = new B();
$b->load();
?>
arjini at gmail dot com
04-Feb-2005 09:56
Didn't see this anywhere obvious, so I'm posting it here. To access a memeber of an array with another variable you use $arr[$name]
To access a class method or property, you use $obj->{$name} You can also use the return value of a function.
<?php
class Test {
function methodName(){
echo 'works!';
}
}
function getName(){
return 'methodName';
}
$t = new Test();
$t->{getName()}();
?>
spam at modem-help dot com
23-Jan-2005 05:32
Although the php 4.2.2 parser and variable storage are case-sensitive, classes + class-function + function declaration *storage* are not.
To example this, consider the following:
[note: constructor is `sendfile()', not `SendFile()' nor `sendFile()']
<?php
class SendFile {
function SendFile() {
}
function sendFile() {
}
function sendfile() {
}
} ?>
This was eventually illuminated by:
<?php
print_r( get_declared_classes());
?>
...in which a snippet of the result is:
Array
(
[0] => stdClass
[1] => __PHP_Incomplete_Class
[2] => Directory
[3] => DomNode
[4] => DomDocument
[5] => DomParser
...
[24] => sendfile
)
Specifically, it appears that php has used initial-caps for all of it`s own (internal) classes, but that all user-classes are stored lower-cased, as are class + ordinary functions.
Written in the hope of saving someone else time & grief from this interesting `feature'.
rdc_uk
22-Jan-2005 04:44
Just found this interesting "gotcha";
If you implement a class with no member variables, calling the constructor does NOT produce an object. This can be a source of (great) consternation when producing classes which need no data storage.
Essentially if your class has no data members, all its methods are ONLY available statically, this can be a pain if defining object hierarchies with abstract base classes...
Example:
class A
{
function A()
{
$i = 0; // not an empty constructor!
}
function fn()
{
return "A";
}
}
$obj_a = new A();
$obj_a == null
$obj_a->fn(); will generate an error
A::fn(); works
Simply putting a "var $status=0;" in the class suddenly makes your object instantiatable.
This is certainly a "quirk" in an OO implementation, possibly a bug, definitely worth watching out for...
php dot net at mechintosh dot com
05-Dec-2004 11:52
While it is possible to use the names of existing PHP functions for class method names (not that you *should*, however sometimes there's really only one good name for a method even if it's taken..), you cannot use the names of language constructs like list(), echo, print etc, and appearantly also not of eval().
But you probably shouldn't be using PHP functionnames anyway :-)
email at richardlee dot info
05-Sep-2004 05:11
An example of how to pass an object back into its own class for direct use.
(thisClass.php)
<?php
class thisClass{
var $var1;
function thisClass($value)
{$this->var1 = $value;}
function set_var1($value)
{$this->var1 = $value;}
function get_var1()
{return $this->var1;}
function showVar()
{echo "<p>var1 = ".$this->var1."</p>";}
function callShowVar($object)
{$object->showVar();}
function copyObject($object)
{$this->var1 = $object->get_var1();}
}
?>
(test.php)
<?php
require_once('class.php');
$thisObject = new thisClass(3);
$thatObject = new thisClass(1);
$thatObject->callShowVar($thisObject); $thisObject->showVar(); $thatObject->showVar(); $thatObject->copyObject($thisObject);
$thatObject->showVar(); ?>
babs at sntteam dot org
31-Aug-2004 02:22
We can't split the class declaration in multiple PHP section but we can exit php tag in a function . ex :
<?
class plop {
function plop() {
$this->whatever = "bar";
}
function foo() {
?>
<pre>foo returns <?=$this->whatever?></pre>
<?
}
};
$a = new plop;
$a->foo();
?>
will print : foo returns bar
PHP Version 4.3.8-9
bishop
20-Jul-2004 01:04
Say you have a factory method that needs to put data into an object before the constructor is called. This might be necessary, for example, if the factory class establishes a connection to a database and the manufactured object uses that connection in the constructor.
Do something like this:
<?php
function &factory($class ) {
$obj = new stdClass();
$tmp = explode(':', serialize($obj));
$tmp[1] = strlen($class);
$tmp[2] = '"' . $class . '"';
$obj = unserialize(implode(':', $tmp));
$obj->copyFrom($this);
$args = func_get_args();
array_shift($args); call_user_func_array(array (&$obj, $class), $args);
return $obj;
}
?>
NOTE: The Editor's note in the "simon dot li at hongkong dot com" entry is misleading; it only works because the class names "foo" and "bar" are the same length. In general, you must change the first and second entries in serialized array as done above.
Also NOTE: This typecasting business works if you have a function that takes an arbitrary number of arguments and you want to pass those arbitrary arguments into a constructed class. You can't just use call_user_func_array() in that case because 'new' is an operator, not a function.
catalin dot ivan at utoronto dot ca
06-Jul-2004 10:50
Regarding defining class variables:
The 'var' statement can NOT take Heredoc definitions, i.e. the "<<<MARKER" stuff (these may be somehow 'dynamic' as per warning above).
You must assign them values within the class constructor if you must use Heredoc.
oran at anonimous dot biu dot ac dot il
16-Jun-2003 05:34
class baseclass {
function static1() {return "bla";}
function static2() {return call_user_func(array(__CLASS__,'static1'));}
}
[ Editor's Note: Using the above, rather than below, will allow the static function to call its own generation's version of the method. ]
Unfortunately, inheritance of static methods is a bit problematic in PHP, because in order to use a static method you have to know the exact class it's defined in. This means trouble if you want to use one static function (or a static variable) from within another static function. For example:
class baseclass {
function static1() {return "bla";}
function static2() {return baseclass::static1();}
}
Now suppose that you write a class newclass that extends baseclass and redefines static1() to return "foo" instead of "bla" - this change will not be reflected in static2() of newclass. Not good at all.
You could use $this->static1() instead of baseclass::static1() in the definition of static2(), but then static2() will not be a static method. Another idea is to use get_class_name() to get the class name inside static2(), but again you need the $this variable to make this function call.
I found no way to overcome this problem, except to use real functions (not methods) for the purpose of wrapping my static functions. The name of the exact class to use is passed as a parameter to the wrapping function. It looks like this:
function wrapped_static1($clname) {
if (in_array('static1', get_class_methods($clname)))
return $clname::static1();
return baseclass::static1();
}
function wrapped_static2($clname) {
if (in_array('static2', get_class_methods($clname)))
return $clname::static2();
return baseclass::static2();
}
class baseclass {
function static1() {return "bla";}
function static2() {return wrapped_static1('baseclass');}
}
Now you can go on using baseclass and writing extension classes for it, using the following rules:
1. Use inheritance with your static functions in the natural way, as you would in C++. The wrapping code given here supports just 1 level of inheritance, but it may be improved to work its way up the inheritance tree using PHP's class functions.
2. When calling a static function, always call it through its wrapper.
For example:
class newclass extends baseclass // example for rule 1
{
function static1() {return 'foo';}
}
print static2_wrapper('newclass'); // example for rule 2
This is a little cumbersome, but now when you redefine a static function, you can be sure that any functions that rely on it will be able to use the correct definition.
russ dot taylor at nifty dot com
18-Apr-2003 08:31
It is sometimes useful to register a class instance as a session variable. This can allow classes and their contained values to persist across multiple pages and/or frames. Frames which need to use the registered class must be loaded (or reloaded) after the class instance is registered and the class declaration must be included in each file that needs to access the registered class.
i.e.
<?
session_start();class foo{var $bar;
function foo(){$this->bar = "a value to share and persist";
}
}
$vital = new foo;session_register("vital");?>
**NOTE: it would be helpful to include the class from an external source so the same declaration could be used everywhere its needed, duh
then simply include the class declaration in any other file and you will have access to the registered class instance. in a separate frame on the same page you could use ...
<?
session_start();
class foo{var $bar;
function foo(){$this->bar = "a value to share and persist";
}
}
echo $vital->bar;
?>
**NOTE: if you use a frameset you must allow processing time of the session registration or the value will not be available! You can use any number of methods to trigger the delay, but the session must NOT be started on the second page beforre the variable is registered on the first. On option is to use an onload statement in the first frames body tag, assuming normal html output...
<html><head></head><body onLoad="parent.frame[1].location.reload();"><!--what ever else you need to output--></body></html>
"frame[1]" assumes a two frame layout with frame[0] containing the values to share and frame[1] requiring those values. thus this, when included in frame[0] will force a reload of frame[1] AFTER the class instance was registered.
mcoakley at netplay dot net
18-Jan-2003 04:47
In response to the comments above and using tomcats example directly... I love scripting languages and I love PHP the most out of them. While most programmers (and editors notes) try to state that PHP is not a true OO language it has what you need to develop good OO programs. Sure some of the really strong structured things aren't there but that is the fun you get with scripted languages. But after reading every comment on this page I think people (and I know I am going to get flamed for this one...) should start to fully understand the principles of OO programming: Encapsulation, Polymorphism and Abstraction.
For those new to those terms:
- Encapsulation is what you get when you can have data and the methods that act on those data in an "encapsulated" entity (object)
- Polymorphism is a property of objects that comes through inheritence that allows methods of the same name to perform different (but similar in purpose) actions
- Abstration provides a mechanism to design effective OO heirarchies by pulling common methods or actions into superclasses and using inheritence to provide functionality
If these principles are understood fully, PHP can be used as a great OO language. Another common complaint is that PHP doesn't offer private/protected members/methods, I too would like to see these features. One BIG thing to keep in mind while desiging an OO program is that the objects should provide funtionality at the class level. Don't think of objects as individual entities but think of a heirarchy that provides "blackboxes" of code. In otherwords the class names should tell you what the object does and the methods only tell you how to invoke the functionality. You should never be concerned with how the object achieves its functionality.
b dot ruecker at portunity dot de
08-Jul-2001 04:22
If you need a destructor, perhaps it is an idear to simulate it this way with a global Destroy-Function:
<?
function DestroyObject ($name)
{
$theobject = &$GLOBALS[$name];
if (method_exists ($theobject,"Destroy"))
$theobject->Destroy ();
unset ($GLOBALS[$name]);
}
class xyz
{
var $somevar;
function xyz ()
{
}
function Destroy ()
{
echo ("Now we destroy it !");
}
function SomeDo ()
{
echo ("doing something: ".$this->somevar);
}
}
$example = new xyz;
$example->somevar = 3;
$example->SomeDo();
DestroyObject ("example");
$example->SomeDo ();
?>
sgarner at expio dot co dot nz
19-Feb-2001 02:15
[Editor's note: Remember tha PHP is not a hard core OOP language, and even the ones that are do not always support the unusual vector/array references applied to results from methods.]
It seems there is no way to access the return value of a method (or any function) inline, without assigning it to a variable.
For example:
<?php
class Test
{
function blah ()
{
return array(1,2,3);
}
function childTest ()
{
return new Test;
}
}
$test = new Test;
$foo = $test->blah()[0];
$temp = $test->blah();
$foo = $temp[0];
$foo = $test->childTest()->blah();
$temp = $test->childTest();
$foo = $temp->blah();
?>
buzz77 at gmx dot net
14-Feb-2001 04:33
You can also store object variables as session variables, so that you don't have to create an object every time the page loads.
Let's see how:
here is my simple class file:
// simple.lib.php
class simple
{
function dummy
{
print "TEST SUCCESSFUL!\n";
}
}
Then, I create a simple .php which starts a new session and registers the object-variable of the "simple"-class.
// test1.php
require ("simple.lib.php");
session_start();
session_register("CLASSOBJ");
$CLASSOBJ=new simple();
That's all.
In the following .php-files you've only to add the following lines:
require("simple.lib.php");
session_start();
To test out if it works, simply call:
$CLASSOBJ->dummy();
and it will print the message.
I tried it out also with quite huge classes, and it always worked (I think the pointer to the instanciated class is stored and the class object itself won't be deleted if you eg. change to another .php-page)
brice at webprojkt dot com
22-Dec-2000 05:23
Defaulting a function parameter to a variable isn't directly supported, but here's how to get around that:
Suppose you have a class:
class query {
var $sql;
var $link;
function go ($SQLstring = $this->sql)
{
return mysql_query($this->sql,$link);
}
}
This doesn't work. Here's the workaround:
(function spec):
function go ($SQLstring)
{
if (isset($SQLstring)) { $this->sql = $SQLstring; }
return mysql_query($this->sql,$this->link);
}
This may not be the best example of this, but I thought I'd throw this out for you folks ... should allow support of presetting of an object value and then execution of the method on that, or something like query::go("SELECT ...");
Enjoy!
p.s. (in this case query::go wouldn't work because it is coded with $this->link, but if you wanted to just use the default connection, it'd work fine :)
iw at warped dot nu
09-Oct-2000 12:12
Here's a very important reminder to those of you used to Java/C++ object references/pointers. When you send a function arguments which include a class object, PHP will make copies of that object for use inside that function.
This differs from passing a Java reference to an object or passing a C++ pointer to an object. Within the scope of the above-mentioned function, calling class methods of the argument object will only affect the copy that PHP creates. Likewise, when the function itself is completed, the copy of the object you passed ceases to exist.
To emulate Java/C++ functionality of arguments that are objects, you just have to modify the given function's signature from this:
function foo(..., $object, ...)
to this:
function foo(..., &$object, ...)
The ampersand(&) thus signifies that the function should receive a reference to the object, instead of creating a copy of the object.
simon dot li at hongkong dot com
13-Sep-2000 11:15
-------------------------------------------------
[Editor's note: class casting per se is not part of the object/class implementation in PHP, but code like the one in this note can kludge if you need it for very simple cases, more complex ones are left to the imagination of the programmer:
<?php
class foo {
function foo($name="foo") {
$this->name=$name;
}
}
class bar extends foo {
function boom() {
echo "BOOOM!";
}
}
$f = new foo();
$temp = explode(":",serialize($f));
$temp[2] = "\"bar\"";
$b = unserialize(implode(":",$temp));
$b->boom();
?>
This forces $b to be an instance of "bar" using an object $f, an instance of "foo"]
-------------------------------------------------
About casting of object, say, i got:
class A extends B {
function A() {
$this->B();
}
....
}
$b = new B();
$a = new A();
I wanna have a object of class A with "content" of $b:
$a = (A) $b; // not a valid code,(right?) as for illustration.
| |
内部（ビルトイン）関数
