php中的类与对象(继承)
来源:互联网 发布:603881数据港股票 编辑:程序博客网 时间:2024/06/07 10:25
简介
在php中,类型的继承使用extends关键字,而且最多只能继承一个父类,php不支持多继承。
class MyClass { public $dat = 0; public function __construct($dat) { $this->dat = $dat; } public function getDat() { return "$this->dat\n"; }}class MySubClass extends MyClass{ public function getDat() { return "dat: $this->dat\n"; }}$a = new MyClass(3);$b = new MySubClass(4);echo $a->getDat(); // 3echo $b->getDat(); // dat: 4
方法覆盖
包括构造函数在内,子类可以重新定义同名的类方法以覆盖父类方法。覆盖时遵循以下规则:
1.除构造函数之外,其他函数在覆盖时,函数的参数列表必须相同
2.包括构造函数在内,方法被覆盖后,调用子类方法时并不会自动调用父类方法
3.如果父类要禁止方法被子类覆盖,可以使用final来声明方法,这时如果子类仍要覆盖父类方法,将会出错
class MyClass { private $name = ""; public $num = 0; public $str = ""; public function __construct($name) { $this->name = $name; $this->num = 100; $this->str = "none"; } public function getName() { return $this->name; }}class MySubClass extends MyClass{ public function __construct($name, $str) { parent::__construct($name); // 调用父类方法 $this->num = "0"; $this->str = $str; echo parent::getName()."\n"; // 调用父类方法 } public function getName() { return parent::getName()."$this->str\n"; // 调用父类方法 }}$b = new MySubClass("myName", true); // myNameecho $b->getName(); // myName1
class MyClass { final public function getName() { }}
属性重定义
在子类中,可以访问父类中的public和protected属性成员,除非重定义了同名的自有属性,这时,父类中的属性将无法访问。
方法则不同,子类对方法进行覆盖后,仍然可以访问到父类方法。
class MyClass { public $a = 1; protected $b = 2; private $c = 3; public function f1() { echo "MyClass f1\n"; echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; } protected function f2() { echo "MyClass f2\n"; echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; } private function f3() { echo "MyClass f3\n"; }}class MySubClass extends MyClass { public $b = 22; public $c = 33; public function f1() { echo "MySubClass f1\n"; // 继承到父类中的$a属性,直接使用 echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; // 调用父类中的同名方法 parent::f1(); // 继承到父类中的f2()方法,直接使用 $this->f2(); } // 父类的f3()是私有的,这里的定义与父类无关 public function f3() { echo "MySubClass f3\n"; }}$b = new MySubClass;$b->f1();echo "\n";/*MySubClass f1$a:1; $b:22; $c:33;MyClass f1$a:1; $b:22; $c:3;MyClass f2$a:1; $b:22; $c:3;*/$b->f3();echo "\n";/*MySubClass f3*/
重定义父类(同名)属性时,属性的可访问性可以变得更开放,但不能更严格,也就是说,父类中的public属性,不能在子类中修改为private属性。
如果通过子类对象调用父类方法,那么该父类方法在访问属性时,对于重定义了的同名属性,public和protected的属性将访问到子类版本,private属性将访问到父类版本。也可以理解为,public和protected属性可以被重定义(父类的版本被重定义,从而不存在了),而private并未被重定义(父类中的属性仍然存在,通过父类方法进行访问,与子类中是否有同名属性毫不相干)。
class MyClass { public $a = 1; protected $b = 2; private $c = 3; public function f1() { echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; }}class MySubClass extends MyClass { public $a = 11; // 必须为public protected $b = 22; // 必须为protected或public private $c = 33; public function f2() { echo "\$a:$this->a; \$b:$this->b; \$c:$this->c;\n"; }}$b = new MySubClass;$b->f1(); // $a:11; $b:22; $c:3;$b->f2(); // $a:11; $b:22; $c:33;
范围解析操作符 ::
又冒号常用于访问类常量、类静态变量,也用于在方法覆盖时调用父类版本。与其搭配的还包括parent、self、static等关键字。
class MyClass { const Name0 = "MyClass"; // 类常量 public static $id0 = 0; // 类变量 public function put() { // 将被子类覆盖的方法 echo "MyClass put()\n"; }}class MySubClass extends MyClass { const Name1 = "MySubClass"; public static $id1 = 1; public function put() { parent::put(); // 调用父类版本的对象方法 echo parent::Name0 . "\n"; // 父类常量 echo parent::$id0 . "\n"; // 父类变量 echo self::Name1."\n"; // 子类常量 echo self::$id1 . "\n"; // 子类变量 echo static::Name1 . "\n"; // 子类常理 echo static::$id1 . "\n"; // 子类变量 }}$a = "MyClass";$ca = new MyClass;$cb = new MySubClass;$cb->put();echo MyClass::Name0 . "\n";echo MyClass::$id0 . "\n";echo $a::Name0 . "\n";echo $a::$id0 . "\n";echo $ca::Name0 . "\n";echo $ca::$id0 . "\n";在子类中访问父类中的成员时,应避免直接使用父类类名,而应使用parent::,以免破坏父类的封装性。
final
声明为final的方法不能被子类覆盖,如果类声明为final,则此类不能被继承。
// 声明为final的类不能被继承final class MyClass{ private $dat; public function __construct($dat) { $this->dat = $dat; } // final方法不能被覆盖,不过此类已经是final类,方法无必要在声明为final了 final public function getDat() { return $this->dat; }}
后期静态绑定
使用 self:: 或者 __CLASS__ 对当前类的静态引用,取决于定义当前方法所在的类
class A{ public static function who() { echo "A\n"; } public static function test() { self::who(); }}class B extends A{ public static function who() { echo "B\n"; }}A::test(); // AB::test(); // A在本例中,对who()的调用使用了self::,那么不管是通过A还是B来调用test(),运行的都是A类版本的who()方法。如果换成static::,效果则不同:
class A{ public static function who() { echo "A\n"; } public static function test() { static::who(); }}class B extends A{ public static function who() { echo "B\n"; }}A::test(); // AB::test(); // B可见,这时通过B调用test()时,who()已经使用了B类中的版本,这就是后期绑定,也就是static:: 不再被解析为定义当前方法所在的类,而是在实际运行时计算。
$this与self::的相同与不同
class A{ public static function swho() { echo "SA\n"; } public function who() { echo "A\n"; } public function test() { $this->who(); $this->swho(); static::who(); static::swho(); echo "***\n"; }}class B extends A{ public static function swho() { echo "SB\n"; } public function who() { echo "B\n"; }}$b = new B;$b->test();/*BSBBSB****/
class A{ private static function swho() { echo "SA\n"; } private function who() { echo "A\n"; } public function test() { $this->who(); $this->swho(); static::who(); static::swho(); echo "***\n"; }}class B extends A{}$b = new B;$b->test();/*ASAASA****/
这两种方式都可以用来调用本类方法,但在有类继承的情况下,两者会有不同的表现:
class A{ public function who() { echo "A\n"; } public function test() { $this->who(); self::who(); echo "***\n"; }}class B extends A{ public function who() { echo "B\n"; }}$a = new A;$b = new B;$a->test();$b->test();/*AA***BA****/可见,使用selft::调用方法时,方法就绑定在定义此调用语句所在的类中。注意,本例中who()是公有方法,如果定义私有则结果又不同。由于私有方法不能被覆盖,所以如果将who()定义成私有方法,定义在A类中的test()方法只会使用A类中的who()方法。
class A{ private static function swho() { echo "SA\n"; } private function who() { echo "A\n"; } public function test() { $this->who(); $this->swho(); //static::who(); //static::swho(); echo "***\n"; }}class B extends A{ private static function swho() { echo "SC\n"; } private function who() { echo "C\n"; }}$b = new B;$b->test();/*ASA****/本例中,只有$this可以工作,而且使用的是A类版本的方法。static::则不能正常工作,因为B包含了自身版本的who()方法,但却是一个私有方法,无法从外部调用。
self:: 与 parent::
这两者都能容易地判别出调用的哪个类的方法,其中self::就是定义此调用语句的类本身,parent::则是定义此调用语句的类的父类。
class A{ public static function swho() { echo "SA\n"; } public function who() { echo "A\n"; }}class B extends A{ public static function swho() { echo "SB\n"; } public function who() { echo "B\n"; } public function testB() { self::who(); parent::who(); self::swho(); parent::swho(); echo "***\n"; }}class C extends B{ public static function swho() { echo "SC\n"; } public function who() { echo "C\n"; } public function testC() { self::who(); parent::who(); self::swho(); parent::swho(); echo "***\n"; }}$c = new C;$c->testB();$c->testC();/*BASBSA***CBSCSB****/
也可以直接使用类名来调用方法,结果是直接使用相应指定类的方法版本。后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面,如果静态调用使用 parent:: 或者 self:: 将转发调用信息。
class A{ public static function foo() { static::who(); } public static function who() { echo "A\n"; }}class B extends A{ public static function test() { A::foo(); parent::foo(); self::foo(); echo "***\n"; } public static function who() { echo "B\n"; }}class C extends B{ public static function who() { echo "C\n"; }}B::test();C::test();/*ABB***ACC****/
- php中的类与对象(继承)
- php中的类与对象(对象比较)
- 类与对象-继承
- PHP中的类与面向对象
- php中的类与对象(入门)
- php中的类与对象(遍历)
- java中的继承与对象的访问
- 面向对象中的继承与多态
- php中的类与对象(抽象、接口与特性)
- php中的类、对象
- 类和对象与继承
- 私有继承中的派生类对象与基类对象间的转换
- 68. PHP 对象继承
- php面向对象--继承
- PHP面向对象:继承
- Php内核中的类与对象相关用法详解
- php中的类与对象(魔术方法、克隆和重载)
- PHP基础----面向对象相关特性----12类的继承与方法重写
- 林正隆(coolfire)
- SpringBoot初体验(完整版)
- 函数方法之知道怎么用apply()和call()吗
- while 和 for 循环
- ArcGIS中Geodatabase简介
- php中的类与对象(继承)
- Python学习 第一天任务 (一)【基于Python编程从入门到实践】
- CoolHC Volume 1 By CoolFire
- spring boot shiro整合
- 电脑切换应用和软件分屏
- okhttp3封装 get post 请求 下载上传文件 Post请求发送JSON数据 判断下载目录是否存在......并返回绝对路径 从下载连接中解析出文件名
- [POJ](1088)滑雪 ---- 动态规划
- C# 读取 Geodatabase
- 程序关于调出键盘崩溃问题(系统为8.0的机器)