静态，关键字：static 接口，IUSB , API 接口关键字：interface

//静态
//普通成员
//普通成员是属于对象的

//静态成员
//静态成员属于类的

//关键字：static
//self关键字：在类里面代表该类
//在静态方法里面不能调用普通成员
//在普通方法里面能够调用静态成员

//.$this代表该对象,需要用对象去调用它，不能用类名调用！说明了一个情况：在静态方法里面不能调用普通成员

class FenBi
{
    public $length; //粉笔的长度
    public static $color; //粉笔的颜色

    static function show()
    {
        echo "粉笔颜色是：".self::$color;
    }

    function XianShi()
    {
        echo "显示：".self::$color;
    }
}

$f = new FenBi(); //先造一个对象
$f->length; //用对象去调用普通成员

FenBi::$color = "红色"; //使用类名调用静态成员
FenBi::show();
$f->XianShi();

//抽象
//抽象类:关键字abstract
//特点：不能被实例化，只能被继承
//目的：为了派生子类，控制子类

abstract class Dog
{
    public $name;

    function Jiao()
    {
        echo "汪汪";
    }
}

class JinMao extends Dog
{

}

$d = new Dog();

1.用abstract关键字来修饰一个类时，这个类就叫抽象类，
2.用abstract关键字来修饰一个分法时，这个方法就是抽象方法。

抽象类
为什么设计抽象类这个技术？
1.在实际开发中，我们可能有这样一种类，是其它类的父类，但是它本身并不需要实例化，主要用途是

用于让子类来继承，这样可以达到代码复用，同时利于项目设计者，设计类！

快速入门案例

//在实现方法覆盖的时候，访问修饰符可以不一样
//但是必须满足：子类的访问范围>=父类的访问范围
abstract class Anima1{
    public $name;
    protected $age;
    //这个方法没有方法体，这个方法主要是为了让子类去实现，
    abstract public function cry();

    }

    class Cat extends Anima1{
        public function cry(){
                echo "猫咪叫唤..";

            }

        }
//创建一个子类实例
$cat1 = new Cat();
$cat1->cry();

使用抽象类的注意事项：
1.基本用法
abstact class 类名{
    //方法
    //属性
}

2.如果一个类使用abstract 来修饰，则该类就是抽象类，如果一个方法被abstract修饰，则该方法就

是抽象方法【抽象方法就不能有方法体】

3.抽象类可以没有抽象方法，同时还可以有实现了的方法
//在实现方法覆盖的时候，访问修饰符可以不一样
//但是必须满足：子类的访问范围>=父类的访问范围
abstract class Anima1{
    public $name="abc";
    protected $age;
    //这个方法没有方法体，这个方法主要是为了让子类去实现，
    abstract public function cry();

        public function getName(){
            return $this->name;
            }
    }

    class Cat extends Anima1{
        public function cry(){
                echo "猫咪叫唤..";

            }

        }
//创建一个子类实例
$cat1 = new Cat();
$cat1->cry();
echo $cat1->getName();

4.如果一个类中，只要有抽象方法，则该类必须声明 abstract

abstract class A{
    abstract function test();

    }

echo "ok";

5.如果 A 类继承了一个抽象类 B，则要求 A 类实现从 B 类继承的所有抽象方法。
案例如下：
//这是一个抽象类
abstract class A{
    abstract function test();
    abstract function test2();
    }
    //B类要么自己抽象，或者实现从A类继承的抽象方法。
    class B extends A{
        function test(){
            echo "我实现A:text()";
            }

        function test(){
            echo "我实现A:text2()";
            }

    }
echo "ok";

//练习题

abstract class Animal{

    public function abc(){
            echo "abc";

        }

    public static function abc2(){

            echo "ok no";
        }
    }

Animal::abc2();//直接有类名调用抽象方法。

//接口
//极度抽象的类
//接口里面不能包含成员变量，只能包含成员方法
//成员方法可以没有函数体
//接口关键字：interface
//实现接口的类，必须实现接口里面的所有方法

interface IUSB
{
    function read(); //读的方法
    function write(); //写的方法
}

//鼠标的驱动类
class Mouse implements IUSB
{
    function read()
    {
        echo "鼠标点击了";
    }
    function write()
    {
        echo "给鼠标一个指令";
    }
}

//键盘的驱动类
class JianPan implements IUSB
{
    function read()
    {
        echo "键盘输入了内容";
    }
    function write()
    {
        echo "给键盘指令";
    }
}

$m = new Mouse();
$m->write();

$j = new JianPan();
$j->read();

接口：
快速入门案例

//使用程序模拟现实情况
//定义规范（方法/属性）
interface iusb{

    public function start();
    public function stop();

    }

//编写相机类，让它去实现接口
//1.当一个类实现了某个接口，则要求该类必须实现这个接口的所有方法
class camera implements iusb{

    public function start(){

        echo "相机开始工作....";

        }

    public function stop(){

        echo "相机停止工作....";
        }

    }

//编写手机类
class phone implements iusb{

    public function start(){

        echo "手机开始工作....";

        }

    public function stop(){

        echo "手机停止工作....";
        }

    }

//如何使用
//相机对象
$camera1=new Camera();
$camera1->start();
$camera1->stop();

//手机对象
$phone1=new phone();
$phone1->start();
$phone1->stop();

//注意细节：
1.接口的使用基本语法

interface 接口名{
    //属性
    //方法

}
//接口的方法都不能有方法体

//如何去实现接口
class 类名 implements 接口名{

}

//接口它的作用就是声明一些方法，供其他类来实现,接口还体现编程中我们希望的效果 高内聚低耦合 的特点：

//接口：API