php中的类与对象(继承)

最新推荐文章于 2023-08-27 11:32:18 发布

pish7

最新推荐文章于 2023-08-27 11:32:18 发布

阅读量356

点赞数

分类专栏： PHP 文章标签： php

本文链接：https://blog.csdn.net/pish7/article/details/78759478

版权

PHP 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

简介

在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();    // 3
echo $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);   // myName
echo $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();  // A
B::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();  // A
B::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();

/*
B
SB
B
SB
***
*/

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();

/*
A
SA
A
SA
***
*/

这两种方式都可以用来调用本类方法，但在有类继承的情况下，两者会有不同的表现：

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();

/*
A
A
***
B
A
***
*/

可见，使用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();

/*
A
SA
***
*/

本例中，只有$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();

/*
B
A
SB
SA
***
C
B
SC
SB
***
*/

也可以直接使用类名来调用方法，结果是直接使用相应指定类的方法版本。后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用 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();
/*
A
B
B
***
A
C
C
***
*/