转自:http://php.net/manual/zh/language.oop5.abstract.php
abstract
定义为抽象的类不能被实例化.
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。(如果类的前方没有abstract声明,就会报错)
继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；
这些方法的访问控制必须和父类中一样（或者更为宽松）。(即,要小于等于父类的访问控制)
方法的调用方式必须匹配，即类型和所需参数数量必须一致。
<?php
abstract class AbstractClass
{
// 强制要求子类定义这些方法,且被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。
abstract protected function getValue();//子类继承的访问控制应声明为受保护的或者公有的，而不能定义为私有的
abstract protected function prefixValue($prefix);
abstract protected function prefixName($name);//抽象方法仅需要定义需要的参数
// 普通方法（非抽象方法）
public function printOut() {
print $this->getValue() . "\n";
}
}class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}public function prefixName($name) {
return "{$name}ConcreteClass1";
}
}class ConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
public function prefixName($name) {
return "{$name}ConcreteClass2";
}
}
class ConcreteClass extends AbstractClass
{public function getValue() {
return "ConcreteClass";
}public function prefixValue($prefix) {
return "{$prefix}ConcreteClass";
}// 子类可以定义父类签名中不存在的可选参数
public function prefixName($name, $separator = ".") {
if ($name == "Pacman") {
$prefix = "Mr";
} elseif ($name == "Pacwoman") {
$prefix = "Mrs";
} else {
$prefix = "";
}
return "{$prefix}{$separator} {$name}";
}
}$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n"; //Mr. Pacman
echo $class->prefixName("Pacwoman"), "\n"; //Mrs. Pacwoman$class1 = new ConcreteClass1;
$class1->printOut(); //ConcreteClass1
echo $class1->prefixValue('FOO_') ."\n"; //FOO_ConcreteClass1$class2 = new ConcreteClass2;
$class2->printOut(); //ConcreteClass2
echo $class2->prefixValue('FOO_') ."\n"; //FOO_ConcreteClass2
?>
用abstract修饰的类表示这个类是一个抽象类，用abstract修饰的方法表示这个方法是一个抽象方法。
抽象方法是只有方法声明，而没有方法的实现内容。
抽象类不能被实例化，通常是将抽象方法做为子类方法重写使用的，且要把继承的抽象类里的用abstract修饰的方法都实现。
<?php
abstract class AbstractClass{
//定义抽象方法
abstract protected function getValue();
//普通方法
public function printOut(){
echo $this->getValue();
}
}
class CommonClass extends AbstractClass{
protected function getValue(){
return "抽象方法的实现"；
}
}
$class1 = new CommonClass();
$class1->printOut();
转自:http://php.net/manual/zh/language.oop5.interfaces.php
interface
对象接口
使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是公有，这是接口的特性。
要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
Note:
实现多个接口时，接口中的方法不能有重名。
接口也可以继承，通过使用 extends 操作符。
类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。
常量
接口中也可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。
Example #1 接口示例
<?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;
}
}
?>
Example #2 可扩充的接口
<?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)
{
}
}
?>
Example #3 继承多个接口
<?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()
{
}
}
?>
Example #4 使用接口常量<?php
interface a
{
const b = 'Interface constant';
}// 输出接口常量
echo a::b;// 错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
class b implements a
{
const b = 'Class constant';
}
?>
interface
interface即PHP接口，并用关键字implements来实现接口中方法，且必须完全实现。
抽象类和接口的区别
接口是一个特殊的抽象类，接口与抽象类大致区别如下：
1，一个子类如果implements一个接口，就必须实现接口中的所有方法（不管是否需要）；如果是继承一个抽象类，只需要实现需要的方法即可
2，如果一个接口中定义的方法名改变了，那么所有市县次接口的子类需要同更新方法名，而抽象类中如果方法名改变了，其子类对应的方法名将不受影响，只是变成了一个新的方法而已
3，抽象类只能单继承，当一个子类需要实现的功能需要集成多个父类，就必须适用接口。
interface的引入是为了部分地提供多继承的功能。
在interface中只需声明方法头，而将方法体留给实现的class来做。
这些实现的class的实例完全可以当作interface的实例来对待。
在interface之间也可以声明为extends（多继承）的关系。
注意一个interface可以extends多个其他interface。