什么是对象克隆？
对于对象而言，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"
?>
通过深拷贝后，它们在内存中的关系
通过在__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）一个类可以同时实现多个接口，但是只能实现一个抽象类。
终于做了个全面的总结：关于面试掌握的基础技能。