php 抽象 继承 多态

1、继承和重载

！！！php中使用extends单一继承的方法

被继承的类  父类（基类）

继承者   子类（派生类）

如果说我们需要将父类方法重载（方法覆盖），在派生类里使用与基类方法重名的方法名称执行重载

重载时我们需要调用原始基类内容，再增加新的内容，我们可以使用：

基类名：：方法名称

<?php
    class Root{
        function dayin(){
            return  "Root print <br>";
        }
    }
    class Son extends Root{
        function dayin2(){
            return $this->dayin()."Son print <br>";
        }
    }

    $p = new Son();
    echo  $P->dayin();
　　 echo  $P->dayin2();

?>

<?php
    class Root{
        function dayin(){
            return  "Root print <br>";
        }
    }
    class Son extends Root{
        function dayin(){
            return Root::dayin()."Son print <br>";
        }
    }

    $p = new Son();
    echo  $P->dayin();
?>

这样可以帮我们减少很多重新命名我们方法的名称，重载减少了我们命名的一些混乱，减轻了一些步骤。

2、抽象方法和抽象类

抽象关键字：abstract

抽象就是无法确切说明，但又有一定的概念或者名称

一个类中至少有一个方法是抽象的，我们称之为抽象类。

所以定义抽象类首先定义抽象方法

抽象方法不允许有{ }

抽象方法前面必须加abstract

其实就是抽象类是建立在抽象方法之上的

抽象类的几个特点：

　　1、不能被实例化，只能被继承

　　2、继承的派生类中要把所有抽象方法重载才能实例化

<?php
    abstract class cl1{
        abstract function func1();
        abstract function func2();
        abstract function func3();
        function  ok(){
            echo 'okkkkk';
        }
    }

    class cl2 extends cl1{
        function func1()
        {
           echo "第一个";
        }
        function func2()
        {
            echo "第二个";
        }
        function func3()
        {
            echo "第三个";
        }
        function ok()
        {
            cl1::ok();
        }
    }
    $p = new cl2();
    $p->func2();
    $p->ok();

3、类中常用关键字

1、关键字：final

用于定义类和方法的重要关键字，当定义类的时候该类将不能被继承，当用来定义方法的时候该方法不能被重载

<?php

include ('conn.php');
class MyPc{
    public $name='我的电脑';
    final function power(){
        echo $this->name.",电脑开中......";
    }
}
class My extends MyPc{
    function power()
    {
        echo MyPc::power().'%%%%%';
    }
}
$p = new My();
$p->power();

提示：Fatal error: Cannot override final method MyPc::power() in E:\phptest\datatype\663.php on line 14

<?php
include ('conn.php');
final class MyPc{
    public $name='我的电脑';
    final function power(){
        echo $this->name.",电脑开中......";
    }
}
class My extends MyPc{

}
$p = new My();
提示：Fatal error: Class My may not inherit from final class (MyPc) in E:\phptest\datatype\663.php on line 11

只能实例化基类

<?php
include ('conn.php');
final class MyPc{
    public $name='我的电脑';
    final function power(){
        echo $this->name.",电脑开中......";
    }
}
class My {

}
$p = new MyPc();
$p->power();

2、关键字：self

用来类访问当前类中的内容的关键字，类似与$this关键字，但$this是需要类实例化以后下可以使用，self可以直接访问当前类中的内部成员

self ：：类内部成员  （属性或者方法）

等价于

类名：：类内部成员  （属性或者方法）

注意：因为没有实例化类访问内部属性或者方法是没有意义的，所以self一般用来访问类中：静态成员，常量，或者其他定义内容

<?php
include ('conn.php');
final class MyPc{
    static $name='我的电脑';
    final function power(){
        echo $this->name.",电脑开中......";
    }
}

$p = new MyPc();
$p->power();
提示：

<br />
<b>Strict Standards</b>:  Accessing static property MyPc::$name as non static in <b>E:\phptest\datatype\663.php</b> on line <b>6</b><br />
<br />
<b>Notice</b>:  Undefined property: MyPc::$name in <b>E:\phptest\datatype\663.php</b> on line <b>6</b><br />
,电脑开中......

应该是这样写

<?php
include ('conn.php');
final class MyPc{
    static $name='我的电脑';
    final function power(){
        echo self::$name.",电脑开中......";
    }
}

$p = new MyPc();
$p->power();
输出结果：

我的电脑,电脑开中......

<?php
include ('conn.php');
final class MyPc{
    static $name='我的电脑';
    final function power(){
        echo self::$name.",电脑开中......";
    }
}

//$p = new MyPc();
//$p->power();

echo MyPc::$name;

3、关键字：static

用来定义类的静态属性或方法，可以在类未被实例化时使用，静态属性单独占用内存而不会因创建多个对象时导致同样的方法或者属性重复占用。

4、关键字：const

用来定义类中的常量，类似PHP外部定义常量的关键字define();Const只能修饰类当中的成员属性

注意：

　　1、建议大写常量

　　2、常量不使用$符号

4、类中接口应用

1、接口的介绍与创建

关键字：interface

接口：一种成员属性全部为抽象或常量的特殊抽象类

接口当中不允许声明变量

2、接口的引用与规范

关键字：implements

先继承后接口，单继承多接口

<?php
include ('conn.php');
interface demo{
    const NAME="名称";
    function fun1();
    function fun2();
}
interface demo2{
    function fun3();
    function fun4();
}
interface demo3{
    const PLAY="播放";
    function fun5();
}
class mypc implements demo,demo2 {
    function fun1()
    {
       echo "+++++++++++++<br>";
    }
    function fun2()
    {
       echo "%%%%%%%%%%%%%%<br>";
    }
    function fun3()
    {
        // TODO: Implement fun3() method.
    }
    function fun4()
    {
        // TODO: Implement fun4() method.
    }
}
//单继承多接口
class myps extends mypc implements  demo3{
    function fun5()
    {
        echo '5555';
    }
}

$p = new mypc();
$p->fun1();
echo mypc::NAME;

$b = new myps();
$b->fun5();
echo myps::NAME;
echo myps::PLAY;

5、类中多态的应用

1、多态的优势

类型运算符instanceof 用来测定一个给定的对象是否来自指定的对象类。

<?php
include ('conn.php');
class A{}
class B{}
$thing = new A();
if($thing instanceof A){
    echo 'A';
}
if($thing instanceof B){
    echo 'B';
}

interface myusb{
    function type();
    function alert();
}
class zip  implements myusb{
    function type()
    {
       echo '2.0';
    }
    function alert()
    {
        echo '正在检查U盘驱动';
    }
}

class mp3 implements myusb{
    function type()
    {
        echo '1.0';
    }
    function alert()
    {
        echo '正在检查MP3驱动';
    }
}

class mypc{
    function pcusb($what){
        $what->type().'<br>';
        $what->alert();
    }
}

$p = new mypc();
$zip = new zip();
$mp3= new mp3();

$p->pcusb($zip);
$p->pcusb($mp3);

总结

1、对象描述的配置

2、对象方法的异常处理

3、克隆对象的应用

4、自动载入对象的方法

<?php
include ('conn.php');

class My{
    function __toString(){
        echo '显示的内容';
    }
}
$p = new My();
echo $p;

class MY{
    function __call($name, $arguments)
    {
        echo "错误的方法名".$name;
        echo "错误的参数".print_r($arguments);
    }
}

class My{
    function __clone()
    {
        // TODO: Implement __clone() method.
    }
}

$a = new My();
$b = clone $a;

function __autoload($class_n){
    include($class_n.".php");
}
$p = new Mypc();
$d=new demo();