当前位置:首页 > php面试题 > 正文

php面试之面向对象的相关知识(下篇)

01-12 php面试题 博客


面向对象分上下篇,这里下篇涉及到的内容有:六、什么是对象克隆?  七、this、self和parent的区别是什么?  八、抽象类与接口有什么区别与联系?  九、PHP面向对象的常考面试题讲解

六、什么是对象克隆?
对于对象而言,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都是指向同一个内存区(它们在内存中的关系如下图所示),任何一个对象属性的修改对另外一个对象也是可见的。

在很多情况下,希望通过一个对象复制出一个一样的但是独立的对象。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克隆后,它们在内存中的关系如下图所示。

此时对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"

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

从上图中可以看出,虽然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所示。

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

七、this、self和parent的区别是什么?
this、self、parent三个关键字从字面上比较好理解,分别是指这、自己、父亲。其中,this指的是指向当前对象的指针(暂用C语言里面的指针来描述),self指的是指向当前类的指针,parent指的是指向父类的指针。
以下将具体对这三个关键字进行分析。
##this关键字##
<?php
class UserName {
	private $name;    // 定义成员属性
	function __construct($name) {
		$this->name = $name; // 这里已经使用了this指针
	}
	
	// 析构函数
	function __destruct() {
	
	}
	
	// 打印用户名成员函数
    function printName() {
        print ($this->name."
") ; // 又使用了this指针
    }
	
}

// 实例化对象
$nameObject = new UserName ( "heiyeluren" );
// 执行打印
$nameObject->printName (); // 输出: heiyeluren
// 第二次实例化对象
$nameObject2 = new UserName ( "PHP5" );
// 执行打印
$nameObject2->printName (); // 输出:PHP5
 ?>
上例中,分别在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用来访问类中的静态变量。
<?php
     class Counter {
          // 定义属性,包括一个静态变量
          private  static  $firstCount = 0;
          private  $lastCount;
		  
          // 构造函数
          function __construct() {
              // 使用self来调用静态变量,使用self调用必须使用::(域运算符号)
              $this->lastCount = ++ selft::$firstCount;
          }

          // 打印lastCount数值
          function printLastCount() {
              print ($this->lastCount) ;
          }

      }

       // 实例化对象
      $countObject = new Counter ();
      $countObject->printLastCount (); // 输出 1

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

3.parent关键字
parent是指向父类的指针,一般使用parent来调用父类的构造函数。
<?php
// 基类

class Animal {

	// 基类的属性
	public $name; // 名字

	// 基类的构造函数
	public function __construct($name) {
        $this->name = $name;

    }

}

// 派生类
class Person extends Animal  // Person类继承了Animal类
{
    public $personSex; // 性别
	public $personAge; // 年龄
	
	// 继承类的构造函数
	function __construct($personSex, $personAge) {

        parent::__construct ( "heiyeluren" ); // 使用parent调用了父类的构造函数
        $this->personSex = $personSex;
        $this->personAge = $personAge;
    }

    function printPerson() {

        print ($this->name . " is " . $this->personSex . ",this year " . $this->personAge) ;
    }

}

// 实例化Person对象
$personObject = new Person ( "male", "21" );

// 执行打印
$personObject->printPerson (); // 输出:heiyeluren is male,this year 21

?>
上例中,成员属性都是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."
";
        }

    }

    $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自学中心 感谢阅读!