类的声明与实例化、重载与继承及静态成员学习—2018年09月03日22时00分

今天是第十七天上课，朱老师初步讲解了类的概念。

重要知识点：1. 对象的三大特征: 封装,继承,多态。

                    2. 如果类成员的访问被限制外部访问，那应该通过公共接口(方法)进行,提高安全性。

                    3. 属性重载:在类的外部访问不存在或者无权限访问的属性时,会自动触发重载方法调用。

                    4. 构造方法（__construct()）在类是实例化（创建新对象）之前自动调用。

                    5. 属性继承：继承是指类之间的继承,是代码复用的重要手段。

                    6. protected成员只能在本类或子类中访问，不能从外部访问。

                    7. 多态：子类将父类同名方法进行重写,根据传入参数不同,实现不同的功能,这就是多态性。

                    8. 静态成员是被所有对象共享的，不像普通成员是随着类的实例化（对象）改变而改变的。
                                         

1.  类声明与类的实例化

   实例

   <?php
   /**
    * 类的声明与实例化
    * 1. 类声明: class;
    * 2. 类的实例化: new
    * 3. 对象成员的访问:->
    */
   
   //用关键字class声明一个类
   class Demo1
   {
   
   }
   //用关键字 new 实例化一个类
   $demo1 = new Demo1();
   
   //给当前对象添加一些属性和方法
   $demo1->name = 'zmx';
   $demo1->sex = '男';
   $demo1->hello = function(){
       return '我是一个自定义的类方法';
   };
   //使用对象访问符:-> 来访问对象中的成员(属性和方法)
   echo $demo1->name,': ',$demo1->sex,'<br>';
   
   //错误的调用方式,因为当前对象方法不是一个普通函数,而是一个对象方法
   //echo $demo1->hello();
   //正确的调用方式,对象方法应该以回调的方式运行
   echo call_user_func($demo1->hello);

   
   

   
   

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

   实例

   <?php
   /**
    * 类常量,对象初始化,属性的重载
    * 1. 类常量可用来创建对象之间的共享数据
    * 2. 对象初始化: 用构造方法实现,创建对象之前会自动调用,完全对象的一些初始化工作
    *    例如:对象属性初始化,创建对象时自动调用的方法等,方法名称固定:__construct()
    * 3.属性重载:在类的外部访问不存在或者无权限访问的属性时,会自动触发此类方法调用（动态创建类属性和方法）
    *   属性重载涉及四个方法:获取：__get(),设置：__set(),检测：__isset(),销毁：__unset()
    */
   class Demo3
   {
       private $name;
       private $age;
       private $sex;
       const SITE_NAME = '这是一个类常量';
   
       //构造方法，对当前对象进行初始化，类实例化时会自动调用构造方法
       public function __construct($name,$age,$sex)
       {
           $this->name = $name;
           $this->age = $age;
           $this->sex = $sex;
           echo $this->show();
       }
   
       //获取
       public function __get($member)
       {
           if($member == 'age'){//如果当前要查看的属性为age
   //            return '年龄不允许查看';
               return $this->age;
           }else{
               return $this->$member;
           }
       }
       //设置
       public function __set($member,$value)
       {
           if($member == 'age'){
               return $this->age = $value;
           }
   
       }
      //检测
       public function __isset($member)
       {
           if($member == 'sex'){
               return false;
           }else{
               return isset($this->$member);
           }
   
       }
   //    //销毁
       public function __unset($member)
       {
           if($member == 'sex')
               unset($this->sex);
   
       }
       public function show()
       {
           return $this->name.'的年龄是：'.$this->age.'<br>';
       }
   }
   
   
   //访问类常量，常量:所有对象共享,用类名加范围解析符(::)访问,且默认为公共属性public
   echo Demo3::SITE_NAME;
   $demo3 = new Demo3('zmx',20,'男');//在类实例化之前就自动调用__construct()构造方法
   echo $demo3->age;//触发__get()重载
   $demo3->age = 22;//触发__set()重载
   echo $demo3->age;
   
   if(isset($demo3->age)){//触发__isset()重载
       echo $demo3->sex;
   }else{
       echo '不存在或无权限检测';
   }
   
   unset($demo3->sex);////触发__unset重载
   echo $demo3->sex;

   
   

3. 类的继承与方法重写

   实例

   <?php
   /**
    * 继承与多态
    * 1. 继承是指类之间的继承,是代码复用的重要手段,之前我们是通过"函数"实现的代码复用
    * 2. 继承使用关键字: extends
    * 3. 引用父类成员: parent::
    * 4. 子类可以将父类中的公共成员和受保护成员全部继承
    */
   
   class Demo4  //父类
   {
       public $name;
       protected $age;//protected成员只能在本类或子类中访问，不能从外部访问
       private $salary;
       const APP_NAME = '学生管理系统';
   
       public function __construct($name, $age,$salary)
       {
           $this->name = $name;
           $this->age = $age;
           $this->salary = $salary;
       }
   
   }
   
   class Demo4_1 extends Demo4 //子类（派生类）
   {
       private $sex;//定义子类的属性
       const APP_NAME = '重写常量';//将父类方法进行重写
       //子类将父类同名方法进行重写,根据传入参数不同,实现不同的功能,这就是多态性
       //这里将construct()方法进行重写，参数传入需要包含父类参数
       public function __construct($name, $age, $salary, $sex)
       {
           //这里用parent::来简化代码
           parent::__construct($name,$age,$salary);
           $this->sex = $sex;
       }
   }
   
   //$demo4_1 = new Demo4_1('zmx', 90);
   //echo $demo4_1->name,'<br>';
   //echo $demo4_1->age,'<br>';//不能直接访问protected属性
   
   $demo4_1 = new Demo4_1('小强',23,3000,'男');
   echo $demo4_1::APP_NAME;

   
   

   
   

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

   
   

5. 实例

   <?php
   /**
    * 类中的静态成员与访问
    * 1.类中静态成员使用关键字:static 定义;
    * 2.静态成员是被所有对象共享的，不像普通成员是随着类的实例化（对象）改变而改变的；
    * 3.静态成员是属于类的,应该使用类来访问，例：Class3::name;
    * 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' => 'localhost',
           'dbname' => 'php',
           'user' => 'root',
           'pass' => 'root',
       ];
   
       //声明静态方法
       public static function connect()
       {
           //用self::来调用本类中静态成员$db，实例化一个PDO并传入$pdo
           $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=3)
       {
           //此时$pdo已经成为一个PDO连接类，将其预处理并执行
           $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',10);
   
   //显示结果
   echo '<pre>',var_export($result);