面向对象编程

一. 面向对象思想

        OOA：面向对象分析

        OOD：面向对象设计

        OOP：面向对象编程

二.类和对象

       1. 对象：一切事物皆对象，对象是系统中用来描述客观事物的一个实体，是构成系统的最基本的组成单位；

                 每个对象有属于自己独立的属性和方法；

        2.类：类是把具有相似特性的对象归纳到一个类中，类就是一组相同属性和行为的对象的集合；

        3.类和对象的关系：a.类是相似对象的描述；b.先有类，再有对象；c.类是对象的抽象；d.对象是类的实例；

三.类的申明

        1.创建类

               class 类名{

                     //成员属性和方法

                }

        2.成员属性

               在类中申明的变量；

               一个类可以包含多个成员属性；

               注意：成员属性可以有默认值，也可以没有默认值，如果有默认值，值不能是变量、表达式、函数和方法的                           调用，只能是一个值；

        3.成员方法

              在类中申明的方法就是成员方法

              一个类可以包含多个成员方法

        4.实例化类

              new  类名;       实例化类，实例化类的结果产生对象；

四.对象中内存分配

        1.栈空间段：栈的特点是空间小，CPU访问的速度快，适合存储程序中临时创建的变量，栈后进先出；

        2.堆空间段：堆是用于存放运行中被动态分配的内存段，它大小不固定，可以动态扩展或收缩，使用存放数据长                              度可变或内存比较大的数据，像字符串、数组、对象都是存放在堆空间段；

        3.代码段：代码段是用来存放可执行文件的操作命令，可以想象成可执行程序在内存中的镜像，像函数就是存放                           在代码段中；

        4.初始化静态段（数据段）：存储程序静态分配的变量；

五.构造函数和析构函数

        1.构造函数：public function __construct($var1, $var2,...){}

                          构造函数，当创建对象的时候首先会调用构造函数，适合初始化数据操作；

        2.析构函数：public function __destruct(){}

                          析构函数不能带有参数，析构函数会在对象的所有引用被删除或显示的销毁之前会被调用；

                          可以通过析构函数释放资源、释放结果集；

六.封装性

        1.访问修饰符：

                public:公有的，所有人都可以访问调用；

                protected:受保护的，继承类（子孙）可以访问；----在类内部或者子类中可以访问到

                private:私有的，只有自己内部访问调用；如果外部需要访问，可以通过调用函数（接口函数）访问；

七.魔术方法（这几个魔术方法可见性必须设置成public function...，而且参数不能通过引用来传递）

        1.__set()：在类外部对私有的或者受保护的或者未定义的成员进行赋值的时候会自动调用；

        2.__get()：在类外部对私有的或者受保护的或者未定义的成员进行读取的时候会自动调用；

        3.__isset()：当在类的外部对私有的、受保护的、未定义的成员属性进行isset()或者empty()判断时自动触发；

        4.__unset()：当在类的外部对私有的、受保护的、未定义的成员属性进行unset()操作的时候自动触发；

八.继承

        1.继承性：  class  子类  extends  父类{

                             

                            }

         2.注意：PHP是单继承；（子类只能有一个父类，父类可以有多个子类）

                      代码的高可重用性；

                      代码的高可扩展性；

                      当继承时，重写父类的方法或者属性时，子类的可见性一定要比父类的宽松；

         3.父类--基类--超类；          

            子类--派生类--扩展类

九.parent关键字：       parent::父类方法；    子类可以通过parent关键字调用父类写过的方法；

       若子类方法与父类方法一样，子类重写父类方法；

十.final关键字：代表的是最终，不能被重写或者重载

        如果父类中的方法被声明为final，则子类无法覆盖该方法；

        如果一个类被声明为final，则不能被继承；

         

十一.static关键字：

        通过static关键字修饰类中的成员属性和成员方法是静态的，是属于类的，不用实例化对象就可以直接访问

        类名|self ::属性名

        类名|self ::方法名

        在类内部不能通过$this引用静态属性和方法，需要通过self来引用

        静态属性是共享的

        在静态方法中不能使用$this访问成员属性（包括静态和非静态的都不能用）

        在类的外部（实例化对象）可以访问静态方法，但不可以直接访问静态属性；        

<?phpheader('content-type:text/html;charset=utf-8');class Test{    static public $count=0;    public $int=111;    public function __construct(){        //Test::$count++;        //echo Test::$count;        self::$count++;        //$this->count++;    X    在类内部不能通过$this引用静态属性和方法，需要通过self来引用            }    static public function getCount(){        //echo $this->int;    //    X   在静态方法中不能使用$this，即使是非静态内容也不行；                return self::$count;     //静态函数中不能使用非静态变量，因为在类的非静态成员不存在的时候类的静态成员就存在了；    }    static public function test1(){        echo 'this is test1...<br/>';    }}Test::$count=88;echo Test::$count.'<br/>';Test::test1();      //可以通过类名直接访问静态方法，不需要通过实例化变量$test1=new Test();$test2=new Test();echo Test::$count;echo '<hr/>';$test3=new Test();$test4=new Test();echo Test::getCount();echo '<br/>';echo $test3->getCount();   //可以通过实例化变量访问静态方法//echo $test4->count;      //但不可以通过实例化变量访问静态属性echo '<hr/>';

        后期静态绑定：用于在继承范围内引用静态调用的类；与self不同的是不在解析为当前方法所在的类，而是实际运行时计算的类（可用get_called_class()函数来得到被调用的方法所在的类名）

十二.const关键字：

         定义常量，相当于常量属性，不能是表达式、变量等，只能是值（define）

        访问规则与static类似：1. 类名|self|static:常量名 ；2.常量属于类，通过类访问，不能通过实例直接调用；

十三.类中常用函数

        is_a()/instanceof ：检测一个对象是否是这个类的实例；

        get_class()：返回对象的类名；

        get_parent_class()：返回类或对象的父类名；

        is_subclass_of()：检测一个对象是否是另外一个类的子类

十四.抽象类abstract：不能直接被实例化，只能通过子类继承抽象方法，使抽象类具体化

        类实例没有实际意义，不想直接被实例化，因此出现抽象类；

        abstract  class  类名{

               abstract  public|protected|private  function 方法名();

        }

        1.通过abstract关键字定义抽象类，当类中至少有一个方法为抽象方法的时候，这个类必须定义成抽象类；

        2.抽象类不能直接被实例化，只相当于定义了调用的方式，并没有具体的实现；

        3.子类在继承的时候必须实现所有的抽象方法；

        4.子类在实现抽象方法的时候，可见性可以和父类相同或者宽松；

        5.在抽象类中可以有其他的方法体，不一定都是抽象方法；

十五.接口interface

        对外提供的服务出口，一种规范/契约，类和类之间的一直协议

        接口中的方法必须都是公有的，不能包含有方法体

        定义：

              interface 接口名{

                     public function 方法名([$参数]);

               }

        1.接口中必须是纯粹的模版，只能定义功能，不能包含具体的实现类容;

        实现接口：implements   必须要实现接口中定义的所有方法

              class 类名 implements 接口名{

                       接口中方法的实现

               }

        2.一个类可以实现一个或多个接口，接口之间用逗号分隔，但是接口的方法不能有重名；

        3.一个类可以继承另外一个类，再实现多个接口；要先继承再实现；

                 class Child1 extends Parent1 implements iA,iB{...}

        4.接口中也可以实现继承，可以继承多个接口；实现接口时，需要实现所有接口中的方法

                 interface iD extends iA,iB,iC{...}

        5.接口中也支持常量；访问常量的形式：    接口名::常量

        6.接口与抽象类的区别：抽象类中可以有具体的实现方法，而接口中只能是定义好的模版；

                                               抽象类只能有一个父类---单继承，而接口可以多继承；

十六.多态

        指公用接口后面可以维护多个实现

        继承实现多态

        接口实现多态

十七.常用魔术方法的使用

        __constract():

        __destruct():

        __set():

        __get():

        __toString():直接输出对象不报错，当输出对象的时候会被自动调用，返回字符串；

        __invoke($args):当以调用函数的方式调用对象的时候，会自动触发这个方法；func_get_args()

        __call():当对象调用一个不可访问或者不存在的方法的时候，自动调用；

        __callStatic():用静态的方式调用一个不可访问或者不存在的方法，会自动调用；

        clone: 默认情况下，对 对象的直接赋值是引用赋值，使用的是同一个内存空间 ；

                   而clone相当于赋值另外一个完全相同的对象，是两个不同的个体；

        __clone():克隆对象时自动调用；

        __wakeup():反序列化的时候自动调用；unserialize()

        __sleep():序列化的时候自动调用，返回数组；serialize()