类声明与类的实例化0903作业

0903作业

实例

<?php
/**
 * 类的声明与实例化
 * 1. 类声明: class;
 * 2. 类的实例化: new
 * 3. 对象成员的访问:->
 */
echo '<h3>编程1：类的声明与类的实例化</h3>';
//用关键字class声明一个类
class Demo1
 {

 }
//用关键字 new 实例化一个类
$demo1 = new Demo1();

//给当前对象添加一些属性和方法
$demo1->name = '小龙女';
$demo1->sex = 'female';
$demo1->age=18;
$demo1->say = function()
 {
  return '一个小仙女自定义的类方法';
 };
//使用对象访问符:-> 来访问对象中的成员(属性和方法)
echo '姓名:'.$demo1->name .', 性别:',$demo1->sex. ', 年龄：'.$demo1->age.'<hr>';

//错误的调用方式,因为当前对象方法不是一个普通函数,而是一个对象方法
//echo $demo1->hello();
//正确的调用方式,对象方法应该以回调的方式运行
//call_user_func()：调用一个回调函数处理字符串,
//可以用匿名函数，可以用有名函数，可以传递类的方法
echo call_user_func($demo1->say);

实例

<?php
/**
 * 类常量,对象初始化,属性的重载
 * 1. 类常量可用来创建对象之间的共享数据
 * 2. 对象初始化: 用构造方法实现,创建对象之前会自动调用,完全对象的一些初始化工作
 *    例如:对象属性初始化,创建对象时自动调用的方法等,方法名称固定:__construct()
 * 3.属性重载:在类的外部访问不存在或者无权限访问的属性时,会自动触发此类方法调用
 *   属性重载涉及四个方法:__get(),__set(),__isset(),__unset()
 */
echo '<h3>编程2：类常量与类属性的重载;</h3>';


class Demo3
{
    //类常量:所有对象共享,用类名加范围解析符(::)访问,且默认为公共属性public
    //类常量可用来创建对象之间的共享数据
    const SITE_NAME = 'www.php.cn';

    //声明二个私有属性
    private $name;
    private $course;
    private $grade;

    //构造方法
    public function __construct($name,$course, $grade)
    {
        $this->name = $name;
        $this->course = $course;
        $this->grade = $grade;
        //构造方法中不仅可以初始化对象属性,还可以调用类方法
        echo $this->show().'<hr>';//这里构造函数调用的类方法就是下面输出内容的show方法
    }

    //输出属性内容
    public function show()
    {
        return $this->name.'的《'.$this->course.'》课程的成绩是: '.$this->grade.'分!';
    }

    //获取属性的重载
    public function __get($name)
    {
        if ($name == 'grade') {
            return $name.'不允许查看';
        }
        return $this->$name;
    }

    //更新属性的重载
    public function __set($name, $value)
    {
        if ($name == 'grade')
        {
          echo $name.'：成绩不允许修改','<br>';
        }
          $this->$name = $value;
    }

    //属性检测的重载
    public function __isset($name)
    {
        if ($name == 'grade')
        {
          return false;
        }
          return isset($this->$name);
    }

    //销毁属性的重载
    public function __unset($name)
    {
        if ($name == 'grade' || $name == 'name')
        {
          return false;
        }
          unset($this->$name);
    }
}

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

//实例化Demo3,创建对象
$demo3 = new Demo3('杨逍','THINKPHP',58);
var_dump($demo3);
echo '<hr>';

//访问属性,因为属性全部被封装,所以必须通过一个统一的外部接口访问
echo $demo3->show();
echo '<hr>';
//如果想简化以上操作,可以在实例化之前,在构造方法中调用属性访问接口方法
new Demo3('杨过','THINKPHP', 82);

//属性操作: 获取,设置,检测,销毁
//获取
echo '姓名: ', $demo3->name, '<hr>';   // 访问私有属性,如类中无__get()会出错,如有自动触发
echo '成绩: ', $demo3->grade, '<hr>';  // 可以在__get()进行属性访问的权限控制

//设置
$demo3->course = 'PHP';
echo '课程: ', $demo3->course,'<hr>';
$demo3->grade = 65;

//检测,因为grade私有,所以外部检.测不到,如类中有__isset()方法就可以检测到
echo isset($demo3->name) ? '存在<hr>' : '<span style="color:red">不存在</span><hr>';
echo isset($demo3->grade) ? '存在<hr>' : '<span style="color:red">不存在</span><hr>';

//销毁
unset($demo3->name);    // 重载方法中__unset()不允许销毁grade和name属性
echo $demo3->name,'<hr>';   // 所以这里仍可以访问到name属性

unset($demo3->course);//销毁课程
echo $demo3->course,'<hr>';

实例

<?php
/**
 * 对象三要素之: 继承与多态
 * 1. 继承是指类之间的继承,是代码复用的重要手段,之前我们是通过"函数"实现的代码复用
 * 2. 继承使用关键字: extends
 * 3. 引用父类成员: parent::
 * 4. 子类可以将父类中的公共和受保护成员全部继承
 */
echo '<h3>编程3: 类的继承与方法重写</h3>';
class Demo4
{
    //父类属性
    public $name;
    protected $age;
    private $salary;
    const APP_NAME = '学生管理系统';

    //父类构造器
    public function __construct($name, $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
    public function __get($name)
    {
        if (isset($this->$name))
        {
            return $this->$name;
        }
        return '非法属性';
    }

}

class Demo4_1 extends Demo4
{
    //子类自有属性
    private $sex;
    const APP_NAME = '教师管理系统';  //类常量可以在子类中重写

    //子类将父类同名方法进行重写,根据传入参数不同,实现不同的功能,这就是多态性
    public function __construct($name, $age, $sex='male')
    {

        //  $this->name = $name;
        //  $this->age = $age;
        // 引用父类的构造方法来简化代码
        parent::__construct($name, $age);
        $this->sex = $sex;
    }

    //将父类属性重载方法重写后,顺利读取子类属性
    //所以属性重载方法__get()应该设置在最终工作类中(例如本类Demo4_1),而不是父类Demo4中
    //此时,将父类Demo4中的__get()删除,代码执行仍然正确
    public function __get($name)
    {
        if (isset($this->$name))
        {
            return $this->$name;
        }
        return '非法属性';
    }

}

//当前类Demo4_1中即使没有任何成员,一样可以访问父类成员
$demo4_1 = new Demo4_1('欧阳克',35);
//访问父类中的属性
echo $demo4_1->name,'<hr>';
echo $demo4_1->age,'<hr>';
echo $demo4_1->salary,'<hr>';   // 父类私有属性子类不可见,访问不到
echo Demo4_1::APP_NAME, '<hr>';  // 访问类常量
echo $demo4_1->sex, '<hr>'; //取不值,因为父类__get()不能识别子类属性

实例

<?php
/**
 * 类中的静态成员与访问
 * 1.类中静态成员使用关键字:static 定义;
 * 2.静态成员包括: 静态属性和静态方法;
 * 3.静态成员是属于类的,我们应该终终使用类来访问;
 * 4.静态属性必须使用类来访问,而静态方法即可以用类,也可以用对象访问;
 * 5.静态成员是可以有访问限制的: public,protected,private;
 * 6.静态成员与对象无关,所以内部不允许使用伪变量: $this;
 * 7.访问时,类名后必须使用:范围解析符:双冒号[::]
 * 8.在类中引用自身使用关键字: self::
 *
 * 范围解析符的作用:
 * 1. 访问静态成员;
 * 2. 访问类常量;
 * 3. 继承上下文中引用被覆盖成员
 */

echo '<h3>编程4: 类中静态成员的声明与访问</h3>';
class Demo5
{
    public static $pdo = null;
    protected static $db = [
      'type' => 'mysql',
      'host' => 'localhost',
      '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);

    }
}

//连接数据库
Demo5::connect();

//查询数据表
$result = Demo5::select('staff','name,age,salary',4);

//显示结果
echo '<pre>',var_export($result);