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：类外不可以调用，类内可以调用，不可以继承