面向对象基础知识点

面向对象阶段

面向过程

    分析出实现功能所需要的步骤，一步步实现

面向对象--oop

    什么是面向对象？

        是一种编程思想，是人类用程序语言对现实世界的模仿。

    有什么好处？

        重用性、维护性、扩展性。。

    有什么特征？

        封装、继承、多态

 

    如何学习？

        语法

        思想

 

面向对象编程 ————OOP

    object-oriented programming

    两大重要概念

        类

            对相同或者相似对象的一种抽象描述

        对象 ———

        女朋友，左右手，象棋

            万事万物皆对象

            客观存在的任何一个实体

        类与对象的关系

            先有类，通过类实例化出来对象

            通常使用的是对象

 

类的定义格式

    class 类名

    {   

        [成员属性] ——相当于写在类里面的变量

            修饰符 $属性名[=值];

        [成员方法] ——相当于写在类里面的函数

            [修饰符] function 方法名(){}

    }

 

命名规范

    my computer

    类名：大驼峰(每个单词首字母都大写)

        MyComputer

    方法名：小驼峰

        myComputer

类的实例化

    new

        $对象名 = new 类名;

        $对象名 = new 类名();

 

    -> 对象成员访问符

        $对象名->属性名;

        注意：不用加$,加了$之后会先将后面当做变量解析

        $对象名->方法名();

 

 

伪变量 $this

    只能在类里面使用

    代表的是对象，表示是自己

 

    在方法中通过$this访问自己的成员属性

    $this->name;

    除了成员属性和方法以外，不能有其他过程化代码

 

成员特性

    成员属性

        可以有默认值

        默认值不能是变量

        可以是常量

        值可以有运算 php 5.6版本以后

        值可以是任意类型

    成员方法

        和以往的函数一致

        可以通过$this直接访问自己的成员属性

 

魔术方法

    构造方法

        __construct

        触发时机：在使用new关键字得到新对象的时候，自动调用，字段调用

        低版本里面有和类名同名的方法，也是构造方法；php7反对使用

    析构方法

        __destruct

        触发时机：在销毁对象的时候，自动调用

    由于栈数据结构的特性，后进先出

 

    __set

        触发时机：给没有权限访问的成员属性赋值的时候

        参数：2个(要设置的属性名，值)

    __get

        触发时机：获取一个没有权限访问的成员属性的时候

        参数：1个 (要获取的属性名)

    __isset

        触发时机：在使用unset检测一个没有权限访问或者不存在的成员属性的时候

        参数：1个（要检测的属性名）

    __unset

        触发时机：在使用unset删除一个没有权限访问或者不存在的成员属性的时候

        参数：1个(要删除的属性名)

    __call

        触发时机：在调用一个没有权限访问或者不存在的方法的时候

        参数：2个(方法名，调用时传的参数)

    __callStatic

        触发时机：在调用一个没有权限访问或者不存在的静态方法的时候

        参数：2个(方法名，调用时传的参数)

    __toString()

        触发时机：将对象当做字符串输出的时候

        参数：不能有

        注意：必须要返回一个字符串

    __invoke()

        触发时机：将对象当做函数调用的时候

        参数：可有可无

    __sleep()

        触发时机：在使用serialize串行化对象的时候

        参数：不能有

        注意：必须要返回一个数组，数组里面包含想要保留的成员属性名

    __wakeup()

        触发时机：在使用UNserialize反串行化对象的时候

        参数：不能有

    __clone()

        触发时机：在使用clone关键字克隆对象的时候

        参数：坚决不能有

     __autoload()

        触发时机：在实例化一个不存在的类的时候

        参数：1个(要实例化的类名)

        注意：文件名一定要规范(和类名同名)

        这是唯一一个不用写在类里面的魔术方法

        这个一个补救措施，需要自己手动include

 

 

new

    每次new都会得到一个新对象都会触发构造方法

对象的比较

    =

        取别名，不会产生新对象

    ==

        判断两个对象是否是同一个类的实例，并且成员属性和值是否相等

    ===

        判断两个对象是否是同一个对象

 

 

 

public      公共的，最奔放的。自己、家族、外部都可以直接访问

protected   中间的。无法再外部直接访问，家族和自己都可以访问

private     私有的，最隐私的，只有自己能访问

 

3p表

        public      protected       private

自己      Y              Y             Y

家族      Y              Y             N

外部      Y              N             N

 

extends

    用于继承父类

    父类：被其他类继承的类叫父类，也叫基类

    子类：继承其他类的类叫子类，页叫派生类

子类拥有父类所有的内容，但是私有的无法访问

三个关键字

    public  protected   private

三个范围

    自己  家族  外部

 

 

方法的封装跟属性的封装一模一样

 

将对数据库的增删改查封装成类

    1.class类名必须和文件名相同，为了以后做自动加载

    2.写一个有意义的类，通常从方法出发

 

 

继承本身的特性

    PHP只支持单继承   只能有一个爹

    PHP可以被多个继承

    一个爹可以有多个儿子

    PHP支持多层继承

    可以有祖孙关系

 

属性的继承

    子类覆盖父类的同名属性，私有的除外

    权限只能扩大，不能缩小

    父类      子类

    public     public

    protected  public   protected

    private    public   protected

    private

 

    访问的一定是覆盖的成员属性，私有的无法覆盖

方法的继承

    子类覆盖父类的同名方法，私有的除外

    权限只能扩大，不能缩小

    父类          子类

    public         public

    protected      public   protected

    private        public   protected

    private

    访问的一定是覆盖后的成员方法，私有的无法覆盖

    建议：重写父类的成员方法，建议参数结构(参数个数，是否有默认值)保持一致

 

    可以通过parent关键字访问父类的方法。

 

    要求：重写父类的构造方法的时候，务必在子类调用一次父类的构造方法，保证基类正常运行

 

    parent

        代表的是类，表示父类

    $this

        代表的对象，表示自己

    :: 范围操作符

 

final：最终的

    可以修饰类和方法，不能修饰成员属性

    被修饰的类不能继承（断子绝孙的类）

    被修饰的方法不能被重写

 

static

    不能修饰类，可以修饰成员属性和成员方法

    被他修饰的成员叫静态成员(类属性、类方法)，可以通过类名直接访问

        类名::$属性名; //一定要加$,如果不加，相当于访问常量

        类名::方法名();

        self::$属性名;

        self::方法名

    静态方法里面不能出现$this

    静态方法里面只能访问静态成员属性

    在类外部可以用类实例化的对象访问静态方法，不能访问静态属性。(属性在堆内存，方法放在代码区)

 

self

    表示的是自己这个类

 

$this

    表示的是自己这个对象

 

parent

    表示的是父亲这个类

 

 

define

    不能在类里面定义常量

const

    可以在类里面定义常量

    在类里面定义的常量处于通过范围操作符访问

        类外

            类名::常量名 //不要加$符

        类内

            类名::常量名

            self::常量名

    const的值不支持变量

 

运算符

    instanceof      

        用于判断前面的对象是否是后面类的实例，包括祖孙关系

魔术方法

得到新对象的方式:

        1、使用new关键字

            会自动触发__construct构造方法

        2、使用unserialize反串行化

            会自动触发__wakeup魔术方法

        //串行化

        // $arr = [1,2,'hehe',4,5];

        // echo serialize($arr);

 

        //反串行化

        // $str = 'a:5:{i:0;i:1;i:1;i:2;i:2;s:4:"hehe";i:3;i:4;i:4;i:5;}';

        // $res = unserialize($str);

        // var_dump($res);

        3、使用clone克隆一个对象会自动触发__clone魔术方法

        例子：$b = clone $a;  //克隆$a对象

   

单态(单例)设计模式

目的：只能得到一个对象

步骤：

    1.封装构造方法，阻止在类外new对象

    2.在类里面提供一个静态的方法，在方法里面new自己

    3.在静态方法中进行逻辑判断

    4.提供一个静态成员属性是否为null，如果为null，实例化并赋值为对象，否则直接返回自己。

多态：让不同类的对象，可以对相同名称的函数调用，产生不同的结果

 

abstract 用于定义抽象方法和抽象类

抽象方法

    没有方法体的方法，用abstract修饰

    抽象方法必须以分号结尾

    抽象方法不能是private私有的

 

抽象类

    拥有抽象方法的类叫抽象类，用abstract修饰

    半成品，无法直接实例化

    继承后，必须要实现父类所有的抽象方法。否则自己也一定是抽象类

    *抽象类里面可以有自己的普通成员属性和成员方法

 interface 定义接口

 格式

    Interface 定义接口名

    {

        [常量]

        [抽象方法]

    }

implements

接口特性

    接口里面所有方法都是抽象的，可以省略abstract的修饰

    接口不是用来实例化的，而是用来实现的(implements)

    继承不能同时继承，但是接口可以多实现：class Mouse implements USB,YES {}

    接口与类之间是实现关系；接口与接口之间是继承关系

 

类的定义格式完整版

    [关键字] class 类名[ extends 父类名][ implements 接口1,接口2]

    {

        [成员属性]

        [成员方法]

    }

接口与抽象类的关系:

    单纯的定义规范，两种都可以

    定义规范的时候，还需要共享一下自己的属性和方法，只能用抽象的

 

类型限制

    8大类型中可以作为类型限制的：

        int string float bool arrray

    callable 可以限定参数为回调函数其他所有的都会被认为是类名或者接口名!

 

和类相关的函数

    1.class_alias('旧类名','新类名');

        给类名取个别名

    2.method_exists(对象或者类名，'方法名');

        检测对象或者类(不受封装限制)中的方法是否存在

    3.property_exists('对象或者类名','属性名');

        检测对象或者类中的属性是否存在，父类的私有属性无法检测

    4.class_exists('类名');

        检测类是否存在

    5.get_object_vars(对象)

        获取对象中有权限访问的成员属性，返回一个数组

    6.get_class_methods(类名或者对象)

        获取类或者对象中有权限访问的方法，返回一个数组

    7.get_perent_class('子类名');

        获取父类类名

 

   

PDO的事务处理

    事务：将一堆细小的操作当成一个整体，整体成功则全部成功；一个失败则全部失败；

    事务处理

        MYSQL中只有innodb才支持事务处理

            innodb  支持事务，行锁

            muisam  不支持事务，表锁

 

    小黑框使用事务：

        begin;  //开启事务

        rollback    //回滚(默认)

        commit;     //提交事务

 

    注意：做事务操作之前，必须确认引擎是innodb的

 

    查看表引擎：

        show create table 表名;

    修改表引擎：

        alter table 表名

        engine=innodb;

        

    例：

        try {

                //得到pdo

                $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>2]);

 

                //开启事务

                $pdo->beginTransaction();

                $sql = "update shop_user set money=money-500 where id=13";

                $row = $pdo->exec($sql);

 

                $sql = "update shop_user set money=money+500 where id=3";

                $row += $pdo->exec($sql);

                if ($row == 2) {

                    //提交事务

                    $pdo->commit();

                    echo '转账成功';

                } else {

                    //回滚事务

                    $pdo->rollback();

                    echo '转账失败';

                }

            } catch (PDOException $e) {

              

            }

PDO类里面的其他方法

    try {

            //得到pdo

            $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>PDO::ERRMODE_EXCEPTION]);

 

            //获取属性

            echo $pdo->getAttribute(PDO::ATTR_ERRMODE);

            //查看当前pdo可以操作哪些数据库

            var_dump($pdo->getAvailableDrivers());

            $username = $_GET['username'];

            $pwd = md5(123);

            //自动处理参数中的特殊字符

            $username = $pdo->quote($username);

            $sql = "select * from shop_user where username=$username and pwd='$pwd'";

            echo $sql;

        } catch (PDOException $e) {

            echo $e->getMessage();

        }

PDO的查询

    $stmt->fetch()

        从结果集对象中读取一条

    $stmt->fetchAll()

        从结果集对象中读取所有

    $stmt->rowCount()

        返回受上一个SQL语句影响的行数

   例：

        try {

                $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>2]);

 

                $sql = "select * from shop_user where id > 0";

                $stmt = $pdo->query($sql);

                var_dump($stmt);

 

            从结果集对象中读取一条

                 echo PDO::FETCH_ASSOC;   //2

                 $row = $stmt->fetch(PDO::FETCH_ASSOC);   //常用：返回关联数组

                 $row = $stmt->fetch(PDO::FETCH_NUM); //返回索引数组

                 $row = $stmt->fetch(PDO::FETCH_BOTH);    //混合数组

                 $row = $stmt->fetch(PDO::FETCH_OBJ); //返回对象

                 var_dump($row);

 

            从结果集对象中读取所有

                echo $stmt->rowCount();

                $arr = $stmt->fetchAll(PDO::FETCH_ASSOC);

                var_dump($arr);

 

 

                //不推荐直接遍历对象

                // foreach ($stmt as $v) {

                //  // var_dump($v);

                // }

            } catch (PDOException $e) {

                echo $e->getMessage();

            }

 prepare预处理

    1.先发送一条预处理sql语句

        $pdo->prepare($sql);

    2.绑定参数

        $stmt->bindValue(1,值或者对象);

        1代表第一个坑，从左往右数第一个问号?

    3.确认执行

        $stmt->execute();

        或者：

        $stmt->execute(数组);

        需要传唯一索引数组，下标必须从0开始。

 

    例：

        try {

                $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>2]);

 

 

                //准备一条预处理的sql语句

                $sql = "select * from shop_user where username=? and pwd=?";

                //发送预处理sql语句，返回一个预处理对象

                $stmt = $pdo->prepare($sql);

 

                $username = $_GET['username'];

 

                //绑定参数：预处理的sql语句从左到右数?，从1开始数

                // $stmt->bindValue(1, $username);

                // $stmt->bindValue(2, md5(123));

 

            //准备数组自动绑定

                // $data[3] = $username;    //不行

                $data[] = $username;

                $data[] = md5('123');

                // var_dump($data);exit;

 

                //真正的执行

                $stmt->execute($data);

                var_dump($stmt);

                $arr = $stmt->fetchAll();

                var_dump($arr);

            } catch (PDOException $e) {

                echo $e->getMessage();

            }

 

prepare预处理之冒号占位符

    例：

        try {

            $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>2]);

            准备一条预处理的sql语句

            $sql = "select * from shop_user where username=:username and pwd=:pwd";

            发送预处理sql语句，返回一个预处理对象

            $stmt = $pdo->prepare($sql);

            $username = $_GET['username'];

            绑定参数：预处理的sql语句从左到右数?，从1开始数

            $stmt->bindValue(':username', $username);

            $stmt->bindValue('pwd', md5(123));

 

        准备数组自动绑定

            有点像$_GET或者$_POST

            $data['pwd'] = md5('123');

            $data['username'] = $username;

 

            // var_dump($data);exit;

            echo '<pre>';

                print_r($stmt->debugDumpParams());

            echo '</pre>';

            //真正的执行

            // $stmt->execute();

            $stmt->execute($data);

            $arr = $stmt->fetchAll();

            var_dump($arr);

        } catch (PDOException $e) {

            echo $e->getMessage();

        }

prepare预处理之增删改操作

    例：

        try {

            $pdo = new PDO('mysql:dbname=shop;charset=utf8', 'root', '123', [3=>2]);

            //准备预处理sql语句

            $sql = "insert into shop_user(username, pwd) values(:name, :pwd)";

            //发送预处理语句

            $stmt = $pdo->prepare($sql);

            //绑定参数

            $data['name'] = '老马';

            $data['pwd'] = md5(38);

            //确认执行

            $res = $stmt->execute($data);

            var_dump($res);

            //受影响行数

            echo $stmt->rowCount().'行受了你的影响<br>';

            //最后插入ID

            echo '最后插入的ID是：'.$pdo->lastInsertId();

        } catch (PDOException $e) {

            echo $e->getMessage();

        }

 

PDO操作sqlite数据库

    例：

   try {

        $pdo = new PDO('sqlite:./cookies.sqlite');

        // var_dump($pdo);

        //查询所有的表和建表语句：moz_cookies

        $sql = "select * from sqlite_master where type='table'";

        $stmt = $pdo->query($sql);

        // $stmt = $pdo->exec("update moz_cookies set name='xxoo' where id=4");

        // $stmt = $pdo->exec("delete from moz_cookies where id=2");

        // $stmt = $pdo->exec("delete from moz_cookies where id>4");

        // var_dump($stmt);

        // $stmt = $pdo->query("select * from moz_cookies");

        $res = $stmt->fetchAll(PDO::FETCH_ASSOC);

        var_dump($res);

    } catch (PDOException $e) {

        echo $e->getMessage();

    }     

 

命名空间

    1.用namespace定义命名空间

    2.命名空间的定义必须是在脚本的最前面，之前不能有任何输出。

    例：

        // echo 1;  // very first

 

 

        // echo ' ';

        namespace genji;

        class A{

            public $name = '根基';

        }

        $a = new A;

        var_dump($a);

 

        namespace fangchang;

        class A{

            public $name = '方长';

        }

        $a = new A;

        var_dump($a);   

 

受命名空间影响的类、函数和常量(const定义的常量)

    例：

        namespace fangchang;

        $a = 10;

        define('HOST', 'localhost');

        //受影响的种类

        const DB = 'shop';

        class A{}

        function demo(){}

        namespace genji;

        echo $a;

        echo HOST;

        // echo DB;     //no，无法直接访问

        // $a = new A;  //无法直接实例化其他命名空间的类

        // demo();  //函数也无法直接调用

 

定义子命名空间

    namespace a\b\c\d;

    const DB = 'shop';

    namespace hehe;

    echo \a\b\c\d\DB;    

 

命名空间的使用

    一个文件里面定义多个命名空间

     */

    namespace a\b{

        const DB = 'shop';

 

        //绝对路径：完全限定名称

        // \a\b\c\d\demo();

        //相对路径：限定名称

        c\d\demo();

        //非限定名称:相当于./

        echo DB;

    }

    // echo 1;  //不行的

    namespace a\b\c\d{

        echo \a\b\DB;

        function demo(){

            echo '函数';

        }

        // demo();

        function var_dump(){

            echo '呵呵哒';

        }

        $a = 10;

        var_dump($a);   //输出呵呵哒

    }

 

    // namespace c; //不能混合使用

    //  echo 1;

 

use导入命名空间

        namespace a\b\c\d\e{

        echo __NAMESPACE__; //魔术常量，代表自己这个命名空间名

        echo '<hr>';

        class A{}

        class B{}

        class C{}

        class D{}

        function demo(){}

        const DB = '123';

    }

    namespace a\b\c\d{

        // use a\b\c\d\e;   //会将最后一截作为别名

        // use a\b\c\d\e as xxoo;   //导入的同时取别名

        //导入具体的内容，可以直接使用；否则：e\demo();

        // use a\b\c\d\e\A; //导入一个类

        use a\b\c\d\e\A as qitaA;   //导入一个类并取别名

        use function a\b\c\d\e\demo;    //导入一个函数

        use const a\b\c\d\e\DB; //导入一个常量

        demo();

        echo DB;

        class A{

            public $name = 1;

        }

        // $a = new \a\b\c\d\e\A;   //完全限定名称

        // $a = new e\A;

        // $a = new xxoo\A;

        $a = new A;

        $a = new qitaA;

        var_dump($a);

    }

    // namespace Think;

    // use Think\Auth;

    // $obj = new Auth();