访问控制，范围解析操作符，抽象类，对象接口

<?php    
    abstract  class cl1
{
        abstract  function fun1();
        abstract  function fun2();
}
class cl2 extends  cl1
{
    function fun1(){
        echo "第一个";
    }
    function  fun2(){
        echo "第二个";
    }
    
}
$c=new cl2();
echo $c->fun2();?>

<?php
abstract class  AbstractClass
{
  // 强制要求子类定义这些方法
     abstract protected function  getValue ();
    abstract protected function  prefixValue ( $prefix );

     // 普通方法（非抽象方法）
     public function  printOut () {
        print  $this -> getValue () .  "\n" ;
    }
}

class  ConcreteClass1  extends  AbstractClass
{
    protected function  getValue () {
        return  "ConcreteClass1" ;
    }

    public function  prefixValue ( $prefix ) {
        return  " { $prefix } ConcreteClass1" ;
    }
}

class  ConcreteClass2  extends  AbstractClass
{
    public function  getValue () {
        return  "ConcreteClass2" ;
    }

    public function  prefixValue ( $prefix ) {
        return  " { $prefix } ConcreteClass2" ;
    }
}

$class1  = new  ConcreteClass1 ;
$class1 -> printOut ();
echo  $class1 -> prefixValue ( ‘FOO_‘ ) . "\n" ;

$class2  = new  ConcreteClass2 ;
$class2 -> printOut ();
echo  $class2 -> prefixValue ( ‘FOO_‘ ) . "\n" ;
?> 

//什么样的类是抽象类
/*
 *
 * 被抽象关键字修饰的类就是抽象类
 * 抽象类不一定包含抽象函数的方法，但是包含抽象函数的方法一定是抽象类
 * 抽象类不能直接实例化
 * 可被继承
 * */
abstract class Animal{
    /*
     * 被抽象关键字abstract修饰的方法就是抽象1方法
     * 抽象方法只有声明部分，没有实现部分
     * @return mixed
     *
     * */
abstract public function shout();
}
//继承了抽象类的普通类必须实现抽象类的抽象方法
class Cat extends Animal{
    public function  shout(){

    }
}

*
 * 接口可以认为是特殊的抽象类，但是其实它本身是一个特殊的类别
 * 在接口中只能定义公共的抽象函数方法和静态的常量
 * 接口中的抽象函数方法可以省略public关键字，同时abstract关键字不要书写出来
 * interface IFFly
 * 
 * */
interface IFly
{
    //只能用public
 public  function fly();
 //public abstract function fly();不能写abstract
    
}

<?php

// 声明一个‘iTemplate‘接口
interface  iTemplate
{
    public function  setVariable ( $name ,  $var );
    public function  getHtml ( $template );
}


// 实现接口
// 下面的写法是正确的
class  Template  implements  iTemplate
{
    private  $vars  = array();
  
    public function  setVariable ( $name ,  $var )
    {
         $this -> vars [ $name ] =  $var ;
    }
  
    public function  getHtml ( $template )
    {
        foreach( $this -> vars  as  $name  =>  $value ) {
             $template  =  str_replace ( ‘{‘  .  $name  .  ‘}‘ ,  $value ,  $template );
        }
 
        return  $template ;
    }
}

// 下面的写法是错误的，会报错，因为没有实现 getHtml()：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class  BadTemplate  implements  iTemplate
{
    private  $vars  = array();
  
    public function  setVariable ( $name ,  $var )
    {
         $this -> vars [ $name ] =  $var ;
    }
}
?> 

<?php
interface  a
{
    public function  foo ();
}

interface  b  extends  a
{
    public function  baz ( Baz $baz );
}

// 正确写法
class  c  implements  b
{
    public function  foo ()
    {
    }

    public function  baz ( Baz $baz )
    {
    }
}

// 错误写法会导致一个致命错误
class  d  implements  b
{
    public function  foo ()
    {
    }

    public function  baz ( Foo $foo )
    {
    }
}
?> 

<?php
interface  a
{
    public function  foo ();
}

interface  b
{
    public function  bar ();
}

interface  c  extends  a ,  b
{
    public function  baz ();
}

class  d  implements  c
{
    public function  foo ()
    {
    }

    public function  bar ()
    {
    }

    public function  baz ()
    {
    }
}
?>

<?php
interface  a
{
    const  b  =  ‘Interface constant‘ ;
}

// 输出接口常量
echo  a :: b ;

// 错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
class  b  implements  a
{
    const  b  =  ‘Class constant‘ ;
}
?>