文件实例与类操作

文件实例

<?php
// 文件包含
// 本质：将目录文件复制到当前位置
// 1. include
include __DIR__ . '/int/f1.php';
// 被包含的文件共享作用域
echo $username . '<hr>';
$email = include __DIR__ . '/int/f1.php';;
echo $email. '<hr>';
// 2. require
include __DIR__ . '/int/f1.php';
echo $username . '<hr>';
$email = include __DIR__ . '/int/f1.php';;
echo $email. '<hr>';
// include,require的区别
// 区别1
// include:用到时再加载，动态
// require:应该写到顶部，静态
if(false) include __DIR__ . '/int/f2.php' ;
echo $site;
if(false) require __DIR__ . '/int/f2.php' ;
echo $site;
// 区别2
// include：加载失败，继续执行不中断
// require：加载失败，中断退出
include __DIR__ . '/int/hello.php' ;
echo 'include后面代码.<br>';
require __DIR__ . '/int/hello.php' ;
echo 'require后面的代码.<br>';

类与实例

<?php
/**
 * 类与实例
 * 1.class
 * 2.new
 */
// 类声明
// 1.class
 class Goods
 {
 }
//  类的实例化：创建对象的过程，new
$goods = new Goods;
var_dump($goods);
echo '<hr>';
echo get_class($goods);
// 动态类
$str = 'goods';
// 创建类必须是首字母大写，大驼峰/帕斯卡
$class = ucfirst('goods');
// echo $class;
$o = new $class;
var_dump($o);
var_dump($o instanceof Goods);

类的扩展/抽象/最终

<?php
use Demo1 as GlobalDemo1;
/**
 * 类的扩展/抽象/最终
 * 1.protected:受保护/继承
 * 2.extends:扩展/继承
 * 3.parent:父类引用
 * 4.abstract:抽象
 * 5.final:最终类
 */
//父类，基类，超类
 class Person
 {
     //protected:成员可以继承，可以在子类中使用
     protected $name;
    //  private:私有，仅限于当前类，子类，外部都不可见
     private $id = 1335;
    //  public:类中，子类类外都可见
     public function __construct($name)
     {
         $this->name = $name;
     }
    //  getInfo()::protected
    //  比protected更严格的是private，比它宽松的是public
     protected function getInfo()
     {
         return $this->name;
     }
 }
//  学生类
// extends:Stu这个类，扩展了Person类的功能
class Stu extends Person
{
    // 1.属性扩展
    private $lesson;
    private $score;
    // 2.方法扩展/重写
    public function __construct($name,$lesson,$score)
     {
        //  parent：父类引用   
        // 引用了父类的构造方法
        // :: 这个叫范围操作符
         parent:: __construct($name);
         $this->lesson = $lesson;
         $this->score = $score;
     }
    //  扩展必须得比父类的宽松才行
     public function getInfo()
     {
        //  return $this->name . "同学,($this->lesson : $this->score 分)";
         return parent::getInfo(). "同学,($this->lesson : $this->score 分)";
     }
}
$stu = new Stu('小狗','PHP',80);
echo $stu->getInfo();
echo '<hr>';
$person = new Person('小猪');
var_dump($person);
echo '<hr>';
//如果不想让用户直接使用父类，而必须通过继承/扩展的子类来间接使用
// 将父类声明为严格抽象类
abstract class Demo1
{
}
class Demo2 extends Demo1
{
}
(new Demo2);
// 查询父类是函数是get_parent_class
echo 'Demo2的父类是:'. get_parent_class(new Demo2); 
echo '<hr>';
abstract class Demo3
{
    // hello方法已经实现了
    // protected function hello()
    // {
    // }
    // 抽象方法：只有方法名，参数列表，没有具体实现（大括号）
    abstract protected function hello($name);
}
class Demo4 extends Demo3
{
    // 工作类Demo4中必须实现父类中的抽象成员
    public function hello($name)
    {
        return 'Hello,'.$name;
    }
}
echo call_user_func([new Demo4,'Hello'],'李老师');
echo '<hr>';
// 如果一个类不用扩展，直接当成工作类，/直接干活，直接new
// 为了防止被继承，可声明为最终类
final class Demo5
{
}

接口（大号的抽象类）

<?php
// 接口：大号的抽象类 
// 接口的成员必须都是抽象的
// interface:声明接口
// implements:实现接口
interface iUser
{
    //1.类常量
    const NATION = 'CHINA';
    // 2.必须是抽象，必须是public
    public function m1();
    public function m2();
}
// 接口不能直接使用，要用一个类来实现它
// 1.普通类来实现一个接口，必须将接口中的所有抽象方法全部实现
class Demo1 implements iUser
{
    public function m1()
    {
    }
    public function m2()
    {
    }
}
// 2.抽象类来实现一个接口,允许有不实现的抽象成员
abstract class Demo2 implements iUser
{
    public function m1()
    {
    }
}
//php默认只支持单继承
// class A extends B,
// 可以通过接口，间接实现继承
interface A
{
}
interface B
{
}
interface C
{
}
class Test implements A ,B ,C
{
}
// 查看当前类实现的所有接口
$arr = class_implements('Test');
printf('<pre>%s</pre>',print_r($arr,true));