类的继承，抽象类和接口的

类方法

<?php
// 类方法
// 类中的函数
class Car{
   public $brand = '红旗';
   public $price = '99999';
   public $add = '惠州';
   public $brand1 = '本田';
   public $price1 = '88888';
   public static $add1 = '惠州';
//访问类属性1
   public function hongqi()
   {
    // 创建类实例
    $cook = new car;
    // 访问类中的属性
       return "{$cook->add}的價格{$cook->price}";
   }
 //访问类属性2
   public function bentian()
   {
    // self: 引用当前, $this: 引用当前实例
    // 1. 创建类实例, self 与当前的类绑定
    // $this不允许用户设置, 由php系统进行维护和赋值
    // $this = new self();
    // 2. 访问类中的属性, $this 与当前类的实例绑定
    // 静态方法: 直接用类调用, 被所有类实例所共享
    // 静态方法中只能访问静态成员: 静态属性, 静态方法
       return self::$add1 . "的价格{$this->price}";
   }
//类中访问外部属性
// 关键字：global
    public function byd()
    {global $brand2;
        return "{$this->add}{$brand2}的价格{$this->price}";
    } 
// 访问类外部函数：函数的作用域默认是全局, 函数是全局成员
    public function jili()
    {
        $a = jili();
        return $a;
    }
}
$brand2 = '比亚迪';
$brand3 = '吉利';
function jili()
{
    global $brand3;
    return $brand3 . '是中国的汽车';
}
$cook = new car;
echo $cook->hongqi();
echo '<hr>';
echo $cook->bentian();
echo '<hr>';
echo $cook->byd();
echo '<hr>';
echo $cook->jili();
echo '<hr>';

作用域

// 作用域
 // public: 公开成员,默认值, 类外部, 类内部, 以及类的子类中(类的继承上下文环境中)
    // protected: 受保护的成员, 类外部禁止访问, 但是类的内部以及它的继承上下文中可以访问
    // private: 私有成员, 除了当前类可以访问, 类的外部以及类的继承上下文中都禁止访问
    // 继承上下文环境: 当前类, 以及它的扩展类/子类,构成的一个具有层级结构的类家庭
class Car1{
   public $brand5 = '奇瑞';
   private $price5 = '66666';
   protected $add5 = '惠州';
   public function qirui()
   {
    // 类中方法可以访问类中所有成员, 不受访问控制的限制
    return "{$this->add5}{$this->brand5}{$this->price5}";
   }
}
$b = new car1;
echo $b->qirui();
echo '<hr>';
echo $b->brand5;
echo '<hr>';
// echo $b->price5;    不能访问
echo '<hr>';
// echo $b->add5;    不能访问

// 子类的创建：关键字：extends
class Car2 extends Car
{
}

继承

// 类的继承三大功能：封装，继承，多态
// 封装:public, proteced, private
// 继承：也叫类的扩展
    // 二类成员: 子类有权访问的父类成员类型, public, protected
    // 三种操作: 子类对父类的三种操作: 继承, 重写, 扩展
    // 1. 继承: 父类的二类成员自动成为子类的成员
    // 2. 重写: 覆写与父类/基类同名的成员(属性, 方法)
    // 3. 扩展: 子类添加自身的方法来增加/扩展父类的功能
    // 基类/父类
    class City
    {
        public $capital = '北京';
        protected $district = '密云区';
        private $district1 = '东城区';
        function compare()
        {
            return "{$this->capital}最大的区是{$this->district},最小的区是{$this->district1}";
        }
    }
    // 子类：也叫扩展类
    // 关键字：extends
    class City1 extends City
    {
        // 重写父类属性：覆写与父类/基类同名的成员(属性, 方法)
        public $capital = '西城区 ';
        // 重写父类方法：覆写与父类/基类同名的成员(属性, 方法)
        public function compare()
        {
         return "{$this->district}不属于{$this->capital}";
        }
        // 属性扩展：子类添加自身的方法来增加/扩展父类的功能
        public $capital2 ='朝阳';
        // 方法扩展：子类添加自身的方法来增加/扩展父类的功能
        public function province()
        {
            return "{$this->capital2}";
        }
    }
// 子类操作：继承
// 子类中继承了父类的公开成员和受保护成员，所以在子类中也可以访问
$b = new city1;
echo $b->capital;
echo '<hr>';
echo $b->compare();
echo '<hr>';
// 子类操作：重写
echo $b->capital;
echo '<hr>';
echo $b->compare();
echo '<hr>';
 // 子类操作：扩展
echo $b->capital2;
echo '<hr>';
echo $b->province();

抽象类

// 抽象类：也叫设计类:关键字：abstract
// 抽象类不能被实例化
// 只要一个类中有一个抽象方法, 那么这个类就是:抽象类
// 实现类/工作类: 是一个可以被实例化的普通类
// 工作类不一定是可以被实例化的普通类,也可是一个抽象类
// 抽象类也可以被继承, 抽象类也可以用在继承的上下文环境中
// 抽象类中允许有抽象成员, 但不是强制的,也可以没有
// 设计类
abstract class Introduce
{
    public $name = '小明';
    protected $profession = 'it男';
    protected $age = '25';
    abstract public function poi();
    public function lol()
    {
        return "{$this->name}{$this->profession}";
    }
}
// 实现类:也叫工作类
// 在实现类中通过重写方法实现设计类中没有实现的方法
class Jj extends Introduce
{
    public function poi()
    {
        return parent::lol() . "年龄是{$this->age}";
    }
}
$h = new Jj;
echo '<hr>';
echo $h->poi();

接口

// 接口
// 接口: 完成分离了"设计与实现"
// 使用与类相似的语法: 抽象方法, 常量, 构造方法(魔术方法的一种)
// 默认访问控制必须是public
// 接口允许多继承, 从而间接实现了PHP的多继承
// implements (英婆慢吃)
// 接口:关键字: interface
interface nem
{
    // 接口成员常量:大写
    const NAMBER = '15';
    // 接口成员方法:抽象方法
    public function asd();
}
// 实现类：关键字：implements
class key implements nem
{
    public function asd()
    {
        return nem::NAMBER;
    }
}
$v = new key;
echo '<hr>';
echo $v->asd();

总结

• 1.类属性：是创建在类中，可供类中的所有函数调用
• 2.方法中的变量：是只有包含它的方法中财能使用它
• 3.类中方法可以访问类中所有成员, 不受访问控制的限制
• 4.子类中属性和方法的访问符必需大于类中的访问符
• 5.一旦类中包含了abstract方法，则这个类必须声明为abstract
• 6.如果一个类继承了某个抽象类，则它必须实现该抽象类的所有抽象方法 
• 7.抽象类实现了部分设计与实现，可以有具体的方法也可以有抽象的方法
• 8.接口完全实现了设计与分类，必须是抽象的方法
• 9.’继承’关键字extends，接口’实现’关键字implement