PHP面试常考内容之面向对象（2）

绝地灬酷狼 2022-03-07 03:50 174阅读 0赞

PHP面试专栏正式起更，每周一、三、五更新，提供最好最优质的PHP面试内容。  
继上一篇“[PHP面试常考内容之面向对象（1）][PHP_1]”发表后，今天更新（2），需要（1）的可以直接点击文字进行跳转获取。  
整个面向对象文章的结构涉及的内容模块有：

> **一、面向对象与面向过程有什么区别？**  
> **二、面向对象有什么特征？**  
> **三、什么是构造函数和析构函数？**  
> **四、面向对象的作用域范围有哪几种？**  
> **五、PHP 中魔术方法有哪些？**  
> **六、什么是对象克隆？**  
> **七、this、self和parent的区别是什么？**  
> **八、抽象类与接口有什么区别与联系？**  
> **九、PHP面向对象的常考面试题讲解**

关于PHP面向对象的内容将会被分为三篇文章进行讲解完整块内容，第一篇主要讲解一到四点内容，第二篇主要讲解五到八的内容，第三篇围绕第九点进行讲解。

--------------------

以下正文的内容都来自**《PHP程序员面试笔试宝典》**书籍，如果转载请保留出处：

--------------------

# 五、PHP种魔术方法有哪些？ #

在PHP中，把所有以\_\_（两个下画线）开头的类方法保留为魔术方法。所以在定义类方法时，不建议使用 \_\_ 作为方法的前缀。下面分别介绍每个魔术方法的作用。

## 1．\_\_get、\_\_set、\_\_isset、\_\_unset ##

这四个方法是为在类和它们的父类中没有声明的属性而设计的。  
1）在访问类属性的时候，若属性可以访问，则直接返回；若不可以被访问，则调用\_\_get 函数。  
方法签名为：public mixed \_\_get ( string $name )  
2）在设置一个对象的属性时，若属性可以访问，则直接赋值；若不可以被访问，则调用\_\_set 函数。  
方法签名为：public void \_\_set ( string $name , mixed $value )  
3）当对不可访问的属性调用 isset() 或 empty() 时，\_\_isset() 会被调用。  
方法签名为：public bool \_\_isset ( string $name )  
4）当对不可访问属性调用 unset() 时，\_\_unset() 会被调用。  
方法签名为：public bool \_unset ( string $name )  
需要注意的是，以上存在的不可访问包括属性没有定义，或者属性的访问控制为proteced或private（没有访问权限的属性）。  
下面通过一个例子把对象变量保存在另外一个数组中。

<?php 
      class Test
      {
         /* 保存未定义的对象变量 */
         private $data = array();
         public function __set($name, $value){
            $this->data[$name] = $value;
         }
         public function __get($name){
            if(array_key_exists($name, $this->data))
                return $this->data[$name];
            return NULL;
         }
         public function __isset($name){
            return isset($this->data[$name]);
         }
         public function __unset($name){
            unset($this->data[$name]);
         }
      }
      $obj = new Test;
      $obj->a = 1;
      echo $obj->a . "\n";
    ?>

程序的运行结果为

> 1

## 2．\_\_construct、\_\_destruct ##

1）\_\_construct 构造函数，实例化对象时被调用。  
2）\_\_destruct 析构函数，当对象被销毁时调用。通常情况下，PHP只会释放对象所占有的内存和相关的资源，对于程序员自己申请的资源，需要显式地去释放。通常可以把需要释放资源的操作放在析构方法中，这样可以保证在对象被释放的时候，程序员自己申请的资源也能被释放。  
例如，可以在构造函数中打开一个文件，然后在析构函数中关闭文件。

<?php 
      class Test
      {
         protected $file = NULL;
         function __construct(){
            $this->file = fopen("test","r");
         }
         function __destruct(){
            fclose($this->file);
         }
      }
    ?>

## 3．\_\_call()和\_\_callStatic() ##

1）\_\_call( $method, $arg\_array )：当调用一个不可访问的方法时会调用这个方法。  
2）\_\_callStatic的工作方式与 \_\_call() 类似，当调用的静态方法不存在或权限不足时，会自动调用\_\_callStatic()。  
使用示例如下：

<?php
          class Test 
          {
             public function __call ($name, $arguments) {
                echo "调用对象方法 '$name' ". implode(', ', $arguments). "\n";
        }
             public static function __callStatic ($name, $arguments) {
                echo "调用静态方法 '$name' ". implode(', ', $arguments). "\n";
             }
          }
          $obj = new Test;
          $obj->method1('参数1');
          Test::method2('参数2');
        ?>

程序的运行结果为

> 调用对象方法 'method1' 参数1  
> 调用静态方法 'method2' 参数2

## 4．\_\_sleep()和\_\_wakeup() ##

1）\_\_sleep 串行化的时候调用。  
2）\_\_wakeup 反串行化的时候调用。  
也就是说，在执行serialize()和unserialize()时，会先调用这两个函数。例如，在序列化一个对象时，如果这个对象有一个数据库连接，想要在反序列化中恢复这个连接的状态，那么就可以通过重载这两个方法来实现。示例代码如下：

<?php
      class Test 
      {
         public $conn;
         private $server, $user, $pwd, $db;
         public function __construct($server, $user, $pwd, $db)
         {
             $this->server = $server;
             $this->user = $user;
             $this->pwd = $pwd;
             $this->db = $db;
             $this->connect();
         }
         private function connect()
         {
            $this->conn = mysql_connect($this->server, $this->user, $this->pwd);
            mysql_select_db($this->db, $this->conn);
         }
         public function __sleep()
         {
            return array('server', 'user', 'pwd', 'db');
         }
         public function __wakeup()
         {
            $this->connect();
         }
         public function __destruct(){
            mysql_close($conn);
         }
      }
    ?>

## 5．\_\_toString() ##

\_\_toString 在打印一个对象时被调用，可以在这个方法中实现想要打印的对象的信息，使用示例如下：

<?php
      class Test
      {
         public $age;
         public function __toString() {
            return "age:$this->age";
         }
      }
      $obj = new Test();
      $obj->age=20;
      echo $obj;
    ?>

程序的运行结果为

> age:20

## 6．\_\_invoke() ##

在引入这个魔术方法后，可以把对象名当作方法直接调用，它会间接调用这个方法，使用示例如下：

<?php
      class Test
      {
         public function __invoke()
         {
            print "hello world";
         }
      }
      $obj = new Test;
      $obj();
    ?>

程序的运行结果为

> hello world

## 7．\_\_set\_state() ##

调用 var\_export 时被调用，用\_\_set\_state的返回值作为var\_export 的返回值。使用示例如下：

<?php
      class People
      {
         public $name;
         public $age;
         public static function __set_state ($arr) {
            $obj = new People;
            $obj->name = $arr['name'];
            $obj->age = $arr['aage'];
            return $obj;
         }
      }
      $p = new People;
      $p->age = 20;
      $p->name = 'James';
      var_dump(var_export($p));
    ?>

程序的运行结果为

People::__set_state(array(
       'name' => 'James',
       'age' => 20,
    ))  NULL

## 8．\_\_clone() ##

这个方法在对象克隆的时候被调用，php提供的\_\_clone()方法对一个对象实例进行浅拷贝，也就是说，对对象内的基本数值类型通过值传递完成拷贝，当对象内部有对象成员变量的时候，最好重写\_\_clone方法来实现对这个对象变量的深拷贝。使用示例如下：

<?php
      class People
      {
         public $age;
         public function __toString() {
            return "age:$this->age \n";
         }
      }
      class MyCloneable
      {
         public $people;
         function __clone()
         {
            $this->people = clone $this->people; //实现对象的深拷贝
         }
      }
      $obj1 = new MyCloneable();
      $obj1->people = new People();
      $obj1->people->age=20;
      $obj2 = clone $obj1;
      $obj2->people->age=30;
      echo $obj1->people;
      echo $obj2->people;
    ?>

程序的运行结果为

> age:20 age:30

由此可见，通过对象拷贝后，对其中一个对象值的修改不影响另外一个对象。

## 9．\_\_autoload() ##

当实例化一个对象时，如果对应的类不存在，则该方法被调用。这个方法经常的使用方法为：在方法体中根据类名，找出类文件，然后require\_one 导入这个文件。由此，就可以成功地创建对象了，使用示例如下：  
Test.php：

<?php 
      class Test { 
        function hello() {
            echo 'Hello world';
        }
      }
    ?>

index.php：

<?php
      function __autoload( $class ) {
        $file = $class . '.php';  
        if ( is_file($file) ) {  
            require_once($file);   //导入文件
        }
      } 
    
      $obj = new Test();
      $obj->hello();
    ?>

程序的运行结果为

> Hello world

在index.php中，由于没有包含Test.php，在实例化Test对象的时候会自动调用\_\_autoload方法，参数$class的值即为类名Test，这个函数中会把Test.php引进来，由此Test对象可以被正确地实例化。  
这种方法的缺点是需要在代码中文件路径做硬编码，当修改文件结构的时候，代码也要跟着修改。另一方面，当多个项目之间需要相互引用代码的时候，每个项目中可能都有自己的\_\_autoload，这样会导致两个\_\_autoload冲突。当然可以把\_\_autoload修改成一个。这会导致代码的可扩展性和可维护性降低。由此从PHP5.1开始引入了spl\_autoload，可以通过spl\_autoload\_register注册多个自定义的autoload方法，使用示例如下：  
index.php

<?php
      function loadprint( $class ) {
        $file = $class . '.php';  
        if (is_file($file)) {  
            require_once($file);  
        } 
      } 
    spl_autoload_register( 'loadprint' );   //注册自定义的autoload方法从而避免冲突
      $obj = new Test();
      $obj->hello();
    ?>

spl\_autoload是\_autoload()的默认实现，它会去include\_path中寻找$class\_name(.php/.inc) 。除了常用的spl\_autoload\_register外，还有如下几个方法：  
1）spl\_autoload：\_autoload()的默认实现。  
2）spl\_autoload\_call：这个方法会尝试调用所有已经注册的\_\_autoload方法来加载请求的类。  
3）spl\_autoload\_functions：获取所有被注册的\_\_autoload方法。  
4）spl\_autoload\_register：注册\_\_autoload方法。  
5）spl\_autoload\_unregister：注销已经注册的\_\_autoload方法。  
6）spl\_autoload\_extensions：注册并且返回spl\_autoload方法使用的默认文件的扩展名。

## 引申：PHP有哪些魔术常量？ ##

除了魔术变量外，PHP还定义了如下几个常用的魔术常量。  
1）\_\_LINE\_\_：返回文件中当前的行号。  
2）\_\_FILE\_\_：返回当前文件的完整路径。  
3）\_\_FUNCTION\_\_：返回所在函数名字。  
4）\_\_CLASS\_\_：返回所在类的名字。  
5）\_\_METHOD\_\_：返回所在类方法的名称。与\_\_FUNCTION\_\_不同的是，\_\_METHOD\_\_返回的是“class::function”的形式，而\_\_FUNCTION\_\_返回“function”的形式。  
6）\_\_DIR\_\_：返回文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录（PHP 5.3.0中新增）。  
7）\_\_NAMESPACE\_\_：返回当前命名空间的名称（区分大小写）。此常量是在编译时定义的（PHP 5.3.0 新增）。  
8）\_\_TRAIT\_\_：返回 Trait 被定义时的名字。Trait 名包括其被声明的作用区域（PHP 5.4.0 新增）。

--------------------

# 六、什么是对象克隆？ #

对于对象而言，PHP用的是引用传递，也就是说，对象间的赋值操作只是赋值了一个引用的值，而不是整个对象的内容，下面通过一个例子来说明引用传递存在的问题：

<?php  
      class My_Class {
        public $color;
      }
      $obj1 = new My_Class ();
      $obj1->color = "Red";
      $obj2 = $obj1;
      $obj2->color ="Blue";     //$obj1->color的值也会变成"Blue"
    ?>

因为PHP使用的是引用传递，所以在执行$obj2 = $obj1后，$obj1和$obj2都是指向同一个内存区（它们在内存中的关系如下图所示），任何一个对象属性的修改对另外一个对象也是可见的。

![clipboard.png][]

在很多情况下，希望通过一个对象复制出一个一样的但是独立的对象。PHP提供了clone关键字来实现对象的复制。如下例所示：

<?php    
        class My_Class {
          public $color;
        }
        $obj1 = new My_Class ();
        $obj1->color = "Red"；
        $obj2 = clone $obj1;
        $obj2->color ="Blue";     //此时$obj1->color的值仍然为"Red"
    ?>

$obj2 = clone $obj1把obj1的整个内存空间复制了一份存放到新的内存空间，并且让obj2指向这个新的内存空间，通过clone克隆后，它们在内存中的关系如下图所示。

![clipboard.png][clipboard.png 1]

此时对obj2的修改对obj1是不可见的，因为它们是两个独立的对象。  
在学习C++的时候有深拷贝和浅拷贝的概念，显然PHP也存在相同的问题，通过clone关键字克隆出来的对象只是对象的一个浅拷贝，当对象中没有引用变量的时候这种方法是可以正常工作的，但是当对象中也存在引用变量的时候，这种拷贝方式就会有问题，下面通过一个例子来进行说明：

<?php    
        class My_Class {
            public $color;
        }
        $c ="Red";
        $obj1 = new My_Class ();
        $obj1->color =&$c;   //这里用的是引用传递
        $obj2 = clone $obj1;  //克隆一个新的对象
        $obj2->color="Blue";  //这时，$obj1->color的值也变成了"Blue"
    ?>

在这种情况下，这两个对象在内存中的关系如下图所示。

![clipboard.png][clipboard.png 2]

从上图中可以看出，虽然obj1与obj2指向的对象占用了独立的内存空间，但是对象的属性color仍然指向一个相同的存储空间，因此当修改了obj2->color的值后，意味着c的值被修改，显然这个修改对obj1也是可见的。这就是一个非常典型的浅拷贝的例子。为了使两个对象完全独立，就需要对对象进行深拷贝。那么如何实现呢，PHP提供了类似于\_\_clone方法（类似于C++的拷贝构造函数）。把需要深拷贝的属性，在这个方法中进行拷贝：使用示例如下：

<?php
        class My_Class {
          public $color;
          public function __clone() {
            $this->color = clone $this->color;
          }
        }
        $c ="Red";
        $obj1 = new My_Class ();
        $obj1->color =&$c;   
        $obj2 = clone $obj1;  
        $obj2->color="Blue";  //这时，$obj1->color的值仍然为"Red"
    ?>

通过深拷贝后，它们在内存中的关系如图1-4所示。

![clipboard.png][clipboard.png 3]

通过在\_\_clone方法中对对象的引用变量color进行拷贝，使obj1与obj2完全占用两块独立的存储空间，对obj2的修改对obj1也不可见。

--------------------

> 自己整理了一篇 **“如果遇到代码怎么改都没效果，怎么办？”**的文章，关注公众号：“ **琉忆编程库**”，回复：“ **问题**”，我发给你。

--------------------

# 七、this、self和parent的区别是什么？ #

this、self、parent三个关键字从字面上比较好理解，分别是指这、自己、父亲。其中，this指的是指向当前对象的指针（暂用C语言里面的指针来描述），self指的是指向当前类的指针，parent指的是指向父类的指针。  
以下将具体对这三个关键字进行分析。

##1．this关键字##
      1 <?php
      2     class UserName {
      3         private $name;    // 定义成员属性
      4         function __construct($name) {
      5             $this->name = $name; // 这里已经使用了this指针
      6         }
      7         // 析构函数
      8         function __destruct() {
      9         }
     10          // 打印用户名成员函数
     11          function printName() {
     12              print ($this->name."\n") ; // 又使用了this指针
     13          }
     14     }
     15     // 实例化对象
     16     $nameObject = new UserName ( "heiyeluren" );
     17     // 执行打印
     18     $nameObject->printName (); // 输出: heiyeluren
     19     // 第二次实例化对象
     20     $nameObject2 = new UserName ( "PHP5" );
     21     // 执行打印
     22     $nameObject2->printName (); // 输出：PHP5
     23 ?>

上例中，分别在5行和12行使用了this指针，那么this到底是指向谁呢？其实，this是在实例化的时候来确定指向谁，例如，第一次实例化对象的时候（16行），当时this就是指向$nameObject 对象，那么执行第12行打印的时候就把print($this->name)变成了print ($nameObject->name)，输出"heiyeluren"。  
对于第二个实例化对象，print( $this- >name )变成了print( $nameObject2->name )，于是就输出了"PHP5"。  
所以，this就是指向当前对象实例的指针，不指向任何其他对象或类。

## 2．self关键字 ##

先要明确一点，self是指向类本身，也就是self是不指向任何已经实例化的对象，一般self用来访问类中的静态变量。

1 <?php
      2      class Counter {
      3          // 定义属性，包括一个静态变量
      4          private  static  $firstCount = 0;
      5          private  $lastCount;
      6          // 构造函数
      7          function __construct() {
      8              // 使用self来调用静态变量,使用self调用必须使用::(域运算符号)
      9              $this->lastCount = ++ selft::$firstCount;
     10          }
     11          // 打印lastCount数值
     12          function printLastCount() {
     13              print ($this->lastCount) ;
     14          }
     15      }
     16       // 实例化对象
     17      $countObject = new Counter ();
     18      $countObject->printLastCount (); // 输出 1
     19 ?>

上述示例中，在第4行定义了一个静态变量$firstCount，并且初始值为0，那么在第9行的时候调用了这个值，使用的是self来调用，中间使用域运算符“::”来连接，这时候调用的就是类自己定义的静态变量$firstCount，它与下面对象的实例无关，只是与类有关，无法使用this来引用，只能使用 self来引用，因为self是指向类本身，与任何对象实例无关。

## 3．parent关键字 ##

parent是指向父类的指针，一般使用parent来调用父类的构造函数。

1 <?php
      2       // 基类
      3       class Animal {
      4           // 基类的属性
      5           public $name; // 名字
      6           // 基类的构造函数
      7           public function __construct($name) {
      8              $this->name = $name;
      9           }
     10       }
     11        // 派生类
     12       class Person extends Animal  // Person类继承了Animal类
     13       {
     14           public $personSex; // 性别
     15           public $personAge; // 年龄
     16           // 继承类的构造函数
     17           function __construct($personSex, $personAge) {
     18                parent::__construct ( "heiyeluren" ); // 使用parent调用了父类的构造函数
     19                $this->personSex = $personSex;
     20                $this->personAge = $personAge;
     21           }
     22           function printPerson() {
     23                print ($this->name . " is " . $this->personSex . ",this year " . $this->personAge) ;
     24           }
     25       }
     26       // 实例化Person对象
     27       $personObject = new Person ( "male", "21" );
     28       // 执行打印
     29       $personObject->printPerson (); // 输出：heiyeluren is male,this year 21
     30 ?>

上例中，成员属性都是public的，特别是父类的，是为了供继承类通过this来访问。第18行： parent::\_\_construct( "heiyeluren" )，使用了parent来调用父类的构造函数进行对父类的初始化，因为父类的成员都是public的，于是就能够在继承类中直接使用 this来访问从父类继承的属性。

--------------------

# 八、抽象类与接口有什么区别与联系？ #

抽象类应用的定义如下：

abstract class ClassName{
    }

抽象类具有以下特点：  
1）定义一些方法，子类必须实现父类所有的抽象方法，只有这样，子类才能被实例化，否则子类还是一个抽象类。  
2）抽象类不能被实例化，它的意义在于被扩展。  
3）抽象方法不必实现具体的功能，由子类来完成。  
4）当子类实现抽象类的方法时，这些方法的访问控制可以和父类中的一样，也可以有更高的可见性，但是不能有更低的可见性。例如，某个抽象方法被声明为protected的，那么子类中实现的方法就应该声明为protected或者public的，而不能声明为private。  
5）如果抽象方法有参数，那么子类的实现也必须有相同的参数个数，必须匹配。但有一个例外：子类可以定义一个可选参数（这个可选参数必须要有默认值），即使父类抽象方法的声明里没有这个参数，两者的声明也无冲突。下面通过一个例子来加深理解：

<?php
        abstract class A{
            abstract protected function greet($name);
        }
        class B extends A {
            public function greet($name, $how="Hello ") {
                echo $how.$name."\n";
            }
        }
        $b = new B;
        $b->greet("James");
        $b->greet("James","Good morning ");
    ?>

程序的运行结果为

Hello James
    Good morning James

定义抽象类时，通常需要遵循以下规则：  
1）一个类只要含有至少一个抽象方法，就必须声明为抽象类。  
2）抽象方法不能够含有方法体。  
接口可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。在PHP中，接口是通过interface关键字来实现的，与定义一个类类似，唯一不同的是接口中定义的方法都是公有的而且方法都没有方法体。接口中所有的方法都是公有的，此外接口中还可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。要实现一个接口，可以通过关键字implements来完成。实现接口的类中必须实现接口中定义的所有方法。虽然PHP不支持多重继承，但是一个类可以实现多个接口，用逗号来分隔多个接口的名称。下面给出一个接口使用的示例：

<?php
      interface Fruit
      {
         const MAX_WEIGHT = 3;   //静态常量
         function setName($name);
         function getName();
      }
    
      class Banana implements Fruit
      {
         private $name;
         function getName() {
            return $this->name;
         }
         function setName($_name) {
            $this->name = $_name;
         }
      }
    
      $b = new Banana(); //创建对象
      $b->setName("香蕉");
      echo $b->getName();
      echo "<br />";
      echo Banana::MAX_WEIGHT;   //静态常量
    ?>

程序的运行结果为

> 香蕉  
> 3

接口和抽象类主要有以下区别：  
抽象类：PHP5支持抽象类和抽象方法。被定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方法和参数，不能定义其具体的功能实现。抽象类通过关键字abstract来声明。  
接口：可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。在这种情况下，可以通过interface关键字来定义一个接口，在接口中声明的方法都不能有方法体。  
二者虽然都是定义了抽象的方法，但是事实上两者区别还是很大的，主要区别如下：  
1）对接口的实现是通过关键字implements来实现的，而抽象类继承则是使用类继承的关键字extends实现的。  
2）接口没有数据成员（可以有常量），但是抽象类有数据成员（各种类型的成员变量），抽象类可以实现数据的封装。  
3）接口没有构造函数，抽象类可以有构造函数。  
4）接口中的方法都是public类型，而抽象类中的方法可以使用private、protected或public来修饰。  
5）一个类可以同时实现多个接口，但是只能实现一个抽象类。

--------------------

**预告：**PHP面试常考内容之面向对象（3）将于本周五（2019.2-15）更新。

以上内容摘自**《PHP程序员面试笔试宝典》**书籍，该书已在[天猫][Link 1]、[京东][Link 2]、[当当][Link 3]等电商平台销售。  
![图片描述][2747446929-5c6128c0d8e8a_articlex]

更多PHP相关的面试知识、考题可以关注公众号获取：**琉忆编程库**  
![图片描述][4018058165-5c6384b2adbbb_articlex]  
**对本文有什么问题或建议都可以进行留言，我将不断完善追求极致，感谢你们的支持。**

[PHP_1]: https://segmentfault.com/a/1190000018118399?_ea=6923332%E3%80%82
[clipboard.png]: /images/20220307/621e354af47f4bd6b130887c47d9bc59.png
[clipboard.png 1]: /images/20220307/4f05d457417e47c59bc10927e2209008.png
[clipboard.png 2]: /images/20220307/f9d8478a04ca49cba78a437e31eb3e14.png
[clipboard.png 3]: /images/20220307/8296273ba38248439f4a7a95a0212941.png
[Link 1]: https://detail.tmall.com/item.htm?spm=a220m.1000858.1000725.26.4af349110GiVv7&id=585807458843&skuId=4611686604234846747&user_id=1049653664&cat_id=2&is_b=1&rn=40dad66eca062850c96e30ac397faefd
[Link 2]: https://item.jd.com/12493342.html
[Link 3]: http://product.dangdang.com/26315140.html
[2747446929-5c6128c0d8e8a_articlex]: /images/20220307/b603f0073ffd46eab5d1dae52e807a4e.png
[4018058165-5c6384b2adbbb_articlex]: /images/20220307/05d85d077cd149298b40cbdc36760aaa.png