php类abstract和final，类方法abstract和final， interface

class类修饰符

final：

当final做用于某个类时，此类被限定为不可继承类，即其余类没法继承此类，最终类，当你不想让别人继承本身的编写的类时只须要在前面加上final关键字便可

final class MyClass {
    //code
}

//fatal error final class MyClass can not be inherited by other class
class SubClass extends Myclass {
}

当final做用于某个类方法时，此方法被限定为不可重写，即子类中不能够重写此方法，并不是不可继承，类方法能否被继承依旧被public protected private限定，但即便父类的fianl private方法没法被子类继承，子类中仍然不能重写此方法

php的继承机制是先检查此方法是否是final，若为final子类中仍重写此方法，则报错

只有在不是final时才会进一步依据public protected private来限定子类是否能继承此方法

且重写追寻访问权限必须宽松于父类的原则 

class MyClass {
    final public function finalPublic() {
        echo __METHOD__;
    }
    
    final private function finalPrivate() {
        echo __METHOD__;
    }
    
    final protected function finalProtected () {
        echo __METHOD__;
    }
}
//可调用父类可继承的方法MyClass::finalPublic() MyClass::finalProtected() 但 MyClass::finalPrivate()将不被继承
class CorrectSubClass extends Myclass {
}
//由于重写了父类的final修饰的方法 因此会报错
class ErrorSubClass extends Myclass {
    public function finalPublic() {
        echo __METHOD__;
    }
    //虽然并不能从父类MyClass中继承finalPrivate()方法但依旧会由于其被final修饰而报错
    //弱父类private方法不为fianl类型，则子类能够重写一个private方法
    //private function finalPrivate() {
    //   echo __METHOD__;
    //}
    
    protected function finalProtected () {
        echo __METHOD__;
    }
}

abstract：

当abstract做用于某个类时，此类被限定为抽象类，只能用于继承，而没法实例化对象。

抽象类不必定含有抽象方法，但抽象方法必定存在于抽象类中，且继承此抽象类的子类必须所有实现其抽象方法，不然，子类也要标识为抽象类。

抽象方法是必须被子类继承实现的，因此不能够用private修饰符去限定abstract抽象方法，能够用public和protected去修饰。

abstract class MyClass {
    //抽象方法的定义相似于C/C++中的函数声明 没有函数体 其后继承此类的子类中必须实现此方法 不然子类也必须为抽象类
    abstract public function abstractFunc();
    abstract public function abstractFuncOther();
    
    public function index() {
    
    }
}

abstract class SubAbstract extends MyClass {
    //不实现父抽象类的抽象方法则自身必须为抽象类
}

//不然要实现所有抽象方法
class Sub extends MyClass {
    //继承抽象类若自身不为抽象类必须实现其父类的全部抽象方法
    public function abstractFunc() {
        
    }
    
    public function abstractFuncOther() {
        
    }
}

实例汇总

<?php
//========================================================================================================================================
//============================================       final类       and      final方法       ==============================================
/**
* final class 不能够被其余类继承 终结类
*/
final class FinalClass
{
	public function index()
	{
		echo "i am " . __METHOD__;
	}
}

/**
 * 含有final method的class 继承类中不能重写此类中的final method 
 * final的优先级要高于private 即虽然此类中此方法为final private method 子类没法继承此private方法
 * 但此时依然会由于父类中此私有的方法为final 不能在子类中自行定义 不给你 也不让你作一个
 */
class FinalMethod
{
	final public function finalPublic()
	{
		echo __METHOD__ . ' can be inherited, but be overrided' . '<br/>';
	}

	final protected function fianlProtected()
	{
		echo __METHOD__ . ' can be inherited, but be overrided' . '<br/>';
	}

	final private function finalPrivate()
	{
		echo __METHOD__ . ' can not be inherited or be overrided' . '<br/>';
	}
}

class MethodClass extends FinalMethod 
{
	public function index()
	{
		$this->finalPublic();
		$this->fianlProtected();
	}
	//被final限定不可重写父类全部的fianl方法 不管是否可从父类继承
	// public function finalPrivate() {

	// }
}
echo '==================== final ======================' . '<br/>';
$method = new MethodClass();
$method->index();

//========================================================================================================================================
//============================================       抽象类       and      抽象方法       ================================================

/**
 * 抽象类 只能用于继承 不可实例化对象 且抽象类抽象方法可为零
 * 抽象方法必须存在于抽象类中 抽象方法没有函数体 相似于c/c++中的函数声明
 * 继承此抽象类的子类要么将此类中的全部抽象方法实现 不然子类也必须为抽象类
 * 抽象方法不能够用private去修饰 由于其自己的出发点就是要去被重写实现的 这点与final刚好相反 final不容许被重写 abstract必须被重写 因此在抽象类中private没有任何意义
 * 抽象方法的访问级别只能是public或者protected 且子类去实现方法时只能是下降方法的访问级别而不能提高 即protected能够被重写为public 但public不能重写为protected
 * 访问级别的升降要以顶级抽象方法的声明为准则 即便此方法后期被实现后又被继承 继承时重写次方法仍然不能提升访问级别 只能是下降 始终下降
 */
abstract class AbstractClass
{
	//index()被调用之日此抽象类的所有抽象方法确定已被实现 index()只能经过对象去调用 而实例化对象时则此类的全部抽象方法最终也已被实现
	public function index()
	{
		$this->abstractPublicFunc();
		$this->abstractProtectedFunc();
	}
	// 不能够用private去修饰 abstract原本就是用于子类继承实现的 且子类实现此抽象方法时访问级别必需要小于等于此抽象类定义的
	abstract public function abstractPublicFunc();
	abstract protected function abstractProtectedFunc();
}
/**
 * 只实现了父抽象类中的一个抽象方法 则自身也只能做为抽象类使用
 */
abstract class SubAbstractClass extends AbstractClass
{
	//抽象方法被具体实现 但后续子类中此方法的访问级别仍然不能提高 即不能重写为protected
	public function abstractPublicFunc()
	{
		echo __CLASS__ . __METHOD__ . '<br/>';
	}
}
/**
 * 父类中的抽象方法都已经被实现 可实例化对象
 */
class ObjectClass extends SubAbstractClass
{
	public function abstractPublicFunc()
	{
		echo __METHOD__ . '<br/>';
	}
	//这里能够将此方法的访问级别设定为public 但绝对不可能为private
	public function abstractProtectedFunc()
	{
		echo __METHOD__ . '<br/>';
	}

}
echo '====================abstract=====================' . '<br/>';
$abstract = new ObjectClass();
$abstract->index();

//========================================================================================================================================
//========================================================       接口 interface       ====================================================
/**
 * 接口是用来定义一套行为标准 任何使用此接口的类都必须追寻接口所声明的方法标准 是一套不须要使用abstract修饰的但所有为抽象方法的标准类
 */
interface MyInterface
{
	public function getName();
	public function getAge();
	public function getSex();
}

class User implements MyInterface
{
	private $name = null;
	private $age = null;
	private $sex = null;

	public function __construct($name, $age, $sex)
	{
		$this->name = $name;
		$this->age = $age;
		$this->sex = $sex;
	}

	public function getName()
	{
		echo $this->name . '<br/>';
	}

	public function getAge()
	{
		echo $this->age . '<br/>';
	}

	public function getSex()
	{
		echo $this->sex . '<br/>';
	}
}

$user = new User('sallency', 25, 'male');
echo '====================interface=====================' . '<br/>';
$user->getName();
$user->getAge();
$user->getSex();
?>