文件包含的本质与应用

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

include

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

require

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

include,require区别

区别1
- include: 用到时再加载, 动态
- require: 应该写到顶部, 静态
区别2
- include: 加载失败,继续执行不中断
- requrie: 加载失败,中断退出

//使用include ,如果文件不存在则会继续运行下面的代码
// include __DIR__ . '/inc/hello.php';
@include __DIR__ . '/inc/hello.php'; //前面加@可以屏蔽调错误提示
echo 'include后面的代码' . '<br>';
//使用require,若是文件不存在则不会机械执行下面的代码
require __DIR__ . '/inc/hello.php';
echo 'require后面的代码' . '<br>';

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

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

文件模板

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

类与对象

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

对象 = 变量 + 函数

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

class A
{
}
new A;

类与实例

类声明

class Goods
{
    // ...
}

类的实例化:创建对象的过程,new

$goods = new Goods;
var_dump($goods);
// 车: class
// 轿车: obj
echo '<hr>';
echo get_class($goods) . '<br>';//返回对象的类名
// 动态类
$str = 'goods';
// 大驼峰/帕斯卡 ucfirst()将字符串的首字母转换为大写
$class = ucfirst('goods'); //
// echo $class;
$o = new $class;
var_dump($o);
var_dump($o instanceof Goods);

类成员

常规成员
1. 属性:可以被其他方法所共享
2. 方法:自定义方法和魔术方法两种方法
访问限制符
1. private:私有,仅限在当前类中使用
2. protected:继承,可在本类或子类中使用,不对外公开
3. public:公共,默认
静态成员
1. static,静态属性,静态方法
2. 与类实例无关,静态成员,不要用$this
3. 内部用self,外部用类名

常规成员和访问限制符

class User1
{
    // 常规成员
    // 1. 属性
    // 语法: 访问限制符 类成员声明
    // 声明为私有, 实现封装
    private $username;
    // 2. 方法
    // 2.1 自定义方法: 用户自己声明自己调用
    public function getUsername()
    {
        // -> 对象成员访问符
        // 当前实例的引用, $this 与实例绑定的
        return $this->username;
    }
    // 2.2 魔术方法: 由系统来调用,用户不能直接调用
    // 构造方法: 实例化进自动调用
    // 名字固定__construct
    public function __construct(string $username)
    {
        $this->username = $username;
    }
}
// 实例化
$user1 = new User1('张老师');
echo $user1->getUsername();
echo '<hr>';

静态方法

class User2
{
    // 静态属性
    private static $username = 'admin';
    // 类常量: 与实例无关,用类访问
    const APP = '商城';
    // 方法
    public static function getUsername()
    {
        // self: 功能与$this类似, 与当前类 User2 绑定
        return self::$username;
    }
}
// 实例访问静态方法是一个兼容bug, 能成功,但不要再用了
echo (new User2)->getUsername();
// 应该永远用类来访问静态成员
echo User2::getUsername();
echo User2::APP; //类常量

类的扩展/抽象/最终

protected:受保护/可继承
extends:扩展/继承,类的继承扩展
parent:父类引用
abstract:抽象
final:最终类

父类/基类/超类 protected 声明成员可被继承

class Person
{
    // protected: 成员可继承,可以在子类中使用
    protected $name;
    // private: 私有, 仅限当前类, 子类,外部都不可见
    private $id = 12345;
    // public: 类中,子类, 类外都可见
    public function __construct($name)
    {
        $this->name = $name;
    }
    // getInfo::protected
    // 比protected再严格的是 private, 比它更宽松的是: public
    protected function getInfo()
    {
        return $this->name;
    }
}

子类/学生类

//Stu 是 Person 的子类,可以通过protected继承一些东西
class Stu extends Person
{
    // 1. 属性扩展
    private $lesson;
    private $score;
    // 2. 方法扩展/重写
    public function __construct($name, $lesson, $score)
    {
        // 引用了父类的构造方法
        // parent: 父类引用 Person
        parent::__construct($name);
        $this->lesson = $lesson;
        $this->score = $score;
    }
    public function getInfo()
    {
        // $this->name 
        // return $this->name . "同学, ($this->lesson : $this->score 分)";
        return parent::getInfo() . "同学, ($this->lesson : $this->score 分)";
    }
}
$stu = new Stu('小狗', 'PHP', 88);
echo $stu->getInfo();
echo '<hr>';
$person = new Person('小猪');
// var_dump只打印属性
var_dump($person);
echo '<hr>';

extends类的继承/扩展

abstract class Demo1
{
}
// Demo2的类继承Demo1的类
class Demo2 extends Demo1
{
}
echo 'Demo2的父类是: ' . get_parent_class(new Demo2);
echo '<hr>';

abstract 抽象类不想让用户直接使用父类,必须通过继承子类来间接使用

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

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

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

 class Demo4 extends Demo3
 {
     // 工作类Demo4中必须实现父类中的抽象成员
     public function hello($name)
     {
         return 'Hello , ' . $name;
     }
 }
 //调用 Demo4 里面的方法
 echo call_user_func([new Demo4, 'hello'], '牛老师');
 echo '<hr>';

final:最终类防止类被继承,可声明为最终类

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

//使用final来声明最终类
final class Demo5
{
}
//声明最终类以后,就不能被继承,所以下面的代码会报错
class Demo6 extends Demo5
{
}

接口:大号的抽象类

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

interface: 声明接口

interface iUser
{
    // 1. 类常量
    const NATION = 'CHINA';
    // 2. 必须是抽象,必须是public
    public function m1();
    public function m2();
    // 官方手册: 不建议声明抽象构造方法
}

implements: 实现接口

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

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

 class Demo1 implements iUser
 {
     //普通类来实现接口,必须两个都实现
     public function m1()
     {
     }
     public function m2()
     {
     }
 }

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

 abstract class Demo2 implements iUser
 {
     //使用抽象类来实现接口,允许有不实现的
     public function m1()
     {
     }
 }

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

 //声明3个接口
 interface A
 {
 }
 interface B
 {
 }
 interface C
 {
 }
 //通过接口,间接实现三个继承
 class Test implements A, B, C
 {
 }
 // 查看当前类实现的所有接口
 $arr = class_implements('Test');
 printf('<pre>%s</pre>', print_r($arr, true));

总结

文件的包含:include和require
类声明用class,实例用new
类成员
1. 常规成员,用实例来访问,用$this来内部引用
2. 静态成员,用类来访问,用self来内部引用
类的扩展/抽象/最终
1. protected来声明成员可被继承,可扩展
2. extends来声明继承类
3. 在子类中用parent来引用父类里面的成员
4. abstract来声明抽象类,在类不允许直接使用,只允许通过子类来访问的情况下用抽象类
5. final来声明最终类,在类不允许被继承的情况下用最终类
接口,抽象类的升级版
1. 接口中的所有成员,必须都是抽象的,必须是public
2. interface: 声明接口
3. implements: 实现接口
  1. 用普通类来实现接口,必须将接口中的所有抽象方法全部实现,可以直接干活使用
  2. 用抽象类来实现接口,允许有不实现的抽象成员(可以只实现部分,或者不实现)

文件包含与类操作