高级OOP特性

Posted 2020-10-30 xiukang

PHP不支持的高级OPP特性

 php不支持通过函数重载实现多态

PHP不支持多重继承

PHP不支持根据所修改数据类型为操作符赋予新的含义

对象克隆

• 克隆实例

 在对象前面添加clone关键字来克隆对象，对象的属性值都被继承，克隆的对象还可以重新为原对象赋值

class xiu {
    private $name;
    //为$name定义一个设置方法和获取方法
    function getName(){
        return $this -> name;
    }
    function setName($name){
        $this -> name = $name;
    }
}
$xiu = new xiu();
$xiu -> setName("user");
//用clone克隆$xiu对象
$xiu2 = clone $xiu;
$xiu2 -> setName("kang");
echo $xiu -> getName();//输出user
echo $xiu2 -> getName();//输出kang

• __clone()方法

 __clone()方法在克隆操作其中执行

class xiu {
    private $name;
    //为$name定义一个设置方法和获取方法
    function getName(){
        return $this -> name;
    }
    function setName($name){
        $this -> name = $name;
    }
    function __clone() {
        $this -> name = "sear";
    }
}
$xiu = new xiu();
$xiu -> setName("user");
//用clone克隆$xiu对象
$xiu2 = clone $xiu;
echo $xiu -> getName();//输出user
echo $xiu2 -> getName();//输出sear

继承

• 类继承

 类继承通过关键字extends实现

下面的列子是kang类继承xiu类，所以kang类的对象具有xiu类的所有成员和方法

<?php
    class xiu {
        private $name;
        function setName($name) {
            $this -> name = $name;
        }
        function getName(){
            return $this -> name;
        }
    }
    class kang extends xiu {
        function getKang() {
            echo "kang方法";
        }
    }
    $kang = new kang();
    $kang -> setName("修抗");
    echo $kang -> getName();//输出修抗
    $kang -> getKang();//输出kang方法
?>

下面的列子是kang类继承了xiu类，ceo类继承了kang类

所以knag对象拥有xiu类的成员和方法，而ceo对象拥有kang类和xiu类的成员和方法

<?php
    class xiu {}
    class kang extends xiu {}
    class ceo extends kang {}
?>

• 继承和构造函数

 如果父类有构造函数，而子类没有构造函数，那么子类实例化的时候会执行父类的构造函数

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {

    }
    $kang = new kang();//输出"执行父类构造函数"
?>

但如果子类也有构造函数，那不管父类有没有构造函数，只会执行子类的构造函数

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {
        function __construct(){
            echo "执行子类构造函数";
        }
    }
    $kang = new kang();//输出"执行子类构造函数"
?>

同时执行父类和子类的构造函数，需要添加 parent::__construct()（如果父类没有构造函数就会去找祖类）

<?php
    class xiu {
        function __construct(){
            echo "执行父类构造函数";
        }
    }
    class kang extends xiu {
        function __construct(){
            parent::__construct();
            echo "执行子类构造函数";
        }
    }
    $kang = new kang();//输出"执行父类构造函数执行子类构造函数"
?>

假设创建新的ceo对象时，需要xiu类和kang类的构造函数都在执行，此时就可以在ceo的构造函数中显式的引用这些函数

class ceo extends kang {
    function __construct(){
        xiu::__construct();
        kang::__construct();
    }
}

• 继承与延迟静态绑定

self关键词会在编译时而非运行时确定其作用域（运行后编译）

<?php
    class xiu {
         static $name = "xiu";
         static function getName(){
            echo self::$name;
        }
    }
    class kang extends xiu {
         static $name = "kang";
    }
    echo kang::getName();//输出"xiu"
?>

接口

• 实现一个接口

使用interface关键字创建接口

接口的属性必须是常量

接口的方法必须是public，且不能有函数体

使用implements关键字实现接口类

类必须实现接口中的所有方法

interface xiu{
    const brand = ‘siemens‘;
    public function connect();
}
class kang implements xiu{
    public function connect(){
        echo self::brand;
    }
}

• 实现多个接口

类可以同时实现多个接口

interface xiu{
    public function connect();
}
interface kang{
    public function contact();
}
class sear implements xiu,kang{
    public function connect(){}
    public function contact(){}
}

抽象类

 抽象类是不能实例化的类，只能被其他类继承

抽象类定义的所有方法都必须在子类实现

abstract class xiu {
    public $name;
    abstract public function kang();
}
class sear extends xiu{
    function kang(){}
}