1 多态

多态：多种形态。

多态分为两种：方法重写和方法重载

1.1 方法重写

子类重写了父类的同名的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
//父类
class Person {
    public function show() {
        echo '这是父类<br>';
    }
}
//子类
class Student extends Person {
    //子类重写了父类的同名方法
    public function show() {
        echo '这是子类<br>';
    }
}
//测试
$stu=new Student;
$stu->show();           //这是子类

注意事项：

  1. 子类的方法必须和父类的方法同名
  2. 参数个数要一致
  3. 子类修饰的不能比父类更加严格

1.2 方法重载

在同一个类中，有多个同名的函数，通过参数的不同来区分不同的方法，称为方法重载

💡 注意：PHP不支持方法重载，但是PHP可以通过其他方法来模拟方法重载。

2面向对象三大特性

  1. 封装
  2. 继承
  3. 多态

3 私有属性继承和重写

私有属性可以继承但不能重写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
class A {
    private $name='PHP';
    public function showA() {
        //var_dump($this);  //object(B)#1 (2) { ["name":"B":private]=> string(4) "Java" ["name":"A":private]=> string(3) "PHP" }
        echo $this->name,'<br>';    //PHP
    }
}
class B extends A {
    private $name='Java';
    public function showB() {
        //var_dump($this);  //object(B)#1 (2) { ["name":"B":private]=> string(4) "Java" ["name":"A":private]=> string(3) "PHP" }
        echo $this->name,'<br>';    //Java
    }
}
$obj=new B();
$obj->showA();
$obj->showB();
/*分析：
showA()和showB()中的$this都表示B的对象，B中继承了A的私有属性，所以B中有两个$name.
在showA()中只能访问A中的$name，不能访问B中的$name
在showB()中只能访问B中的$name,不能访问A中的$name
*/

4 方法修饰符

方法修饰符有：static、final、abstract

4.1 static【静态的】

  1. static修饰的属性叫静态属性、static修饰的方法叫静态方法
  2. 静态成员加载类的时候分配空间，程序执行完毕后销毁
  3. 静态成员在内存中就一份。
  4. 调用语法 类名::属性 类名::方法名()
1
2
3
4
5
6
7
8
9
<?php
class Person {
    public static $add='北京';    // 修饰符之间没有顺序
    static public function show() {
        echo '这是一个静态的方法<br>';
    }
}
echo Person::$add,'<br>';       //北京
Person::show();                 //这是一个静态的方法

💡 注意：self表示所在类的类名，使用self降低耦合性

静态成员也可以被继承

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
class Person {
    public static $add='中国';
    public static function show() {
        echo '这是人类<br>';
    }
}
//继承
class Student extends Person {
}
//测试
echo Student::$add,'<br>';      //中国   通过子类名称访问父类的静态成员
Student::show();                //这是人类

静态延时绑定

static表示当前对象所属的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
class Person {
    public static $type='人类';
    public function show1() {
        //var_dump($this);      //object(Student)#1 (0) { }
        //echo self::$type,'<br>';  //人类
        echo static::$type,'<br>';          //学生   延时绑定
    }
}
class Student extends Person {
    public static $type='学生';
    public function show2() {
        //var_dump($this);      //object(Student)#1 (0) { }
        //echo self::$type,'<br>';  //学生
        echo static::$type,'<br>';          //学生
    }
}
//测试
$obj=new Student();
$obj->show1();
$obj->show2();

小结：

1、static在内存中就一份，在类加载的时候分配空间

2、如果有多个修饰符，修饰符之间是没有顺序的

3、self表示所在类的类名

4、static表示当前对象所属的类

5、static有两个作用，第一表示静态的，第二表示类名

4.2 final【最终的】

final修饰的方法不能被重写

final修饰的类不能被继承

4.2.1 作用

1、如果一个类确定不被继承，一个方法确定不会被重写，用final修饰可以提高执行效率。

2、如果一个方法不允许被其他类重写，可以用final修饰。

4.3 abstract【抽象的】

  1. abstract修饰的方法是抽象方法，修饰的类是抽象类
  2. 只有方法的声明没有方法的实现称为抽象方法
  3. 一个类中只要有一个方法是抽象方法，这个类必须是抽象类。
  4. 抽象类的特点是不能被实例化
  5. 子类继承了抽象类，就必须重新实现父类的所有的抽象方法，否则不允许实例化
  6. 类中没有抽象方法也可以声明成抽象类，用来阻止类的实例化

4.3.1 抽象类的作用

1、定义命名规范

2、阻止实例化，如果一个类中所有的方法都是静态方法，这时候没有必要去实例化，可以通过abstract来阻止来的实例化。

5 类常量

类常量是const常量

1
2
3
4
5
6
<?php
class Student {
    //public const ADD；     //7.1以后才支持访问修饰符
    const ADD='地址不详';
}
echo Student::ADD;

问题：define常量和const常量的区别？

答：const常量可以做类成员，define常量不可以做类成员。

问题：常量和静态的属性的区别？

答：相同点：都在加载类的时候分配空间

不同点：常量的值不可以更改，静态属性的值可以更改

6 接口（interface）

6.1 接口

  1. 如果一个类中所有的方法是都是抽象方法，那么这个抽象类可以声明成接口
  2. 接口是一个特殊的抽象类，接口中只能有抽象方法和常量
  3. 接口中的抽象方法只能是public，可以省略，默认也是public的
  4. 通过implements关键字来实现接口
  5. 不能使用abstract和final来修饰接口中的抽象方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
//声明接口
interface IPerson {
    const ADD='中国';
    function fun1();
    function fun2();
}
//接口实现
class Student implements IPerson {
    public function fun1() {

    }
    public function fun2() {

    }
}
//访问接口中的常量
echo IPerson::ADD;

6.2 接口的多重实现

类不允许多重继承，但是接口允许多重实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
interface IPic1 {
    function fun1();
}
interface IPic2 {
    function fun2();
}
//接口允许多重实现
class Student implements IPic1,IPic2 {
    public function fun1() {

    }
    public function fun2() {

    }
}

注意：

1、在接口的多重实现中，如果有同名的方法，只要实现一次即可

2、类可以继承的同时实现接口

1
2
3
class Student extends Person implements IPIc1,IPic1{

}

7 匿名类

这是了解的内容，PHP7.0支持

1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stu=new class {
    public $name='tom';
    public function __construct() {
        echo '构造函数<br>';
    }
};
echo $stu->name;
/*运行结果；
构造函数
tom
*/

小结：

1、如果类只被实例化一次就可以使用匿名类

2、好处，在执行的过程中，类不占用空间

8 方法绑定

这是了解的内容，PHP7.0支持

1
2
3
4
5
6
7
8
9
10
11
12
<?php
$stu=new class {
    public $name='tom';
    public function __construct() {
        echo '构造函数<br>';
    }
};
echo $stu->name;
/*运行结果；
构造函数
tom
*/

小结：

1、如果类只被实例化一次就可以使用匿名类

2、好处，在执行的过程中，类不占用空间

9 异常处理

集中处理在代码块中发生的异常。

在代码块中发生了异常直接抛出，代码块中不处理异常，将异常集中起来一起处理。

9.1 使用的关键字

1
2
3
4
5
try:监测代码块
catch:捕获异常
throw:抛出异常
finally:无论有无异常都会执行，可以省略
Exception：异常类

语法结构

1
2
3
4
5
6
7
8
try{
	//检测代码
}catch(Exception $ex){
	//捕获异常
}
finally{
	//不论是否有异常，都要执行，finally可以省略
}

9.2 自定义异常

场景：如果实现异常的分类处理？比如异常有三个级别异常对应三种处理方式

自定义三种异常即可

所有异常类的父类是Exception，Exception中的方法不允许重写

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章
博客近期分类标签归档
项目开源库
社交友链留言板
更多关于本站GitHub

本站由 RuntimeBroker 使用 Stellar 主题创建。
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议，转载请注明出处。

本"页面"访问 次 | 👀总访问 次 | 总访客 人