search

博客列表 >文件包含与类操作

文件包含与类操作

天宁
天宁原创
2022年05月03日 23:16:16475浏览

文件包含的本质与应用

本质:将目录文件复制到当前位置

include

  1. include __DIR__ . '/inc/f1.php';
  2. // $username = '猪老师'; //这是f1.php里面的内容
  3. // 被包含文件共享作用域
  4. echo $username . '<br>';//输出 猪老师
  6. // echo $email . '<br>';
  7. $email = include __DIR__ . '/inc/f1.php';
  8. // 引用的f1.php文件里可以直接用return,这样引用的文件就有返回值
  9. echo $email . '<hr>';

require

  1. //require也可以引用
  2. require __DIR__ . '/inc/f1.php';
  4. echo $username . '<br>';
  6. $email = require __DIR__ . '/inc/f1.php';
  7. echo $email . '<br>';

include,require区别

  • 区别1

    • include: 用到时再加载, 动态
    • require: 应该写到顶部, 静态

  • 区别2

    • include: 加载失败,继续执行不中断
    • requrie: 加载失败,中断退出
  1. //使用include ,如果文件不存在则会继续运行下面的代码
  2. // include __DIR__ . '/inc/hello.php';
  3. @include __DIR__ . '/inc/hello.php'; //前面加@可以屏蔽调错误提示
  4. echo 'include后面的代码' . '<br>';
  6. //使用require,若是文件不存在则不会机械执行下面的代码
  7. require __DIR__ . '/inc/hello.php';
  8. echo 'require后面的代码' . '<br>';

使用include_once或require_once,代表只包含一次

  1. include_once __DIR__ . '/inc/f1.php';
  2. require_once __DIR__ . '/inc/f1.php';

文件模板

  1. <?php require __DIR__ . '/inc/header.php' ?>
  2. <!-- 主体 -->
  3. <main>
  4.     <ul>
  5.         <li><a href="">最新文章1</a></li>
  6.         <li><a href="">最新文章2</a></li>
  7.         <li><a href="">最新文章3</a></li>
  8.         <li><a href="">最新文章4</a></li>
  9.         <li><a href="">最新文章5</a></li>
  10.         <li><a href="">最新文章6</a></li>
  11.         <li><a href="">最新文章7</a></li>
  12.         <li><a href="">最新文章8</a></li>
  13.         <li><a href="">最新文章9</a></li>
  14.         <li><a href="">最新文章10</a></li>
  15.     </ul>
  16. </main>
  17. <?php require __DIR__ . '/inc/footer.php' ?>

类与对象

将一组相关的变量和函数进行组合,形成一个新的编码单元,来简化代码,实现”代码复用”

对象 = 变量 + 函数

PHP对象是基于”类”,类是对象的模板

  1. class A
  2. {
  3. }
  5. new A;

类与实例

类声明
  1. class Goods
  2. {
  3.     // ...
  4. }
类的实例化:创建对象的过程,new
  1. $goods = new Goods;
  2. var_dump($goods);
  3. // 车: class
  4. // 轿车: obj
  5. echo '<hr>';
  7. echo get_class($goods) . '<br>';//返回对象的类名
  8. // 动态类
  9. $str = 'goods';
  11. // 大驼峰/帕斯卡 ucfirst()将字符串的首字母转换为大写
  12. $class = ucfirst('goods'); //
  13. // echo $class;
  14. $o = new $class;
  15. var_dump($o);
  16. var_dump($o instanceof Goods);

类成员

  1. 常规成员

    1. 属性:可以被其他方法所共享
    2. 方法:自定义方法和 魔术方法两种方法

  2. 访问限制符

    1. private:私有,仅限在当前类中使用
    2. protected:继承,可在本类或子类中使用,不对外公开
    3. public:公共,默认

  3. 静态成员

    1. static,静态属性,静态方法
    2. 与类实例无关,静态成员,不要用$this
    3. 内部用self,外部用类名
常规成员和访问限制符
  1. class User1
  2. {
  3.     // 常规成员
  4.     // 1. 属性
  5.     // 语法: 访问限制符 类成员声明
  6.     // 声明为私有, 实现封装
  7.     private $username;
  10.     // 2. 方法
  11.     // 2.1 自定义方法: 用户自己声明自己调用
  12.     public function getUsername()
  13.     {
  15.         // -> 对象成员访问符
  16.         // 当前实例的引用, $this 与实例绑定的
  17.         return $this->username;
  18.     }
  20.     // 2.2 魔术方法: 由系统来调用,用户不能直接调用
  21.     // 构造方法: 实例化进自动调用
  22.     // 名字固定__construct
  23.     public function __construct(string $username)
  24.     {
  25.         $this->username = $username;
  26.     }
  27. }
  29. // 实例化
  30. $user1 = new User1('张老师');
  31. echo $user1->getUsername();
  33. echo '<hr>';
静态方法
  1. class User2
  2. {
  3.     // 静态属性
  4.     private static $username = 'admin';
  7.     // 类常量: 与实例无关,用类访问
  8.     const APP = '商城';
  10.     // 方法
  11.     public static function getUsername()
  12.     {
  14.         // self: 功能与$this类似, 与当前类 User2 绑定
  15.         return self::$username;
  16.     }
  17. }
  19. // 实例访问静态方法是一个兼容bug, 能成功,但不要再用了
  20. echo (new User2)->getUsername();
  21. // 应该永远用类来访问静态成员
  22. echo User2::getUsername();
  23. echo User2::APP; //类常量

类的扩展/抽象/最终

  1. protected:受保护/可继承
  2. extends:扩展/继承,类的继承扩展
  3. parent:父类引用
  4. abstract:抽象
  5. final:最终类
父类/基类/超类 protected 声明成员可被继承
  1. class Person
  2. {
  3.     // protected: 成员可继承,可以在子类中使用
  4.     protected $name;
  5.     // private: 私有, 仅限当前类, 子类,外部都不可见
  6.     private $id = 12345;
  7.     // public: 类中,子类, 类外都可见
  8.     public function __construct($name)
  9.     {
  10.         $this->name = $name;
  11.     }
  13.     // getInfo::protected
  14.     // 比protected再严格的是 private, 比它更宽松的是: public
  15.     protected function getInfo()
  16.     {
  17.         return $this->name;
  18.     }
  19. }
子类/学生类
  1. //Stu 是 Person 的子类,可以通过protected继承一些东西
  2. class Stu extends Person
  3. {
  4.     // 1. 属性扩展
  5.     private $lesson;
  6.     private $score;
  8.     // 2. 方法扩展/重写
  9.     public function __construct($name, $lesson, $score)
  10.     {
  11.         // 引用了父类的构造方法
  12.         // parent: 父类引用 Person
  13.         parent::__construct($name);
  14.         $this->lesson = $lesson;
  15.         $this->score = $score;
  16.     }
  18.     public function getInfo()
  19.     {
  20.         // $this->name 
  21.         // return $this->name . "同学, ($this->lesson : $this->score 分)";
  22.         return parent::getInfo() . "同学, ($this->lesson : $this->score 分)";
  23.     }
  24. }
  26. $stu = new Stu('小狗', 'PHP', 88);
  27. echo $stu->getInfo();
  29. echo '<hr>';
  30. $person = new Person('小猪');
  31. // var_dump只打印属性
  32. var_dump($person);
  33. echo '<hr>';
extends类的继承/扩展
  1. abstract class Demo1
  2. {
  3. }
  5. // Demo2的类继承Demo1的类
  6. class Demo2 extends Demo1
  7. {
  8. }
  9. echo 'Demo2的父类是: ' . get_parent_class(new Demo2);
  11. echo '<hr>';
abstract 抽象类不想让用户直接使用父类,必须通过继承子类来间接使用

  1. 通过abstract将父类声明为一个抽象类

    1.  abstract class Demo3
    2.  {
    4.      // 抽象方法: 只有方法名,参数列表,没有具体实现(大括号)
    5.      abstract protected function hello($name);
    6.  }

  2. 通过继承类来实现父类成员的调用

    1.  class Demo4 extends Demo3
    2.  {
    3.      // 工作类Demo4中必须实现父类中的抽象成员
    4.      public function hello($name)
    5.      {
    6.          return 'Hello , ' . $name;
    7.      }
    8.  }
    9.  //调用 Demo4 里面的方法
    10.  echo call_user_func([new Demo4, 'hello'], '牛老师');
    11.  echo '<hr>';
final:最终类防止类被继承,可声明为最终类

如果一个类不用扩展,直接当成工作类/直接干活的,直接new的情况下用最终类final

  1. //使用final来声明最终类
  2. final class Demo5
  3. {
  4. }
  5. //声明最终类以后,就不能被继承,所以下面的代码会报错
  6. class Demo6 extends Demo5
  7. {
  8. }

接口:大号的抽象类

接口的所有成员,必须是抽象

interface: 声明接口
  1. interface iUser
  2. {
  3.     // 1. 类常量
  4.     const NATION = 'CHINA';
  6.     // 2. 必须是抽象,必须是public
  7.     public function m1();
  8.     public function m2();
  10.     // 官方手册: 不建议声明抽象构造方法
  11. }
implements: 实现接口

接口不能直接用,要用一个类来实现它

  1. 用普通类来实现一个接口,必须将接口中的所有抽象方法全部实现

    1.  class Demo1 implements iUser
    2.  {
    3.      //普通类来实现接口,必须两个都实现
    4.      public function m1()
    5.      {
    6.      }
    7.      public function m2()
    8.      {
    9.      }
    10.  }

  2. 用抽象类来实现一个接口,允许有不实现的抽象成员

    1.  abstract class Demo2 implements iUser
    2.  {
    3.      //使用抽象类来实现接口,允许有不实现的
    4.      public function m1()
    5.      {
    6.      }
    7.  }

  3. php默认只支持单继承,可通过接口,间接实现多继承

    1.  //声明3个接口
    2.  interface A
    3.  {
    4.  }
    5.  interface B
    6.  {
    7.  }
    8.  interface C
    9.  {
    10.  }
    11.  //通过接口,间接实现三个继承
    12.  class Test implements A, B, C
    13.  {
    14.  }
    16.  // 查看当前类实现的所有接口
    17.  $arr = class_implements('Test');
    18.  printf('<pre>%s</pre>', print_r($arr, true));

总结

  1. 文件的包含:include和require
  2. 类声明用class,实例用new

  3. 类成员

    1. 常规成员,用实例来访问,用$this来内部引用
    2. 静态成员,用类来访问,用self来内部引用

  4. 类的扩展/抽象/最终

    1. protected来声明成员可被继承,可扩展
    2. extends来声明继承类
    3. 在子类中用parent来引用父类里面的成员
    4. abstract来声明抽象类,在类不允许直接使用,只允许通过子类来访问的情况下用抽象类
    5. final来声明最终类,在类不允许被继承的情况下用最终类

  5. 接口,抽象类的升级版

    1. 接口中的所有成员,必须都是抽象的,必须是public
    2. interface: 声明接口

    3. implements: 实现接口

      1. 用普通类来实现接口,必须将接口中的所有抽象方法全部实现,可以直接干活使用
      2. 用抽象类来实现接口,允许有不实现的抽象成员(可以只实现部分,或者不实现)
上一条：字符串函数学习下一条：MYSQL -（二）文件上传/分页展示
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多