PHP基础：PHP抽象类和接口、类的重载和方法的重载

静态继承

<?php
// 1、静态成员 （属性和方法）
class Shop{
    public static $title='苹果13PRO';
    public $price;
    public $num1=1;
    public static $num2=1;
//构造 给与静态成员默认值会报错
//使用静态成员没有经过构造方法
    public function __construct($title,$price)
    {
        $this->title =$title;
        $this->price =$price;
//        普通成员变量，每次从头开始计算
        $this->num1++;
//        静态变量成员调用一次，就会增加1
//        静态成员为本类调用，为所有实例共享
//        存在内存中，只要使用了改变了它的值，它会在内存中保存改变后的数据
        self::$num2++;
    }
    public static function vedio($tit){
//        静态成员用self 代表本类 Shop， 普通方法用$this
        return '看视频手机：'. self::$title . $tit;
    }
}
class Son extends Shop
{
// 静态也能被继承
}
/*
 * 静态化成员的优缺点
 * 1、存在多个实例，静态成员在内存中，只占一份
 * 2、静态成员 执行效率比 实例化高
 *
 * 缺点
 * 静态成员不能自动销毁 实例化会自动销毁
*/
echo Son::vedio('!厉害了！'); //看视频手机：苹果13PRO!厉害了！

抽象类

/* 2、抽象类
 * （多态的一种，静态也是多态的一种）
 * 抽象类 用于描述一些十五所具有的特性和行为 但是没有具体实现
 * 抽象有类 也有方法  abstract
 * */
abstract class Person
{
    abstract  public  function  say();
    abstract  public  function  eat();
    //抽象方法
}
//new Person(); Cannot instantiate abstract class Person
//抽象类不能被实例化的，不能生产出来对象
//抽象类继承抽象类
abstract class Chinese extends Person
{
    protected $name;
    //构造方法也可以在抽象类里使用
    public function __construct($name)
    {
        $this->name =$name;
    }
// 抽象类里是可以有普通方法的
    public  function  say(){
        return $this->name . '我是中国人，我说汉语';
    }
}
//架构师 把项目架起来，在做很多抽象类，你写的代码必须继承抽象类
//有多少个抽象方法就继承多少个抽象方法
// 如果继承了抽象类，不能把所有的方法重写，只能自己也是抽象类
class Anhui extends Chinese
{
    public  function  eat(){
        return $this->name . '我是中国人，我吃中国菜';
    }
}
$obj =new Anhui('小明');
echo $obj->say();//小明我是中国人，我说汉语
echo '<hr />';
echo $obj->eat(); //小明我是中国人，我吃中国菜
// 抽象类 设计类和实现类是分离的 可以为子类提供 公用的方法 作为子类重写模板来使用

类常量 const

class App
{
    // const 常量关键词
    const APP_NAME='PHP';
    public function  get_name(){
        return self::APP_NAME;//调用常量
    }
}
///常量不能实例化访问
echo App::APP_NAME; //静态访问方式
$obj = new App();
echo $obj->get_name();
//常量会当成静态成员进行访问

接口

接口

//也是多态的一种，不管是普通还是抽象，都是单继承，就是一个子类只能继承一个父类
// interface 关键词 创建 替换class
interface File
{
    //接口只能声明两种成员 常量 抽象方法
    const APP_NAME='中小学教育部';
    //接口的方法本身就是抽象的不能放abstract
    public  function no_ke($o,$t);
    public  function no_ye(...$param);
}
interface Guojia
{
    //接口里可以用静态方法
    public  static function no_tifa($param);
}
// 接口不能继承
// 实现接口implements
class Teacher implements File,Guojia{
    public  function no_ke($o,$t){
        return $o . $t;
    }
    public  function no_ye(...$param){
        return print_r($param);
    }
    // 接口有静态成员，重写也要用静态
    public static function no_tifa($param){
        return $param;
    }
}
$obj = new Teacher();
echo $obj->no_ke('补课?','不补课!'); //补课?不补课!
echo '<hr />';
echo $obj->no_ye('作业?','没有作业!','不能留作业!');
//Array ( [0] => 作业? [1] => 没有作业! [2] => 不能留作业! ) 1
echo '<hr />';
//echo $obj->no_tifa('不能体罚!'); //不能体罚!
//静态成员不要实例化
echo Teacher::no_tifa('不能体罚!');//不能体罚!

示例

abstract class Computer
{
   const APP_NAME="Win11 电脑";
   abstract public function install($param);
}
interface Plugo{
    public function install_o($param);
}
interface Plugt{
    public function install_t($param);
}
class VScode extends Computer implements Plugo,Plugt{
    public function install($param){
        return '安装成功：'.$param;
    }
    public function install_o($param){
        return '安装成功：'.$param;
    }
    public function install_t($param){
        return '安装成功：'.$param;
    }
}
$obj = new VScode();
echo $obj->install("vscode");
echo '<br />';
echo $obj->install_o("插件1");
echo '<br />';
echo $obj->install_t("插件2");

后期静态绑定

//后期静态绑定 延迟静态绑定  静态::访问类 就是后期
// 关键词 static
class A{
    public static function test(){
        return 'A';
    }
    public function show(){
        //return $this->test();
        return static::test();
    }
}
class B extends A{
    public static function test(){
        return 'B';
    }
}
$a =new A();
//实例化A 用a请求$this 先找A
echo $a->show();
echo '<hr />';
$b =new B();
//实例化B 找B
echo $b->show();

魔术方法

__destruct 析构方法

class A{
    public $name;
    public function  __construct($name)
    {
        $this->name=$name;
    }
    public function __destruct()
    {
        echo '执行完成';
        //可以执行很多代码 比如unset
    }
}
$a= new A('明明');
echo $a->name;
$name=$a->name;
echo '<hr />';
unset($a);
echo '<hr />';
//$name=$a->name;
echo $name;

析构方法

属性重载 get

class People{
    //私有的 受保护的都可以使用
    private $name;
    protected $age;
    protected $height;
    public function __construct($name,$age,$height)
    {
        $this->name=$name;
        $this->age=$age;
        $this->height=$height;
    }
    public function __get($n){
        //__get 参数是 我们要找的成员名字，外面找name 返回name
//        return $this->name;
        //要找name $n就是name  $this->$n 相当于 $this->name
        if($n=='name'||$n=='age'){
            return $this->$n;
        }
        //empty 没有值也会当成真
        if(empty($this->$n)){
            return $n.',你访问的成员不存在!';
        }
        return $n.',你访问的成员不能访问!';
    }
}
$obj = new People('明明',18,180);
echo $obj->name;
echo '<hr />';
echo $obj->age;
echo '<hr />';
echo $obj->height;  //height,你访问的成员不能访问!

set 修改

class People{
    //私有的 受保护的都可以使用
    private $name;
    protected $age;
    protected $height;
    public function __construct($name,$age,$height)
    {
        $this->name=$name;
        $this->age=$age;
        $this->height=$height;
    }
    public function __get($n){
        //__get 参数是 我们要找的成员名字，外面找name 返回name
//        return $this->name;
        //要找name $n就是name  $this->$n 相当于 $this->name
        if($n=='name'||$n=='age'){
            return $this->$n;
        }
        //empty 没有值也会当成真
        if(empty($this->$n)){
            return $n.',你访问的成员不存在!';
        }
        return $n.',你访问的成员不能访问!';
    }
    //设置需要两个参数
    public function __set($key,$value){
//        print_r($key.'----'.$value);
        //通过返回$this 的key =要修改的值
        return $this->$key=$value;
    }
}
$obj = new People('花花',25,160);
echo $obj->age;
echo '<hr />';
$obj ->age =26;
echo '<hr />';
echo $obj->age;

方法重载

//方法重载 __call 访问未定义的方法时，触发
class People{
    //call 有两个参数
    public function __call($key,$value){
        // $key 第一个参数是访问的方法
        //$value 第二个参数是方法的传值
//        print_r($key); //add
//        print_r($value);//Array ( [0] => 10 [1] => 20 [2] => 30 [3] => 40 )
//        return 1;
        //方法重载是为了提醒和处理错误信息
//        if($key=='add')
//        {
//            $num=0;
//            foreach ($value as $v){
//                $num +=$v;
//            }
//            return $num;
//        }
        return '方法名：'.$key.'<br> 方法参数：<pre>'.print_r($value,true).'</pre>';
    }
}
$obj = new People();
echo $obj->add(10,20,30,40);

静态重载 callStatic

class People{
    //callStatic 静态触发 要用静态方法
    public static function __callStatic($key,$value){
        return '方法名：'.$key.'<br> 方法参数：<pre>'.print_r($value,true).'</pre>';
//
    }
}
//静态处理不能用普通方式来执行
//$obj = new People();
//echo $obj->add(10,20,30,40);
//没有静态方法就会执行模式方法__callStatic
echo People::add(100,200,300);

汇总

关键词	类外声明	声明类	声明属性	声明方法	解释
const	√		√		定义类常量
extends		√			扩展类，用一个类去扩展它的父类
public			√	√	公用属性或方法
protected			√	√	私有属性或方法
private			√	√	受保护的属性或方法
static		备注1	√	√	静态成员
abstract		√	备注2	√	抽象类或方法
interface		√			创建接口
implements		√			实现接口
final		√		√	类不能被继承
parent::					访问父类
$this->					访问本类
self::					访访问本类静态
static::					后期静态绑定
namespace	√				创建命名空间

备注1：老师课件显示static可以声明类，我试了下发现不能用，先去掉
备注2：老师课件中abstract 可以声明属性，应该是可以声明抽象方法

其他魔术方法

方法	描述
`__construct`	构造方法，实例类的时候，自动调用
`__destruct`	析构方法，类执行完后，自动调用
`__call`	在对象中调用一个不可访问方法时调用
`__callStatic`	用静态方式中调用一个不可访问方法时调用
`__get`	获得一个类的成员变量时调用
`__set`	设置一个类的成员变量时调用
`__isset`	当对不可访问属性调用 isset()或 empty()时调用
`__unset`	当对不可访问属性调用 unset()时被调用
`__sleep`	执行 serialize()时，先会调用这个函数
`__wakeup`	执行 unserialize()时，先会调用这个函数
`__toString`	类被当成字符串时的回应方法
`__invoke`	调用函数的方式调用一个对象时的回应方法
`__set_state`	调用 var_export()导出类时，此静态方法会被调用
`__clone`	当对象复制完成时调用
`__autoload`	尝试加载未定义的类
`__debugInfo`	打印所需调试信息

静态继承

抽象类

类常量 const

接口

后期静态绑定

魔术方法

更多相关文章

随机推荐