类与对象：类声明，类常量，类属性，以及类中静态成员的声明与访问 2018年9月3日 22:28

1、类声明与类的实例化

实例

<?php

echo '<meta charset="UTF-8">';
echo '<h1>类声明与类的实例化</h1><hr>';

//声明一个类，类的首写字母用大写
class Task1 {

}

//用关键字new实例化一个类,即创建了一个变量（对象）
$task1 = new Task1();

//给这个当前的对象用指向符 ->添加一些属性值和方法即函数
$task1 ->name = 'arthur';
$task1 ->age = 38;
$task1 ->salary = function (){
    return '我的工资对外保密！';
};

//对象指向符同时也是对象访问符，在类与对象外部可以通过对象访问符进行访问对象的属性
echo $task1 ->name ,'的年龄是：',$task1 ->age ,'岁！','<br>';

//对象内部的函数本质上也是对象的属性的一种，应该用回调的方式进行访问查看
echo call_user_func($task1 ->salary);

2、类常量与类属性的重载

实例

<?php
echo '<meta charset="UTF-8">';
echo '<h1>类常量与类属性的重载</h1><hr>';

//什么是类常量
//根据我的理解，类常量就是提供了给该类对象的一个公共属性
//创建类常量使用const固定方式，且创建的类常量默认属性为Public

class Task2 {
//    const 后面好像需要完全大写
    const COR_NAME = '南通税企通';

    private $project;
    private $money;
    private $admin;

//    使用固定方式__construct()来构建对象的方法,可以实现自动调用
    public function __construct($project,$money,$admin)
    {
//        使用伪变量指定对象属性
        $this ->project = $project;
        $this ->money = $money;
        $this ->admin = $admin;

//        当有可以调用的内容之后，使用指向符->show()实现方法的调用
//        就是new了之后就自动调用实行并输出了
        echo $this ->show();
    }
//    输出属性的内容
    public function show(){
        return $this ->project . '的价格是：'. $this ->money .'元；负责人是：'. $this ->admin;
    }
    //获取属性的重载
    public function __get($ming)
    {
        if ($ming == 'money'){
            return $ming.'不允许查看';
        }
        return $this ->$ming;

    }
//    设置属性的重载
    public function __set($ming1, $value)
    {
        if ($ming1 == 'money'){
            return $ming1.'不允许修改价格';
        }
         $this ->$ming1 = $value;
    }
//    检测属性的重载
    public function __isset($ming2)
    {
        if ($ming2 == 'money'){
            return false;
        }
        return isset($this ->$ming2);
    }
//    销毁属性的重载
    public function __unset($ming3)
    {
        if ($ming3 == 'project' || $ming3 == 'money'){
            return false;
        }
        unset($this ->$ming3);
    }

}

//类常量的访问，类常量不属于任何一个对象，所以应该使用类来访问
echo '公司名称：',Task2::COR_NAME ,'<br>';

//实例化Task2，创建对象
$task2 = new Task2('委托申报',500,'arthur');
//var_dump($task2);
echo '<hr>';
//输出属性的内容
//echo $task2 ->show();

//属性的重载有四个场景：获取，设置，检测，销毁；
//当从类的外部访问类中不存在或无权访问的属性的时候，这些重载方法会被自动触发！
//1，属性重载的获取
echo '项目名称是：',$task2 ->project, '<br>';
echo '项目价格是：',$task2 ->money,'<br>';
echo '<hr>';
//2，属性重载的设置
$task2 ->project = '委托记账';
echo '更新后的项目名称是：',$task2 ->project, '<br>';
echo $task2 ->money = 5000;
//这边直接输出就=5000了，是可以修改的，请老师指教啊！！！
echo '<hr>';
//3，属性重载的检测
echo isset($task2 ->project) ? '存在<br>' : '<span style="color: red;">不存在</span>';
echo isset($task2 ->money) ? '存在<br>' : '<span style="color: red;">不存在</span>';
echo '<hr>';
//4,属性重载的销毁
unset($task2 ->admin);
echo isset($task2 ->project) ? '存在<br>' : '<span style="color: red;">不存在</span>';
echo isset($task2 ->money) ? '存在<br>' : '<span style="color: red;">不存在</span><br>';
echo isset($task2 ->admin) ? '存在<br>' : '<span style="color: red;">不存在</span>';

3、类的继承与方法重写

实例

<?php
echo '<meta charset="UTF-8">';
echo '<h1>类的继承与方法重写</h1><hr>';

class Task3{
    const COR_NAME = '南通税企通';
    public $project;
    protected $money;
    private $arthur;

//    父类构造器
    public function __construct($project,$money)
    {
        $this ->project = $project;
        $this ->money = $money;
    }
}
//创建一个子类并用extends继承父类
class Task3_1 extends Task3 {
//    类常量也可以在子类中重写
     const COR_NAME = '天业税企通';
//    创建子类自由属性
     private $leval;
//     将父类中的构造方法进行重新设置，即多态
     public function __construct($project, $money, $leval)
     {
//         这就是多态
         parent::__construct($project, $money);
         $this ->leval = $leval;
     }
    public function __get($ming)
    {
        if (isset($this ->$ming)){
            return $this ->$ming;
        }return '该属性不存在';
    }
}
//new的谁，谁就是工作类，所以属性方法的重写应该放到工作类中
$task3_1 = new Task3_1('委托申报',500,'vip1');

echo $task3_1 ->project,'<br>';
echo $task3_1 ->money,'<br><hr>';
echo $task3_1 ->leval,'<br><hr>';
echo Task3::COR_NAME,'<br>';
echo Task3_1::COR_NAME,'<br>';

4、类中静态成员的声明与访问

实例

<?php
echo '<meta charset="UTF-8">';
echo '<h1>类中静态成员的声明与访问</h1><hr>';

//什么是静态？static就是静态：）其实，在类中，所有成员只要没有声明是静态，那就都是动态
//静态成员不需要用伪变量来指向访问，同时静态成员是被所有对象所共享，是用类来访问的
//访问时，类名后必须使用双冒号，即范围解析符 :: ，而在类中引用自己用关键字，self::

class Task4{
    public static $pdo = null;
    protected static $db = [
        'type' => 'mysql',
        'host' => '127.0.0.1',
        'dbname' => 'php',
        'user' => 'root',
        'pass' => 'root',
    ];

    public static function connect()
    {
        $dsn = self::$db['type'].':host='.self::$db['host'].';dbname='.self::$db['dbname'];
        self::$pdo = new PDO($dsn,self::$db['user'],self::$db['pass']);
    }
    public static function select($table,$fields='*', $num=5)
    {
        $stmt = self::$pdo->prepare("SELECT {$fields} FROM {$table} LIMIT {$num}");
        $stmt->execute();
        return $stmt->fetchAll(PDO::FETCH_ASSOC);

    }
}

//连接数据库
Task4::connect();
var_dump(Task4::$pdo);
//进行数据库查询
$result = Task4::select('staff','name,age,salary',6);
echo '<pre>',var_export($result);