类的封装继承多态作业

类的声明与实例化:

实例

<?php

//类的声明与实例化
//类声明:class
//实例化 new
//对象成员的访问: ->

//用class关键字声明一个类
class student{

}

//用new实例化类
$stu=new student();
//给对象添加属性和方法
$stu->name='小明';
$stu->age='18';
$stu->fun=function(){
    return '自定义的类方法';
};
//使用对象访问符->访问对象的成员(属性和方法)
echo $stu->name,'今年',$stu->age,'岁了.','<hr>';

//错误的调用方式,因为当前对象方法不是一个普通函数,而是一个对象方法
//echo $stu->fun();
//正确的调用方式,对象方法应该以回调的方式运行
echo call_user_func($stu->fun);
?>

实例

<?php

/**
 * 对象三大特征:封装,继承,多态
 * 对象三要素之一:封装
 * 1.封装是指类中成员访问进行限制,从而实现类的封装;
 * 2.类的成员包括二类:类属性,类方法
 * 3.类成员的访问限制符(3p):public protected private
 * 4.类成员的访问应该通过公共接口(方法)进行,提高安全性
 * 5.类成员可以使用$this->成员 直接访问
 * 6.$this->是对象伪变量.代表着当前类的一个实例对象
 */
class school{
    //声明类属性,属性值必须是字面量,不能是变量或表达式
    public $name;//为初始化,默认值为null
    public $height=180;//public公共属性
    //将类进行封装,外部不能访问
    protected $sex=0;//protected受保护的成员,仅限本类或本类的子类访问1男0女
    private $age=18;//private 私有成员,仅限本类访问
    //声明类方法:创建公共接口,供外部访问类中访问受限成员
    public function getSex(){
        //返回语义化的性别名称
        return ($this->sex == 1) ? 'man' : 'women';
    }
    //创建$age的公共访问接口
    public function getAge(){
//        男的直接输出年龄,女的拒绝查看(保密)
        return ($this->sex == 1) ? $this->age:'保密喔';
    }
}
//类的实例化
$sch=new school();
//测试属性默认值
var_dump(is_null($sch->name));    // ($sch->name === null) 返回同样结果: true

//测试公共属性
echo '身高:',$sch->height,'<hr>';

//private 私有成员,类外部不可访问
//echo $sch->age:
//protected 受保护的成员,类外部不呢访问
//echo $sch->sex;
echo $sch->getSex();//根据标志,返回语义化的中文
echo'<hr>';
echo $sch->getAge();//男的显示年龄,女的保密

二.类常量与类属性的重载:

实例

<?php
/**
 * 类常量,对象初始化,属性的重载
 * 1.类常量可以用来创建对戏之间的共享数据
 * 2.对象初始化:用构造方法实现,创建对象之前会自动调用,完成对象的一些初始化工作
 *  例如:对象属性的初始化,创建对象时自动调用的方法等,方法名称固定:__construct()
 * 3.属性重载:在类的外部访问不存在或无权访问的属性时,会自动触发此类方法的调用
 * 属性重载涉及四个方法:__get(),__set(),__isset(),__unset()
 */
class three{
    //类常量:所有对象共享,用类名加范围解析符(::)访问,且默认为公共属性public
    //类常量可用来创建对象之间的共享数据
    const SITE_NAME='海澜之家';
    //三个私有属性
    private $name;
    private $type;
    private $money;
    //构造方法
    public function __construct($name='花花公子',$type='长裤',$money='666'){
        $this->name=$name;
        $this->type=$type;
        $this->money=$money;
        //在实例化对象时会自动调用此方法
        echo $this->show().'<hr>';//调用类中的方法
    }
    //输出属性内容
    public function show(){
        return $this->name.'牌'.$this->type.'的价格是'.$this->money.'元噢!';
    }
    //获取属性的重载
    public function __get($name){
        return ($name == 'name')?'不许看': $this->$name;
    }
    //更新属性的重载
    public function __set($name,$val){
        if($name =='type'){
            echo '不许修改的类型';
        }else{
        $this->$name=$val;
        }
    }
//    检测属性的重载
    public function __isset($name)
    {
        if($name =='money'){
            return false;
        }
        return isset($this->$name);
    }
    //销毁属性的重载
    public function __unset($name){
        if($name =='name'){
            return false;
        }
        unset($this->$name);
    }

}

//访问类常量:类常量可以被该类的所有对象所共享,所以不属于任何一个对象,应该使用类来访问
echo '商城名称: ', three::SITE_NAME, '<hr>';

//实例化,上面类中的构造方法中设置了$this->show()方法,所以自动调用了
$store=new three('nike','运动裤','998');
//name属性在获取属性重载限制了,所以查看不到
echo '牌子:',$store->name,'<hr>';
echo '类型:',$store->type,'<hr>';
echo '价格:',$store->money,'<hr>';
//type属性在获取属性重载限制了,所以修改不了
$store->type='运动鞋';
echo '<hr>';
echo '类型:',$store->type,'<hr>';
//money属性为限制修改,可以修改
$store->money='888';
echo '价格:',$store->money,'<hr>';
//查看一下变化
echo $store->show(),'<hr>';
//检测,因为grade私有,所以外部检测不到,如类中有__isset()方法就可以检测到
echo isset($store->money) ? '存在<br>' : '<span style="color:red">不存在</span><br>';
echo isset($store->type) ? '存在<br>' : '<span style="color:red">不存在</span><br>';
//unset()重载,未成功删除$this->name
unset($store->name);
echo $store->show();
//未设置限制,成功删除
//unset($store->money);
//echo $store->money;
/*
class four{
    private $name;
    private $sex;
   public function __construct($name='小黑',$sex='女')
    {
        $this->name=$name;
        $this->sex=$sex;
    }
    public function static1(){
        //访问类常量:类常量可以被该类的所有对象所共享,所以不属于任何一个对象,应该使用类来访问
       echo three::SITE_NAME;
    }
}
//echo '<hr>';
$si=new four();
$si->static1();
*/

三.类的继承与方法重写；

实例

<?php
/**
 * 对象三要素之继承与多态
 * 1.继承是指类之间的继承,是代码复用的重要手段,之前我们是通过函数实现的代码复用
 * 2.继承关键字extends
 * 3.引用父类成员:parent::
 * 4.子类可以将父类的公共和受保护成员全部继承
 */
class demo4{
    //父类属性
    public $name;
    protected $age;
    private $salary;
    const APP_NAME='公司财务系统';
    //父类的构造方法
    public function __construct($name,$age){
        $this->name=$name;
        $this->age=$age;
    }
    //父类的访问重载,其实父类不需要写访问重载,因为写了,子类添加了属性也访问不到,还得重新写一次__get()
    public function __get($name){
        if(isset($this->$name)){
            return $this->$name;
        }
        return '非法属性';
    }
}
class demo4_2 extends demo4{
    //子类自有属性
    private $sex;
    const APP_NAME='公司成员管理系统';//类常量可以在子类中重写
    public function __construct($name,$age,$sex='man'){
        // $this->name = $name;
        // $this->age = $age;
        //引用父类的构造方法来简化代码
        parent::__construct($name,$age);
        $this->sex=$sex;
    }
    /*
     //将父类属性重载方法重载后,顺利读取子类属性
    //所以重载属性重载方法__get()应该设置在工作累中(例如本类demo4_2),而不是demo4中
    //此时将父类demo4的__get()删除,代码执行仍然正确
    public function __get($name){
        if(isset($this->$name)){
            return $this->$name;
        }
        return '非法属性';
    }*/
}
$demo4_2test=new demo4_2('小黑',20,'man');
//访问父类属性
echo $demo4_2test->name,'<hr>';
echo $demo4_2test->age,'<hr>';

echo $demo4_2test->salary,'<hr>';   // 父类私有属性子类不可见,访问不到
echo $demo4_2test::APP_NAME,'<hr>';
//取不到值,因为父类__get()不能识别子类属性
echo $demo4_2test->sex,'<hr>';
//子类加__get()后可以访问的

四.类中静态成员的声明与访问:

实例

<?php
/**
 * 类中的静态成员与访问
 * 1.类中静态成员使用关键字:static定义
 * 2.静态成员包括:静态属性和静态方法
 * 3.静态成员属于属性类的,我们应该始终使用类来访问
 * 4.静态属性必须用类来访问,而静态方法即可以用类,也可以用对象访问
 * 5.静态成员是可以有访问限制的:public,protected,private
 * 6.静态成员与对象无关,所以内部不允许使用伪变量:$this
 * 7.访问时,类名必须使用:范围解析符:双冒号[::]
 * 8.在类中引用自身使用关键字:self::
 *
 * 范围解析符的作用
 * 1.访问静态成员
 * 2访问类常量
 * 3.继承上下文中引用被覆盖成员
 */
class demo5{
    public static $pdo=null;
    protected static $db=[
        'type'=>'mysql',
        'host'=>'127.0.0.1',
        'dbname'=>'test',
        'user'=>'root',
        'pass'=>''
        ];
    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);
    }
}

//连接数据库
demo5::connect();
//查询数据表
$result=demo5::select('user','name',5);
//显示结果
echo '<pre>',var_export($result);

总结:

1. 类的声明:class+类名

2. 类的实例化:new class+类名,访问:->

3. 所谓的封装就是类中成员访问进行限制,从而实现类的封装;

4. 重载:属性重载涉及四个方法:__get(),__set(),__isset(),__unset()

5. 继承:继承关键字extends,.引用父类成员:parent::     子类可以将父类的公共和受保护成员全部继承

6.          静态成员与对象无关,所以内部不允许使用伪变量:$this     

             访问时,类名必须使用:范围解析符:双冒号[::]   

           在类中引用自身使用关键字:self::