php面试题之面向对象(二)

继上一篇“php面试题之面向对象(一)”发表后,今天继续更新。

整个面向对象文章的结构涉及的内容模块有:

一、面向对象与面向过程有什么区别?

二、面向对象有什么特征?

三、什么是构造函数和析构函数?

四、面向对象的作用域范围有哪几种?

五、PHP 中魔术方法有哪些?

六、什么是对象克隆?

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

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

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

在这里插入图片描述

在很多情况下,希望通过一个对象复制出一个一样的但是独立的对象。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指的是指向父类的指针。

以下将具体对这三个关键字进行分析。

1、this关键字


<?php

class UserName {

private $name; // 定义成员属性

function __construct($name) {

$this->name = $name; // 这里已经使用了this指针

}

// 析构函数

function __destruct() {

}

// 打印用户名成员函数

function printName() {

print ($this->name."n") ; // 又使用了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."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 "

";

echo Banana::MAX_WEIGHT; //静态常量

?>

程序的运行结果为

香蕉

3

接口和抽象类主要有以下区别:

抽象类:PHP5支持抽象类和抽象方法。被定义为抽象的类不能被实例化。任何一个类,如果它里面至少有一个方法是被声明为抽象的,那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方法和参数,不能定义其具体的功能实现。抽象类通过关键字abstract来声明。

接口:可以指定某个类必须实现哪些方法,但不需要定义这些方法的具体内容。在这种情况下,可以通过interface关键字来定义一个接口,在接口中声明的方法都不能有方法体。

二者虽然都是定义了抽象的方法,但是事实上两者区别还是很大的,主要区别如下:

1)对接口的实现是通过关键字implements来实现的,而抽象类继承则是使用类继承的关键字extends实现的。

2)接口没有数据成员(可以有常量),但是抽象类有数据成员(各种类型的成员变量),抽象类可以实现数据的封装。

3)接口没有构造函数,抽象类可以有构造函数。

4)接口中的方法都是public类型,而抽象类中的方法可以使用private、protected或public来修饰。

5)一个类可以同时实现多个接口,但是只能实现一个抽象类。

点关注,不迷路

好了各位,以上就是这篇文章的全部内容了,能看到这里的人呀,都是人才。之前说过,PHP方面的技术点很多,也是因为太多了,实在是写不过来,写过来了大家也不会看的太多,所以我这里把它整理成了PDF和文档,如果有需要的可以

点击进入暗号: 思否

在这里插入图片描述

在这里插入图片描述


更多学习内容可以访问【对标大厂】精品PHP架构师教程目录大全,只要你能看完保证薪资上升一个台阶(持续更新)

以上内容希望帮助到大家,很多PHPer在进阶的时候总会遇到一些问题和瓶颈,业务代码写多了没有方向感,不知道该从那里入手去提升,对此我整理了一些资料,包括但不限于:分布式架构、高可扩展、高性能、高并发、服务器性能调优、TP6,laravel,YII2,Redis,Swoole、Swoft、Kafka、Mysql优化、shell脚本、Docker、微服务、Nginx等多个知识点高级进阶干货需要的可以免费分享给大家,需要的可以加入我的PHP技术交流群953224940

评论

暂无评论