php初级之数组与 类初级

PHP 是后端脚本语言，回顾一下：

1.1 PHP 数组：

 <?php
     $user = array();                           // 定义一个数组
     $user[0] = 'zhangsan';                     // 给数组赋值
     $user[2] = 'lizi';                         // 给数组赋值
     echo count($user).'<br>';                  //输出数组中元素的个数
     print_r( $user );                          // 打印数组的详细项目
 ?>

运行结果：

1.2 数组输出乱码：

<?php
    $user = array();      // 定义一个数组
    //[] 是在该数组 最大的数字索引上+1
    $user[] = 'zhangsan';
    $user[8] = '李四';
    $user[] = '王明';
    $user[] = '张三';
    $user[] = '毛小芳';
    $user[] = 'wangwu';
    echo count($user).'<br>';
    print_r( $user );
?>

1.3 在PHP文件开头加入header("Content-type: text/html; charset=utf-8");

<?php
    header("Content-type: text/html; charset=utf-8");
    $user = array();      // 定义一个数组
    //[] 是在该数组 最大的数字索引上+1
    $user[] = 'zhangsan';
    $user[8] = '李四';
    $user[] = '王明';
    $user[] = '张三';
    $user[] = '毛小芳';
    $user[] = 'wangwu';
    echo count($user).'<br>';
    print_r( $user );
?>

乱码变OK了：

1.4  array_keys() 获取数组的键的数组（这里有点类似js中Object.keys() 获取对象的键的数组），array_values()获取数组的值组成的数组

implode(): 把数组链接成字符串：语法implode（separator,array）;

separator  可选，规定在数组元素之间放置的内容；如果没有separator 则默认是""（空字符串）

explode():把字符串分隔，然后组合成数组：语法explode(separator,string,limit) ;

separator 必须，规定在哪里分隔字符串

string必须，需要分隔的字符串

limit 可选，规定返回的数组的最大数量

 <?php
     header("Content-type: text/html; charset=utf-8");
     $user = array(
         'title' => '星星',
         'content' => '恒星',
         'age' => '25亿万年'
     );
     $keys = array_keys( $user );
     print_r( $keys );
     //implode--->join (在js中用join进行链接)    implode 把数组以'，'为分隔符链接成字符串；格式 implode(separator,array);
     // explode 把字符串分隔成数组，格式 explode(separator,string,limit)
     echo implode( ",", $keys )."<br>";
     $values = array_values( $user );
     print_r( $values );
     echo implode( "','", $values )."<br>";
 ?>

运行结果：

1.5 遍历数组：

 <?php
     header("Content-type: text/html; charset=utf-8");
     $userList = array(
         0 => array(
             '张三',
             '李四',
         ),
         1 => array(
             '小星星',
             '小强强'
         )
     );
     // 这里的foreach 类似js中的forEach()以及for(var i in obj)
     foreach( $userList as $k => $v ){
         echo $k . '--->' . $v[0] . '--->' . $v[1] . '<br/>';
     }
     echo  "<br>"."--------------这里是分割符------------------"."<br>"."<br>";
     foreach( $userList as $k => $v ){
         // echo $k . '--->';
         echo $k;
         foreach( $v as $k2 => $v2 ){
             echo '---->' . $v2;
         }
         echo '<br/>';
     }
 ?>

运行结果：

1.5.2 foreach遍历：

格式：foreach($arr as $key => $value) ,也可以简写为for($arr as $value) 省略$key

 <?php
     header("Content-type: text/html; charset=utf-8");
     $arr = array(
         0 => 1,
         3 => 10,
         5 => 100
     );

     foreach( $arr as $key => $val ){
            echo $key . '-->' . $val . '<br/>';
      }

     foreach( $arr as $val ){
         echo $val . '<br/>';
     }
 ?>

1.5.3 for循环，缺点是不能遍历不连续的数字索引，或者字符串索引

 <?php
     header("Content-type: text/html; charset=utf-8");
     $arr = array(
         0 => 1,
         3 => 10,
         5 => 100
     );

     echo '数组的长度是：'.count($arr).'<br>'; //3

     //$i---> 0, 1, 2
     //for循环的缺点：不能遍历 不连续的数字索引 和 字符串索引
     for( $i = 0; $i < count( $arr ); $i++ ){
         // $arr[0] $arr[1] $arr[2]
         echo $arr[$i] . '<br/>';
     }

 ?>

2. 创建一个类

 <?php
     /*
         定义一个类：格式如下
         class 类名称 {

         }
         类是由n个属性和方法组成的
     */

     header("Content-type: text/html; charset=utf-8");
         class MobilePone{
             public $cpu ='麒麟970';
             public $memory = "640G";
             public function favarit(){
                 echo '上网';
             }
             public function play(){
                 echo '神秘星球';
             }
             public function pragram(){
                 echo '编程网页';
             }
         }
         // 调用：想要调用，首先需要进行实例化 ,这里和js有点类似，在js中，构造函数的调用，也需要进行实例化，然后才能调用
         // 实例化对象：对象名 = new 类名()
         $shili = new MobilePone();
         // 然后是调用
         // 调用方法：对象->方法名
         $shili->play();
         echo '<br>';   // 这里是换行
         $shili->favarit();
         echo '<br>';   // 这里是换行
         $shili->pragram();
         echo '<br>';
         //调用属性：  对象->属性名称[注意，属性名前面不需要美元符号]
         echo $shili->cpu;
         echo '<br>';
         echo $shili->memory;
 ?>

运行结果：

2.2 类中的修饰符（权限控制符）

 <?php
     //Object.defineProperty
     header("Content-type: text/html; charset=utf-8");
     class Computer {
         //public: 属性修饰符: 用来控制 属性/方法 的访问权限
         /*
             常见的属性修饰符用3个:
                 public( 公共的 )
                 protected: 受保护的( 继承里面讲 )
                 private: 私有的
         */

         //类的外面：　类的定义中 {} 的外面
         //类的里面:   类的定义中 {} 的里面
         public $keyboard = '键盘'; //public: 在类的外面 和 类的里面 都能够访问
         public $mouse = '鼠标';
         private $cpu = '64核 麒麟975'; //private: 只能在类的内部才能访问
         public function showInfo(){
             //this: 哪个对象调用我，我就指向谁
             // '.'号:在php中，用于字符串的链接，相当于js中的'+'号
             echo $this->cpu . '--->' . $this->mouse . '--->' . $this->keyboard;
         }
     }
     $c = new Computer();
     $c->showInfo();
  ?>

2.3 在类外是不能够访问私有属性的（即private 作为修饰符的部分，只能在类内部访问）

 <?php
     //Object.defineProperty
     header("Content-type: text/html; charset=utf-8");
     class Computer {
         //public: 属性修饰符: 用来控制 属性/方法 的访问权限
         /*
             常见的属性修饰符用3个:
                 public( 公共的 )
                 protected: 受保护的( 继承里面讲 )
                 private: 私有的
         */

         //类的外面：　类的定义中 {} 的外面
         //类的里面:   类的定义中 {} 的里面
         public $keyboard = '键盘'; //public: 在类的外面 和 类的里面 都能够访问
         public $mouse = '鼠标';
         private $cpu = '64核 麒麟975'; //private: 只能在类的内部才能访问

         public function showInfo(){
             //this: 哪个对象调用我，我就指向谁
             // '.'号:在php中，用于字符串的链接，相当于js中的'+'号
             echo $this->cpu . '--->' . $this->mouse . '--->' . $this->keyboard.'<br>';
         }
     }

     $c = new Computer();
     $c->showInfo();

     echo $c->keyboard.'<br>';
     echo $c->mouse.'<br>';
     echo $c->cpu.'<br>'; //报错， 在类的外面 不能访问私有的属性

 ?>

2.4  类外也不能访问受保护的属性（即用protected 修饰的属性）

 <?php
     //Object.defineProperty
     header("Content-type: text/html; charset=utf-8");
     class Computer {
         //public: 属性修饰符: 用来控制 属性/方法 的访问权限
         /*
             常见的属性修饰符用3个:
                 public( 公共的 )
                 protected: 受保护的( 继承里面讲 )
                 private: 私有的
         */

         //类的外面：　类的定义中 {} 的外面
         //类的里面:   类的定义中 {} 的里面
         public $keyboard = '键盘'; //public: 在类的外面 和 类的里面 都能够访问
         public $mouse = '鼠标';
         private $cpu = '64核 麒麟975'; //private: 只能在类的内部才能访问
         protected $aaa = '这是受保护的属性';
         public function showInfo(){
             //this: 哪个对象调用我，我就指向谁
             // '.'号:在php中，用于字符串的链接，相当于js中的'+'号
             echo $this->cpu . '--->' . $this->mouse . '--->' . $this->keyboard.'--->'.$this->aaa.'<br>';
         }
     }
     $c = new Computer();
     $c->showInfo();

     echo $c->keyboard.'<br>';
     echo $c->mouse.'<br>';
     echo $c->aaa.'<br>';//报错， 在类的外面 不能访问受保护的属性 

 ?>

3. 构造函数 __construct()：函数在实例化的时候，就会调用构造函数

<?php
   /*
        构造函数:
            1, 定义的时候, 他的函数名 __construct
                php4 构造函数名是跟类同名
            2, 构造函数 不需要手动去调用, 自动被调用
            3, 当对象实例化的时候， 构造函数会被自动调用
   */
    header("Content-type: text/html; charset=utf-8");
    class Person{
        public $name;
        public $sex;
        public function __construct($n,$s){
            echo '如果此段文字被输出了，说明实例化类的时候会调用__construct()函数'.'<br>';
            $this->name = $n;
            $this->sex = $s;
        }
    }
    $p1 = new Person('huanying2015','man');
    $p2 = new Person('aluoha','man');
?>

4. 继承：

继承1：父类所有的public修饰的属性和方法；继承2：父类所有的protected 修饰的属性和方法

类的继承格式：

class 类名  extends 父类名{}

<?php
    header("Content-type: text/html; charset=utf-8");
    class Person {
        public $name;
        public $age;

        public function __construct( $n, $a ){
            $this->name = $n;
            $this->age = $a;
            echo '父类实例化'.'<br>';
        } 

        public function speak(){
            echo '说话<br/>'.'<br>';
        }

        protected function eat(){
            echo '吃饭<br/>'.'<br>';
        }

        private function waimao (){
            echo '长相<br/>'.'<br>';
        }
    }

    //class 类名 extends 父类名
    /*
        继承 到底 继承了什么？
            1，父类所有的public的属性和方法
            2, 父类所有的protected的属性和方法
            3, private的属性和方法 不会继承过来

        public: 类内，类外，子类 可以访问
        protected: 类内，子类 可以访问
        private: 类内 可以访问

    */
    class Student extends Person{
        public $No;
        // 扩展构造函数
        // public function __construct($n,$a,$no){
        // echo '子类实例化'.'<br>';
        // //parent:父类
        // parent::__construct($n,$a); // 调用父类的方法：构造函数
        // $this->No = $no;            // 把自己扩展的属性也加上去，这样自己的构造函数就完整了
        // }
        // 也可以重写构造函数
        public function __construct($n,$a,$no){
            echo '子类实例化'.'<br>';
            $this->name = $n;
            $this->age = $a;
            $this->No = $no;
        }
        // 如果不满意父类的方法，可以重写父类的方法，改写完成后，对父类不会造成影响
        public function speak(){
            echo '我是一名学生，说的是学生话'.'<br>';
        }
        // 父类没有的类，可以在这里进行扩展，添加新类
        public function test(){
            echo '我的学号是：'.$this->No.'学生正在考试'.'<br>';

            $this->eat();  //protected 修饰的方法：能够被子类继承，所以此处可以被访问
            $this->waimao(); //pravite 修饰的方法：不能够被子类继承，所以此处是访问不到的，会报错
        }

    }

    $p = new Person( '周星星', 23 );           // 父类实例化
    $p->speak();           // 父类方法调用

    $stu = new Student('光头强', 22, '2342343' ); // 子类实例化
    $stu->speak();       // 子类方法调用，这里是调用重写后的方法
    $stu->test();          // 子类调用扩展的方法

?>

小结：修饰符的说明：

public：类外可以调用，类内可以调用，可以继承

protected：类外不可以调用，类内可以调用，可以继承

private：类外不可以调用，类内可以调用，不可以继承