php学习笔记（三）面向对象高级实践 - 快车库

extends对象继承

PHP中类不允许同时继承多个父类，也就是extends后面只能跟一个父类名称，这个特性被称为PHP的单继承特性

当扩展一个类，子类就会继承父类所有公有的和受保护的方法。除非子类覆盖了父类的方法，被继承的方法都会保留其原有功能。

<?php

class foo
{
    public function printItem($string) 
    {
        echo 'Foo: ' . $string . PHP_EOL;
    }

    public function printPHP()
    {
        echo 'PHP is great.' . PHP_EOL;
    }
}

class bar extends foo
{
    public function printItem($string)
    {
        echo 'Bar: ' . $string . PHP_EOL;
    }
}

$foo = new foo();
$bar = new bar();
$foo->printItem('baz'); // Output: 'Foo: baz'
$foo->printPHP();       // Output: 'PHP is great' 
$bar->printItem('baz'); // Output: 'Bar: baz'
$bar->printPHP();       // Output: 'PHP is great'

?>

访问控制（可见性）

对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。

面向对象的三种访问权限：
——public共有的类成员，可以再任何地方被访问到

 - 定义该成员的类（自身），该类的子类，其他类

——protected受保护的类成员，可以被其自身和子类访问

——private私有的类成员，只有自身可以访问，子类和其他类都无法访问

class NbaPlayer 
{
    // 类的属性的定义
    public $team="Bull";
    public $playerNumber="23";

    private $age="40"; // private 类型的属性不能被对象外部访问，但是可以在对象内部使用

$jordan = new NbaPlayer("Jordan", "198cm", "98kg", "Bull", "23");
// 访问对象的属性使用的语法是->符号，后面跟着属性的名称
echo $jordan->age."\n";//Fatal error: Cannot access private property

Static（静态）关键字

声明类属性或方法为静态，就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

静态属性不可以由对象通过 -> 操作符来访问。

<?php
/**
 * 静态成员
 * 1. 静态属性用于保存类的公有数据
 * 2. 静态方法里面只能访问静态属性
 * 3. 静态成员不需要实例化对象就可以访问
 * 4. 类内部，可以通过self或者static关键字访问自身的静态成员
 * 5. 可以通过parent关键字访问父类的静态成员
 * 6. 可以通过类名称在外部访问类的静态成员
 */

class NbaPlayer
{
    // 类的属性的定义
    public $team="Bull";
    public $playerNumber="23";

    private $age="40";  

    public static $president="David Stern";

    public static function changePresident($newPrsdt){
        static::$president = $newPrsdt; // self用于表示当前类，"::"操作符用于访问类的静态成员
        // static关键字也可以用于访问当前类的静态成员
        // echo $this->age . "\n"; // 不能在静态方法中使用this伪变量，也不能用对象的->方式调用静态成员

    }
}   

// 类名加“::”可以访问类的静态成员
// 静态成员不需要实例化就可以访问
echo "The president is ". NbaPlayer::$president. "\n";//The president is David Stern 

NbaPlayer::changePresident("Adam Silver");

echo "The president is changed to ". NbaPlayer::$president. "\n";//The president is changed to Adam Silver

?>

Final 关键字

如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

属性不能被定义为 final，只有类和方法才能被定义为 final。

<?php

/**
 * 重写和Final
 * 1. 子类中编写跟父类完全一致的方法可以完成对父类方法的重写
 * 2. 对于不想被任何类继承的类可以在class之前添加final关键字
 * 3. 对于不想被子类重写（overwrite, 修改）的方法，可以在方法定义前面添加final关键字
 */

class BaseClass {
    public function test() {
         echo "BaseClass::test() called\n";//ChildClass::test called
    }
    public function test1(){
        echo "BaseClass::test1 called\n";
    }       
}
class ChildClass extends BaseClass{
    public function test(){
        echo "ChildClass::test called\n";
    }
}
$obj = new ChildClass();
$obj->test();
?>

对象接口

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

实现（implements)

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

实现多个接口时，接口中的方法不能有重名。

<?php

/**
 * 1. 实现了某个接口的类必须提供接口中定义的方法
 * 2. 不能用接口创建对象，但是能够判断某个对象是否实现了某个接口
 * 3. 接口可以继承接口（interface extends interface）
 * 4. 接口中定义的所有方法都必须是公有，这是接口的特性。
 */

interface ICanEat {
   public function eat($food);
}

// Human类实现了ICanEat接口
class Human implements ICanEat { 
  // 跟Animal类的实现是不同的
  public function eat($food){
    echo "Human eating " . $food . "\n";//Human eating Apple 
  }
}

// Animal类实现了ICanEat接口
class Animal implements ICanEat {
  public function eat($food){
    echo "Animal eating " . $food . "\n";//Animal eating Banana
  }
}

// step1 不同的类可以实现同一个接口，定义接口方法的不同实现
$man = new Human();
$man->eat("Apple");
$monkey = new Animal();
$monkey->eat("Banana")  

?>

抽象类

定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样。

抽象类前面以abstract关键字开始

<?php

/**
 * 抽象类
 * 1. 抽象类允许类里面的部分方法暂时没有具体实现，这些方法我们成为抽象方法
 * 2. 一旦类里面有抽象方法，这个类就必须是抽象类
 * 3. 抽象类跟接口一样，不能直接实例化为对象
 */

// 抽象类前面以abstract关键字开始
abstract class ACanEat {
   // 没有实现的方法需要设定为抽象方法
   // 抽象方法需要在子类中实现 
   abstract public function eat($food);

   public function breath(){
      echo "Breath use the air.\n";
   }
}

// Human类实现了ICanEat接口
class Human extends ACanEat { 
  // 跟Animal类的实现是不同的
  public function eat($food){
    echo "Human eating " . $food . "\n";
  }
}

// Animal类实现了ICanEat接口
class Animal extends ACanEat {
  public function eat($food){
    echo "Animal eating " . $food . "\n";
  }
}

$man = new Human();
$man->eat("Apple");
$man->breath(); // 和Animal共用了抽象类ICanEat的breath方法
$monkey = new Animal();
$monkey->eat("Banana");
$monkey->breath();

?>