编程的艺术就是处理复杂性的艺术
----------------- Edsger Dijkstra

面向对象的核心内容就是一切事物皆为对象。
第一次接触面向对象的时候是java，面向对象主要的特点就是封装，继承和多态。对于面向对象的概念我也不必多说，这里我只记录一下php的面向对象的使用方法。

类的声明

和各种语言一样php也是通过class来声明类的
那么声明类需要几个注意

• 权限修饰符是可选项(public protected private 或者省略)
• class是创建类的关键字
• 类名是所需要创建类的名称，在class之后，后面是{}
• 类体必须放在{}里

下面是一个简单的类的声明，包括一个构造方法和一些getter和setter方法

<?php

/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/10
 * Time: 21:15
 */
class student
{
  var $name;
  var $age;
  var $sex;

    /**
     * student constructor.
     * @param $name
     * @param $age
     * @param $sex
     */
    public function __construct($name, $age, $sex)
    {
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }

    /**
     * @return mixed
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @param mixed $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * @return mixed
     */
    public function getAge()
    {
        return $this->age;
    }

    /**
     * @param mixed $age
     */
    public function setAge($age)
    {
        $this->age = $age;
    }

    /**
     * @return mixed
     */
    public function getSex()
    {
        return $this->sex;
    }

    /**
     * @param mixed $sex
     */
    public function setSex($sex)
    {
        $this->sex = $sex;
    }
    
}

下面是一个测试的文件

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/10
 * Time: 21:19
 */

//注意在这个地方，需要引用这个类文件（php的类要带个.class.php的后缀）
require_once 'Student.class.php';
echo "下面创建一个student对象";
//初始化
$stu = new Student("surine",12,"boy");
//使用
echo $stu->getName();
echo $stu->sex;

除了注意这个类需要手动引入之外其他的都很简单，和java的类似。

特殊访问方式

1.$this

this这个用法我们在java里也经常用，作用就是完成对象内部成员之间的访问。

2.：：

相比this，：：才是真正的强大，他可以在没有任何实例的情况下来访问类成员

那么他的格式如下

关键字：：变量名/常量名/方法名

这里的关键字分为下面几种情况

1. parent : 调用父类的相关成员 （相当于java的super）
2. self：调用当前类的静态成员和常量
3. 类名：调用本类的变量常量和方法。

下面是一个演示

<?php
class animal{
    const NMAE = "动物";

    /**
     * animal constructor.
     */
    public function __construct()
    {
        //使用类名访问常量成员
        echo "动物类:".animal::NMAE;
    }
}

class Cat extends animal{
    const NMAE = "猫";

    /**
     * Cat constructor.
     */
    public function __construct()
    {
        echo "<br>";
        //使用parent访问父类构造
        echo parent::__construct();
        echo "<br>";
        //使用self访问自身常量成员
        echo self::NMAE;
        echo "<br>";
    }
}
   echo "类外调用:".Cat::NMAE;
   new Cat();

运行结果：

运行结果PNG

构造和析构

构造函数大家都知道，在面向对象语言中起着初始化的作用，php也不例外，java中构造函数必须和类同名，php也可以这样写，但是更常见的是下面这种写法

 public function __construct()
    {
        //注意construct前面是两个下划线
    }

我们知道java等语言构造方法是可以有多个的，我们称之为重载，但是php不允许这样，他通过默认参数来实现重载，我们可以给参数赋值，也可以不用这样达到了同样的一个效果。

那么我们同样知道析构函数是在对象销毁的时候执行的一个方法

 function __destruct()
    {
        // TODO: Implement __destruct() method.
    }

通常在析构方法里做一些释放资源的任务。

封装

这是面向对象的三大特点之一，封装的意思就是抽象一个类，包含一些属性，那么这些属性或者方法都有访问权限，比如说public，private，protected

继承

继承使得面向对象更加灵活，我们可以通过extends关键字来实现一个类的继承，在前面我也演示过，并且我们知道通过parent：：来访问父类的方法

多态

多态顾名思义就是有多种状态，包括重载重写等
下面是一个通过接口（接口在下面讲到）实现的多态

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/11
 * Time: 14:26
 */
interface Type{
    public function go_Type();
}
class Type_car implements Type{

    public function go_Type()
    {
        echo "car";
        // TODO: Implement go_Type() method.
    }
}

class Type_bus implements Type{

    public function go_Type()
    {
        echo "bus";
        // TODO: Implement go_Type() method.
    }
}

function change($obj){
    if($obj instanceof Type){
        $obj->go_Type();
    }else{
        echo "obj不合法";
    }
}
change(new Type_car());

那么这个当然是输出car。

抽象

抽象类是不能被实例化的特殊类，他是配合多态使用的，只能作为其他类的父类，使用abstract来声明

那么抽象类和普通类相似，包括成员变量和成员方法，两者区别在于，抽象类至少要包含一个抽象方法，那这个方法是没有方法体，他的方法体是在子类中实现的。

例如：

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/11
 * Time: 14:11
 */
abstract class animal{
    abstract function run();
    abstract function eat();
}

class cat extends animal{

    //必须实现其方法
    function run()
    {
        // TODO: Implement run() method.
        echo "run()";
    }

    function eat()
    {
        // TODO: Implement eat() method.
       echo "eat()";
    }
}

$cat = new Cat();
//调用
$cat->eat();

我们抽象一个动物方法，然后用cat类继承自它，实现其中的相关方法，然后我们可以通过对象进行调用。

接口

继承增加了类的复用性，但php和java类似也只支持单继承，那么多继承当然是使用接口实现。

接口声明如下

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/11
 * Time: 14:17
 */
interface One{
    const CON = "value";
    function One();
}

interface Two extends One{
    function Two();
}

可以看到php的接口也是interface声明，而且也支持extends
那么接口怎么使用？

require_once "MyInter.php";
class TestInter implements One,Two{
    public function One(){
      echo "one";
    }
    public function Two(){
        echo "two";
    }
}
$test = new TestInter();
$test->Two();

输出结果就是two

其他关键字

1.final

final意思是最终的，最后的，也就是最终版本，不允许做其他修改，如果有个类用final修饰，那么他一定不会有子类，不会被继承

2.static

static就是静态的意思，在java中也是有的，他属于类本身，但是不属于类的任何实例，它相当于储存在类中的全局变量，那么同样我们可以使用：：访问

魔术方法

php中有很多以__开头的方法，比如说构造，析构，这些方法被称为魔术方法，那么下面是几个魔术方法

1.__get() __set()

这是php的getter和setter，用于赋值获取值，为外部提供的访问接口

2.__isset() __unset()

这个函数类似于isset和unset函数，如果对象中存在__isset()方法，当在类的外部使用isset函数检测对象中的私有成员属性时，就会自动调用类中的__isset()方法完成对私有成员属性的检测操作
__unset()函数是删除指定的变量，参数为要删除的变量名称

3.__call()

这个函数的作用是：当对象企图使用一个不存在的方法时，系统就会调用call函数，并且把方法名和参数都记录下来。
下面是一个例子

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/11
 * Time: 14:43
 */
class Call{
    var $a;

    /**
     * Call constructor.
     * @param $a
     */
    public function __construct($a)
    {
        $this->a = $a;
    }

    /**
     * @return mixed
     */
    public function getA()
    {
        return $this->a;
    }

    /**
     * @param mixed $a
     */
    public function setA($a)
    {
        $this->a = $a;
    }

    function __call($name, $arguments)
    {
        echo $name;
        echo "<br>";
        print_r($arguments);
        // TODO: Implement __call() method.
    }
}

$a = new Call(10);
$a->A("???");

可以看到我们最后调用了A这个方法，这个方法其实是不存在的，系统识别到，并调用了__cal方法，输出结果就是call方法体里的内容

call.PNG

4.__toString()

这个方法在java中也见过，那么我们可以这样使用它

//在类里实现它
function __toString()
  {
      return "我是方法";
      // TODO: Implement __toString() method.
  }

//直接打印对象
echo $a; 

得到的结果就是执行了__toString输出的内容。
如果没有这个方法将会发生致命错误

5.__autoload()

可以看到我们在之前的类导入的时候都是手动require的，这样比较麻烦也比较乱。
那么系统为我们提供了自动导入的方法，下面一个小例子演示一下

<?php
/**
 * Created by PhpStorm.
 * User: surine
 * Date: 2017/8/11
 * Time: 14:55
 */
function __autoload($name){
    $file = realpath(__DIR__).'/'.$name.'.php';
    if(file_exists($file))
    {
        require_once($file);
       if(class_exists($name,false))
       {
           return true;
       }
        return false;
    }
    return false;
}
$test = new Call();
$test->getA();

在未实例化之前系统首先判断存不存在这个文件，然后确定导入之后才能实例化。

总结

当然面向对象不止这点东西，更多更有意思的东西在以后学习过程中研究。