PHP面向对象

前言

自从php进入5.0版本以来,PHP开始全面地支持面向对象编程。嗯,谁说php很low。我们专注web开发好不好;谁说php代码烂,自己水平不行写的代码当然烂了;谁说php框架不优雅的,你用过laravel吗。好了,进入正题,面向对象的三大特性分别是封装性,继承性以及多态性,使用面向对象开发,让我们的程序可维护以及扩展性大大提高。

基本知识

:具有相同属性或方法的一类集合体。比如雪佛兰汽车是一个雪佛兰汽车类,奔驰汽车是一个奔驰汽车类,宝马汽车是一个宝马汽车类,而这三个类又是汽车大类的子类。

对象:类的一个具体实现,比如宝马Q5就是宝马汽车类的一个具体实现。对象地使用是放在内存中的。一下让我们了解一下对象在内存中的分配


使用面向对象,就是灵活地使用以上两个知识点。让我们来创建和使用类与对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
/**
*新建一个类
*/
class newClass{
public $a;
public $b;
public function funA(){
echo "I am function A";
}
public function funB(){
echo "I am function B";
}
}
/**
*使用类创建对象
*/
$opt=new newClass();
$opt->a="opt";//将opt对象中的a属性赋值为opt
$opt->funA();//打印出"I am function A"
?>

修饰符:在定义类与类中的属性时,我们可以使用如下三个修饰符,若不加,则默认为public
public:权限最大
protected:权限范围在其本身与其子类
private:权限范围仅在其本身

构造函数与析构函数:在我们对类实例化创建对象时,往往需要对对象进行初始化,这时,我们就需要在类中定义一个构造方法。当我们使用完对象时,就需要释放对象,以减少内存的使用,这时我们就需要使用析构方法。
在php中我们使用__construct()方法与__destruct(),如下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
class newClass{
public $a;
public $b;
public function __construct($a,$b){
$this->a=$a;
$this->b=$b;
echo "我是构造函数";
}
public function __destruct(){
echo "我是析构函数";
}
}
?>

封装性

当我们开发一些重要的程序模块时,常常不希望别人能轻易访问这些程序模块的数据,因此需要对这些数据进行封装。这时我们要进行数据的访问控制,常常使用private关键字来对这些属性与方法进行封装。
如下

1
2
3
4
5
6
7
8
9
<?php
class privateClass{
private $a;
private $b;
private function privateFun(){
echo "我是封装的方法";
}
}
?>

这样,当我们创建对象时就不能调用私有的属性与方法。但是我们可以通过使用魔术方法来对这些私有属性与方法进行访问。

__set()与__get()的使用
通过__set()方法我们可以通过对象直接设置成员属性值
通过__get()方法我们可以通过对象直接获取成员属性值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
class setClass{
private $a;
private $b="ww";
public function __set($oldValue,$newvalue){
$this->$oldValue=$newvalue;
}
public function __get($newvalue){
return $newvalue;
}
}
$opt= new setClass();
$opt->a="sss";//直接设置私有属性值
echo $opt->b;//直接读取私有属性值
?>

__isset()与__unset()的使用
通过__isset()直接查看对象中私有属性是否存在
通过__unset()直接删除对象中的私有属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
class issetClass{
private $a;
private $b='www';
function __isset($privateName){
if(isset($privateName)){
return 1;
}
else{
return 0;
}
}
function __unset($privateName){
echo "销毁".$privateName;
}
}
$opt = new issetClass();
echo isset($opt->$b);
var_dump(unset($opt->$b));
?>

继承性

当我们编写多个类时,常常多个类具有相同的属性与方法,为了简化代码我们引入了继承的概念,子类可以继承父类的一些属性与方法,减少了冗余代码地编写。


  1. 如何编写继承类
    我们使用关键字extends来编写子类

    1
    2
    3
    4
    5
    6
    7
    8
    <?php
    class parentClass{

    }
    class childClass extends parentClass{

    }
    ?>

    如上,childClass是parentClass的子类,php仅支持单继承,即一个子类只有一个父类,但父类可以有多个子类。

  2. 重写父类方法
    当父类中的方法不能满足子类的使用时我们可以重写父类方法。但当我们又想在子类使用父类的方法时,我们可以使用如下语法:parent::方法名
  3. 几个重要的关键字
    3.1 final
    final可以修饰类与方法,不能修饰成员属性;
    被final修饰的类不能继承,而用final修饰的方法在子类中不能被重写
    3.2 static
    static可以修饰成员属性与成员方法,不能修饰类;
    使用static修饰的成员与方法可以通过类直接使用,使用如下语法:类名::\$属性名或方法名();
    在类中使用时通过如下语法:self::\$属性名或方法名.
    3.3 const
    在类中声明常量使用const,而不是使用define();
    比如 const TT=90
    当使用常量时直接使用如下语法self::常量名
    3.4 instanceof
    使用该关键字可以检测某个实例是否是某个类的实例。
    3.5 trait
    php只能进行单继承,但它同时提供了另类方式来进行代码复用,解决单继承问题。
    如下
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <?php
    trait testA{
    function a(){}
    }
    trait testB{
    function b(){}
    }
    class testC{
    use testA,testB;
    function c(){}
    }
    ?>

抽象技术

用abstract关键字修饰的方法与类称为抽象方法或抽象类。
声明抽象类与抽象方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
abstract class testClass{
$a;
$b;
abstract function testFun();
abstract function testFun1();
public function optFun(){
echo "抽象类中的抽象方法";
}//抽象类可以有非抽象方法
}
class childClass extends testClass{
function testFun(){
echo "子类中实现抽象方法";
}
function testFun1(){
echo "子类实现抽象方法";
}
}
abstract child1Class extends testClass{

}//子类是抽象方法可以不实现父类的抽象方法
?>

抽象技术为子类的声明提供了一种规范,限制了类的实例化(抽象类不能实例化)。

接口技术

接口是一种特殊的抽象类,接口中只能声明抽象类与常量
声明接口使用interface,实现接口使用implements,修饰符只能是默认的public;
一个子类可以继承多个接口,同时继承一个父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?php
interface newInterface{
const V=12;
abstract function fun1();
abstract function fun2();
}
interface newInterface1{
abstract function fun3();
abstract function fun4();
}
class parentClass{
function fun5(){
echo "fun5";
}
}
class optClass extends parentClass implements newInterface,newINterface1{
function fun1(){
echo "fun1";
}
function fun2(){
echo "fun2";
}
function fun3(){
echo "fun3";
}
function fun4(){
echo "fun4";
}
}
?>

多态

在php中多态地实现需要一个类通过多个子类地继承实现,如果一个类的方法在多个子类中重写并实现不同的功能,我们称之为多态。