文件包含与类操作

文件包含的本质与应用

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

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. 常规成员

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

2. 访问限制符

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

3. 静态成员

   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; //类常量

类的扩展/抽象/最终

1. protected:受保护/可继承
2. extends:扩展/继承,类的继承扩展
3. parent:父类引用
4. abstract:抽象
5. 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 抽象类不想让用户直接使用父类,必须通过继承子类来间接使用

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

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

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

    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: 实现接口

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

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

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

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

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

3. 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));

总结

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. 用抽象类来实现接口,允许有不实现的抽象成员(可以只实现部分,或者不实现)