文件包含和类与对象实例演示

(一) include和require的使用方法和区别

<?php
//文件包含
//本质：将目录文件复制到当前位置
//!1. include
// 推荐绝对路径
// echo __DIR__;
include __DIR__ .'/inc/f1.php';
echo $username .'<br>';
$res = include __DIR__ .'/inc/f1.php';
echo $res .'<hr>';
//!2. require
require __DIR__ . '/inc/f1.php';
echo $username .'<br>';
$res = require __DIR__ .'/inc/f1.php';
echo $res .'<hr>';
//!3. include和 require区别
//? 区别1
//include:用到时再加载，动态
//require:应该写到顶部，静态
//? 区别2
//条件加载使用include,代码执行不终止；不要使用require，代码执行会终止；
if(false) include __DIR__ .'/inc/f2.php';
echo $site;
echo $username .'<br>';
if(false) require __DIR__ .'/inc/f2.php';
echo $site;
echo $username .'<br>';
echo '<hr>';
include __DIR__ .'/inc/f20.php';
echo 'include后面的代码<br>';
// require __DIR__ .'/inc/f20.php';
// echo 'require后面的代码<br>';
//其他情况推荐使用 require，因为有错误可以提前解决

(二) 类与实例:class和new

<?php
//!类与实例
//?1.class
//?2.new
// 类声明
//1.class
class Goods
{
    //...
}
//类的实例化:创建对象的过程，new
$goods = new Goods;
var_dump($goods);
echo '<hr>';
//查看类
echo get_class($goods) . '<br>';
//动态类
$str = 'goods';
// 类用大驼峰命名法
$class = ucfirst('goods');
// echo $class;
$o = new $class;
// var_dump($o);
//判断是不是它的实例,是返回true,否返回false
var_dump($o instanceof Goods);

(三)类成员：常规成员和静态成员

<?php
/**
 * 类成员
 * 一、常规成员
 * 1.属性：可以被其他方法所共享
 * 2.方法：自定义，魔术方法
 * 
 * 
 * 访问限制符
 * 1.private:私有，仅限当前类使用
 * 2.protected:继承，可在本类或子类中使用，不对外公开
 * 3.public:公开，默认
 * 
 * 二、静态成员
 * 1.static 静态属性  静态方法
 * 2.与实例无关，不要用$this
 * 3.内部用self,外部用类名
 */
class User11
{
    //常规成员
    //1.属性
    //语法：访问限制符  类成员声明
    //声明为私有，实现封装
    private $username;
    //2.方法
    //2.1 自定义方法:用户自己声明自己调用
    public function getUsername()
    {
        // -> 对象成员访问符
        // $obj = new User1;
        // return $obj->username;
        // 当前实例的引用，$this与实例绑定的
        return $this->username;
    }
    //2.2 魔术方法：由系统来调用，用户不能直接调用
    //构造方法：实例化时自动调用
    public function __construct(string $username)
    {
        $this->username = $username;
    }
}
//实例化
$user1 = new User11('刘老师');
echo $user1->getUsername() . '<hr>';
//代码优化
//静态成员
class User2
{
    //静态属性
    private static $username = 'admin';
    //类常量：与实例无关,用类访问
    const APP='粮油商城';
    //方法
    public static function getUsername()
    {
        //self:与当前类绑定
        return self::$username;
    }
}
//实例方法问静态方法是一个bug
// echo (new User2) -> getUsername();
//外部用类名访问静态成员
echo User2::getUsername();
echo User2::APP;

(四) 类的扩展、抽象等

1.protected:受保护/可继承

2.extends:扩展/继承

3.parent:父类引用

4.abstract:抽象

5.final:最终类

<?php
use Demo1 as GlobalDemo1;
/**
 * 类的扩展/抽象/最终
 * 1.protected:受保护/可继承
 * 2.extends:扩展/继承
 * 3.parent:父类引用
 * 4.abstract:抽象
 * 5.final:最终类
 */
 //父类 / 基类
 class Person
 {
     //protected:成员可继承，可以在子类中使用
     protected $name;
     //private:私有，仅限当前类，子类和外部都不可见
     private $id = 123;
     //public:类中，子类，类外都可见
     public function __construct($name)
     {
         $this->name = $name;
     }
     //getInfo::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;
    }
    //getInfo
    public function getInfo()
     {
        //  return $this->name."同学，你的 $this->lesson 成绩是 $this->score 分";
        //父类引用方法实现
         return parent::getInfo()."同学，你的 $this->lesson 成绩是 $this->score 分";
     }
 }
$stu = new Stu('小明','php',90);
echo $stu -> getInfo();
echo '<hr>';
//直接使用父类
$person = new Person('李老师');
//var_dump只打印属性,不打印方法
var_dump($person);
echo '<hr>';
//抽象类
//把父类声明成一个抽象类,必须通过继承/扩展的子类来间接使用
echo '抽象类' . '<br>';
abstract class Demo1
{
}
//抽象类不能实例化
// new Demo1;
class Demo2 extends GlobalDemo1
{
}
//通过实例化子类来实现
new Demo2;
// 查看父类
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中必须实现父类Demo3中的抽象成员
    public function hello($name)
    {
        return 'Hello,' . $name;
    }
}
echo call_user_func([new Demo4,'hello'],'小明');
echo '<hr>';
echo '最终类';
//一个类不用扩展,直接当成工作累/直接干活的,直接new
//为了防止被继承,可声明为最终类
final class Demo5{
}
//最终类不能被继承
// class Demo6 extends Demo5
// {
// }

(六)接口

<?php
//接口:大号的抽象类
//接口中的所有成员必须是抽象的
//interface:声明接口
//implements:实现接口
interface User
{
    //1.类常量
    const NATION = 'china';
    //2.必须是抽象,必须是public
    public function m1();
    public function m2();
    //官方手册不建议声明抽象构造方法
}
//接口不能直接使用,要用一个类来实现它
//1.用普通类来实现一个接口,必须将接口中的所有抽象方法全部实现
class Demo1 implements User
{
    public function m1()
    {
    }
    public function m2()
    {
    }
}
//2.用抽象类来实现一个接口,允许有不实现的抽象成员
abstract class Demo2 implements User
{
    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));