标签搜索

PHP面向对象(2)

sunshine
2022-10-11 / 0 评论 / 81 阅读
温馨提示:
本文最后更新于2022年10月11日,已超过734天没有更新,若内容或图片失效,请留言反馈。

1.1 目标

  1. 掌握静态成员的意义和应用;
  2. 掌握self关键字的实际运用;
  3. 了解面向对象的三大特性:封装、继承和多态;
  4. 掌握PHP中继承机制和基本语法;
  5. 掌握访问修饰限定符protected的原理和实际运用;
  6. 掌握重写override的作用和实际应用;
  7. 了解PHP中继承的特点;
  8. 了解静态延迟绑定的作用和使用;
  9. 掌握最终类的作用以及具体的使用方式;
  10. 掌握抽象类的作用以及具体的使用方式;
  11. 掌握接口的作用以及具体的使用方式;

1.2 多态

多态:多种形态。

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

1.2.1 方法重写

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

<?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. 子类修饰的不能比父类更加严格

1560736886382

1560737021928

1.2.2 方法重载

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

1560738378096

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

1.3 面向对象三大特性

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

1.4 私有属性继承和重写

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

<?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
*/

练习一

<?php
class A {
    protected $name='tom';    
    public function showA() {
        echo $this->name,'<br>';
    }
}
class B extends A {
    public $name='berry';
    public function showB() {
        echo $this->name,'<br>';
    }
}
//测试
$obj=new B();
$obj->showA();    //berry
$obj->showB();    //berry

/*
分析:B中将A的$name重写,所以$obj中只有一个$name,($name='berry'),不管$this在哪个方法中访问,就只能访问这个$name
*/

练习二

<?php
class A {
    private $name='tom';    
    public function showA() {
        echo $this->name,'<br>';
    }
}
class B extends A {
    public $name='berry';
    public function showB() {
        echo $this->name,'<br>';
    }
}
//测试
$obj=new B();
$obj->showA();    //tom
$obj->showB();    //berry
/*
分析:
$obj中有两个$name,一个是私有的,一个是公有的
在showA()中既能访问私有的$name,也能访问公有的$name,但是私有的比公有的权限高,所以输出tom
在showB()中不能访问私有的$name,只能访问公有的$name,所以输出berry
*/

1.5 方法修饰符

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

1.5.1 static【静态的】

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

练习:统计在线人数

<?php
class Student {
    private static $num=0;    //静态变量,在内存中就一份
    public function __construct() {
        self::$num++;      //self表示所在类的类名
    }
    public function __destruct() {
        self::$num--;
    }
    public function show() {
        echo '总人数是:'.self::$num,'<br>';
    }
}
//测试
$stu1=new Student;
$stu2=new Student;
$stu3=new Student;
$stu2->show();            //总人数是:3
unset($stu2);
$stu3->show();            //总人数是:2

注意:self表示所在类的类名,使用self降低耦合性

静态成员也可以被继承

<?php
class Person {
    public static $add='中国';
    public static function show() {
        echo '这是人类<br>';
    }
}
//继承
class Student extends Person {    
}
//测试
echo Student::$add,'<br>';        //中国   通过子类名称访问父类的静态成员
Student::show();                //这是人类

静态延时绑定

static表示当前对象所属的类

<?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有两个作用,第一表示静态的,第二表示类名

1.5.2 final【最终的】

final修饰的方法不能被重写

final修饰的类不能被继承

1560743854237

1560743910916

作用

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

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

1.5.3 abstract【抽象的】

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

例题

<?php
//抽象类
abstract class Person {
    public abstract function setInfo();    //抽象方法
    public function getInfo() {
        echo '获取信息<br>';
    }
}
//继承
class Student extends Person {
    //重写实现父类的抽象方法
    public function setInfo() {
        echo '重新实现父类的抽象方法<br>';
    }
}
//测试
$stu=new Student;
$stu->setInfo();        //重新实现父类的抽象方法
$stu->getInfo();        //获取信息

抽象类的作用:

1定义命名规范

1560753765133

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

1.6 类常量

类常量是const常量

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

问题:define常量和const常量的区别?

答:const常量可以做类成员,define常量不可以做类成员。

问题:常量和静态的属性的区别?

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

​ 不同点:常量的值不可以更改,静态属性的值可以更改

1.7 接口(interface)

1.7.1 接口

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

1.7.2 接口的多重实现

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

<?php
interface IPic1 {
    function fun1();
}
interface IPic2 {
    function fun2();
}
//接口允许多重实现
class Student implements IPic1,IPic2 {
    public function fun1() {
        
    }
    public function fun2() {
        
    }
}

注意:

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

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

class Student extends Person implements IPIc1,IPic1{
    
}

1.8 匿名类

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

<?php
$stu=new class {
    public $name='tom';
    public function __construct() {
        echo '构造函数<br>';
    }
};
echo $stu->name;
/*运行结果;
构造函数
tom
*/

小结:

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

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

1.9 方法绑定

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

作用:将方法绑定到对象上,并调用

语法:

闭包->call(对象):将闭包绑定到对象上,并调用

在PHP中匿名函数称为闭包

例题

<?php
$lang='en';
//类
class Student{
}
//匿名函数
if($lang=='ch'){
    $fun=function(){
        echo '我是一名学生';
    };
}else{
    $fun=function(){
        echo 'i am a studnet';
    };
}
//绑定
$stu=new Student;
$fun->call($stu);    //i am a studnet

1.10 异常处理

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

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

1.10.1 使用的关键字

try:监测代码块
catch:捕获异常
throw:抛出异常
finally:无论有无异常都会执行,可以省略
Exception:异常类

语法结构

try{
    //检测代码
}catch(Exception $ex){
    //捕获异常
}
finally{
    //不论是否有异常,都要执行,finally可以省略
}

例题:

<?php
if(isset($_POST['button'])) {
    try{
        $age=$_POST['age'];
        if($age=='')
            throw new Exception('年龄不能为空',1001);    //抛出异常
        if(!is_numeric($age))
            throw new Exception('年龄必须是数字',1001);    //抛出异常
        if(!($age>=10 && $age<=30)) 
            throw new Exception('年龄必须在10-30之间',1002);    //抛出异常
        echo '您的年龄合适';
    }catch(Exception $ex){        //捕获异常
        echo '错误信息:'.$ex->getMessage(),'<br>';
        echo '错误码:'.$ex->getCode(),'<br>';
        echo '文件地址:'.$ex->getFile(),'<br>';
        echo '错误行号:'.$ex->getLine(),'<br>';
    }
    finally{
        echo '关闭数据库连接';  //不管是否有异常,finally都要执行
    }
}
?>
<form method="post" action="">
    年龄: <input type="text" name="age"> <br />
    <input type="submit" name="button" value="提交">
</form>

注意:抛出异常后,try块终止执行,执行权限交给catch块.

运行结果

1560759058383

1.8.2 自定义异常

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

自定义三种异常即可

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

<?php
//自定义空异常类
class MyNullException extends Exception {
}
//自定义类型异常
class MyTypeException extends Exception {
}
//自定义范围异常
class MyRangeException extends Exception {
}
//逻辑代码
if(isset($_POST['button'])) {
    try{
        $name=$_POST['name'];
        $age=$_POST['age'];
        if($name=='')
            throw new MyNullException('姓名不能为空');
        if($age=='')
            throw new MyNullException('年龄不能为空');
        if(!is_numeric($age))
            throw new MyTypeException('年龄不是数字');
        if($age<10 || $age>30)
            throw new MyRangeException('年龄必须在10-30之间');
        echo '姓名:'.$name,'<br>';
        echo '年龄:'.$age;
    }catch(MyNullException $ex){
        echo $ex->getMessage(),'<br>';
        echo '错误记录在日志中';
    }catch(MyTypeException $ex){
        echo $ex->getMessage(),'<br>';
        echo '发送电子邮件';
    }catch(MyRangeException $ex){
        echo $ex->getMessage(),'<br>';
        echo '给管理员打电话';
    }

}
?>
<form method="post" action="">
    姓名: <input type="text" name="name"> <br />
    年龄: <input type="text" name="age"> <br />
    <input type="submit" name="button" value="提交">
</form>

1.9 练习

1、打印图像

<body>
<style type="text/css">
    body{
        text-align:center;
        font-size:25px;
    }
    span{
        width:30px;
        height:10px;
        display:inline-block;
    }
</style>
<?php
for($i=1;$i<=9;$i++){
    $n=$i>5?(10-$i):$i;
    $k=2*$n-1;            //星星的个数
    for($j=1;$j<=$k;$j++){
        echo '<span>*</span>';
    }
    echo '<br>';
}
?>
</body>

1560760166882

2、打印回形

<body>
<style type="text/css">
    body{
        text-align:center;
        font-size:25px;
    }
    span{
        width:30px;
        height:10px;
        display:inline-block;
    }
</style>
<?php
for($i=1; $i<=10; $i++) {
    for($j=1; $j<=10; $j++) {
        if($i>=3 && $i<=8 && $j>=3 && $j<=8)
            echo '<span></span>';
        else
            echo '<span>*</span>';
    }
    echo '<br>';
}
?>
</body>

1560760212372

感觉很棒,欢迎点赞 OR 打赏~
1
分享到:

评论 (0)

取消