类的声明\实例化\继承\方法重载\静态成员声明访问_2018年9月3日

类声明与类的实例化实例

<?php
/**
 * 类的声明与实例化
 * 声明类class
 * 类实例化new
 * 对象访问符->
 */
//用class声明一个类
class car
{
}

//使用类先实例化,用new
$bmw = new car();

$bmw->name = '宝马';
$bmw->color = '白色';
$bmw->by = function (){
  return '我要去兜风，我开着';
};
//echo $bmw->by(); 是不能访问的
//echo ($bmw->by)(); //加括号后成为自执行  一般不这样调用

//正确的方法应用回调的方式来执行（将函数作为函数参数来调用）
echo call_user_func($bmw->by),$bmw->color,$bmw->name; //用回调的方式来调用

类常量与类属性的重载实例

<?php
/**
 * 类常量,对象初始化，属性重载
 * 1.类常量可以创建对象之间的共享数据
 * 2.类常量是属性类的与对象无关
 * 3.类实例化时会先自动调用构造方法
 */
class demo3
{
    const SITE_NAME = 'PHP中文网';
    //声明三个私有属性   以后写代码时对类中的属性尽可能私有化，然后提供接口让外部访问
    private $name;
    private $course;
    private $grade;
    //构造方法 （魔术方法都用__双下划线开始），构造器
    public function __construct($name, $course, $grade)
    {
        $this->name = $name;
        $this->course = $course;
        $this->grade = $grade;
        //构造方法也可以调用本类的方法，在创建对象之前执行
        echo $this->show();

    }

    public function show()
    {
        return $this->name.'的'.$this->course.'成绩是'.$this->grade;
    }
}
//访问类常量，必须通过类名::（范围解析符）类常量名称
echo demo3::SITE_NAME;
echo '<hr>';

$demo3 = new demo3('小皮','PHP','88');
//var_dump($demo3);
echo '<hr>';
echo $demo3->show();

类的继承与方法重写实例

<?php

/**
 * 类的继承与方法重写
 */
class Car
{
    public $name;
    protected $color;
    private $price;

    const CAR_NAME = '汽车管理系统';


    public function __construct($name, $color)
    {
        $this->name = $name;
        $this->color = $color;
    }

    public function sellcar()
    {
        $var = '该车裁型是：' . $this->name . '颜色是:' . $this->color ;
        return $var;
    }

//    public function __get($name)
//    {
//        if (isset($this->$name)) {
//            return $this->$name;
//        }
//        return '不可访问';
//    }


}

class Audi extends Car
{
    private $speed; //子类自建属性
    const CAR_NAME = '汽车销售系统'; //类常量可在子类中重写

    //子类将父类同名方法进行重写,根据传入参数不同,实现不同功能,这就是多态性
    public function __construct($name, $color, $speed)
    {
        //引用父类构造方法简化代码
        parent::__construct($name, $color);
        $this->name = $name;
        $this->speed = $speed;
        $this->color = $color;
        }
    //
    public function __get($name)
    {
        if (isset($this->$name)) {
            return $this->$name;
        }
        return '不可访问';
    }
}

//当前类audi 中即使没有任何成员,也可访问父类成员
$audi = new Audi('audi','white',300);
echo $audi->name,'<br>';
echo $audi->color,'<br>';
echo $audi->price,'<hr>'; //私有子类不能访问
echo $audi::CAR_NAME,'<br>';
echo $audi->sellcar().'最高时速';
//echo $audi->speed;//取不到值,因为父类__get()不能识别子类属性
echo $audi->speed; //将读取器设置到子类就可访问,同时父类读取不受影响,因为子类已继承

类中静态成员的声明与访问实例

<?php
/**
 * 类中静态成员定义和访问
 *1.类中 定义静态成员用关键字:static
 *2.静态成员包括:静态属性和静态方法
 * 3.使用类来访问静态成员
 * 4.静态属性必需使用类访问,而静态方法可以用类,也可以用对象访问
 * 5.静态成员是可以有访问限制的:public protected private;
 * 6.静态成员与对象无关,所以不允许使用伪变量:$this
 * 7.访问时类名后必需使用 范围解析符:双冒号::
 * 8:在类中引用自身使用关键词:self:: 在子类中引用 使用 parent::
 *
 * 范围解析符的作用
 * 1.访问静态成员
 * 2.访问类常量
 * 3.继承上下文中引用被覆盖成员
 */
class Myconn {
    public static $mysqli = null;
    protected static $db = [
        'host'=>'127.0.0.1',
        'user'=>'root',
        'pass'=>'admin',
        'dbname'=>'php',
    ];

//    连接数据库生成mysqli对象
    public static function connect()
    {
        self::$mysqli = new mysqli(self::$db['host'],self::$db['user'],self::$db['pass'],self::$db['dbname']);
    }
    public static function select($fileds, $table,$num)
    {
       $sql="SELECT {$fileds} FROM {$table} LIMIT {$num}";
       $stmt=self::$mysqli->prepare($sql);
       $stmt->execute();
        $stmt->store_result();
        //把结果集中的列绑定到变量中
       $stmt->bind_result($id,$name,$age,$salary);
        while ($stmt->fetch()){
            echo '<p>id:'.$id.'name:'.$name.'age:'.$age.'salary:'.$salary.'</p>';
        }
    }
}

Myconn::connect();
Myconn::$mysqli;
//var_dump(Myconn::$mysqli);
$res=Myconn::select('`id`,`name`,`age`,`salary`','staff',10);
print_r($res);

学习总结:
1.类的声明和实例化:对象就是类的实例化结果

2.类常量与类属性的重载: 使用__construct 构造方法来进行对类属性的进行初始化,在创建对象之前执行

3.类的继承与方法重写:继承类使用extends

4,类中静态成员的声明与访问:声明静态成员用static  本类调用使用self::   子类调用使用parent::