PHP基础-面向对象

对象简介

对象的主要三个特性：

• 对象的行为：可以对 对象施加那些操作，开灯，关灯就是行为。
• 对象的形态：当施加那些方法是对象如何响应，颜色，尺寸，外型。
• 对象的表示：对象的表示就相当于身份证，具体区分在相同的行为与状态下有什么不同。

面向对象内容

名称	释义
类	定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
对象	是类的实例。
成员变量	定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。
成员函数	定义在类的内部，可用于访问对象的数据。
继承	继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
父类	一个类被其他类继承，可将该类称为父类，或基类，或超类。
子类	一个类继承其他类称为子类，也可称为派生类。
多态	多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
重载	简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
抽象性	抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
封装	封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
构造函数	主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
析构函数	析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

创建对象

$obj = new test();

PHP 类定义

类格式

<?php
class phpClass {
    var $x = 1;
    var $y;
    function sum_val ($b) {     // 包含参数的成员函数
        $c = $this->x + $b;     // this 表示自身的对象
        return $c;
  }
}
$class_obj = new phpClass;              // 实例化类对象

$var = $class_obj->x;                   // 调用类变量
echo "类变量的值是：",$var;

print("<br>");

$fun = $class_obj->sum_val(2);      // 调用成员函数
echo "成员函数执行结果：",$fun;
?>

访问控制

PHP 对属性或方法的访问控制，是通过在前面添加关键字

public（公有），protected（受保护）或 private（私有）来实现的。

• public（公有）：公有的类成员可以在任何地方被访问。
• protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
• private（私有）：私有的类成员则只能被其定义所在的类访问。

<?php

class fun1{
    
    // 类内置变量加权
    var $a = "类内置变量1";                  // 默认写法，默认为公有访问权限
    public $b = "类内置变量2";               // 公有访问权限
    protected $c = "类内置变量3";            // 受保护访问权限
    private $d = "类内置变量3";              //私有访问权限

    // 类内置函数加权
    public function test1(){
        print("这是测试函数1");
    }
}

?>

PHP构造函数

构造函数是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。

PHP 5 允许开发者在一个类中定义一个方法作为构造函数

<?php

class phpClass {
    var $name;
    var $gender;
    function __construct($a,$b)                         // 构造函数，类的传参
    {
        $this -> name = $a;                             // 类参数赋值给类自身的对象
        $this -> gender = $b;                           // 类参数赋值给类自身的对象
    }

    function test () {                                  // 包含参数的成员函数
        echo $this->name,"的性别是：",$this->gender;
    }
}
$class_obj = new phpClass("小明","男");                 // 实例化类对象

$fun = $class_obj->test();                              // 调用成员函数
echo $fun;
?>

PHP析构函数

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。

PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言

<?php

class phpClass {
    var $name;
    var $gender;
    function __construct($a,$b)                         // 构造函数，类的传参
    {
        $this -> name = $a;                             // 类参数赋值给类自身的对象
        $this -> gender = $b;                           // 类参数赋值给类自身的对象
    }

    function test () {                                  // 包含参数的成员函数
        echo $this->name,"的性别是：",$this->gender;
    }

    function __destruct()                               // 析构函数
    {
        echo("<br>");
        print("类对象其它函数执行完毕自动执行此函数");
    }
}
$class_obj = new phpClass("小明","男");                 // 实例化类对象

$fun = $class_obj->test();                              // 调用成员函数
echo $fun;
?>

继承

PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承

class Child extends Parent {
   // 代码部分
}

示例

<?php

class foo
{
    var $b = "小狗";
    function printTEST1($string)
    {
        echo $string,"在河边钓鱼";
    }
}

class bar extends foo                      // 继承 foo 类
{
    function printTEST2($string)
    {
        echo $string,"在河里游泳";
    }
}

$bar = new bar();                           // 实例化类，继承了foo类的子类对象
$bar->printTEST1('小猫');           // 可以直接使用父级函数
print("<br>");
$bar->printTEST2($bar->b);                  // 直接使用自身函数,参数为父类的类变量

?>

含构造函数和析构函数的继承

<?php

class foo
{
    var $name;                          // 类内置变量
    function __construct($a) {          // 构造函数。便于实例化传值
        $this->name = $a;
    }

    function printTEST1($b)             // 类内置函数
    {
        echo $b,"在河边钓鱼";
    }
    function __destruct()               // 析构函数
    {
        echo $this->name,"在树上玩耍";
    }
}

class bar extends foo                   // 继承 foo 类
{
    function printTEST2($string)        // 子类内置函数
    {
        echo $string,"在河里游泳";
    }
}

$bar = new bar("松鼠");             // 实例化类，继承了foo类的子类对象
$bar->printTEST1("小猫");           // 可以直接使用父级函数
print("<br>");
$bar->printTEST2("小狗");       // 直接使用自身函数,参数为父类的类变量
?>

接口

使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

<?php

// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $action);
}


// 实现接口
class Template implements iTemplate
{
    public function setVariable($name, $action)
    {
        echo $name,"在河边",$action;
    }
}

$class_obj = new Template();
$V = $class_obj->setVariable("小猫","钓鱼");
echo $V;
?>

抽象类

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。

定义为抽象的类不能被实例化。

被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

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

    // 普通方法（非抽象方法）
    public function test() {
        print("普通函数");
    }
}

class ConcreteClass1 extends AbstractClass
{
    //继承父类的必要函数
    function test1() {
        print("测试1");
    }
}

$class_obj = new ConcreteClass1;
echo $class_obj->test1()
?>

Static 关键字

声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。

静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

静态属性不可以由对象通过 -> 操作符来访问。

自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。

<?php
class test
{
    static $a = 123;
}
echo test::$a;
?>

Final 关键字

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

以下代码执行会报错：

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called" . PHP_EOL;
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

调用父类构造方法

PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

结果

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法

转载于:https://my.oschina.net/zhaojunhui/blog/3086003