1.定义类和实例化对象;

  使用关键字class定义类,使用new实例化对象;

  2.类成员的添加和访问;

  类成员:有属性,方法,常量(常量名不带$符);

  访问属性的时候,变量名不带$符

  添加属性需要使用修饰符:

  public:公共的,类外,类内,子类都可以访问;

  protected:受保护的,类内,子类可以访问;

  private:私密的,类内,访问;

  public $name="zhang"  添加成员;

  添加方法,如果方法前不带修饰符,默认为public 

  public function fn(){}  添加方法

  访问属性:

    $p->name;

  访问函数:

    $p->fn();

  赋值:

    $p->name="456";

  添加常量:使用关键字const常量名;

    const txt="hello world";

  访问常量:范围解析符::  类名::常量名;

    echo Person::txt;

  3.类的内部对象$this和内存原理;

    $this 他是一个对象 指向实例化对象;

    $p->fn()  $this 指向调用他的对象;   (因为实例对象,可能有很多个,所以谁调用,指向谁);

  #2 代表第2个;

  内存原理:

    当我们new实例化的时候,系统会给这个对象分配一个内存空间,内存空间分一个栈内存,一个堆内存,将变量存在栈内存里,将代码块存在堆内存里,然后将堆的内存地址,指向栈的变量,

  如果再给这个栈中变量赋值引用数据类型,那么内存地址就会被修改;

  

  思考:这样的话,都指向一样的内存地址,$b也就失去了意义,怎样才能将他的属性和方法,都得到,且随意更改,都不会影响到原来的变量呢?( 了解:   js使用,深拷贝)

  需要使用php的关键字 clone 通过关键字clone来赋值一个一模一样的对象,但二者却又不是一个对象;

  

  对象传值:传的是地址;

  5.构造函数和析构函数;

  构造函数:我们在申明类的时候,就自然存在,当new实例的时候这个函数会自动调用,也可以人为的去写自己的东西;

  function __construct()  函数名只能是这个;

  析构函数:用于销毁new实例的内存,如果不销毁内存,那么系统的性能会大大降低;

  new实例化以后,这个函数也会自动调用 

  销毁的原则:先进后出;

  6.静态成员的添加;

    在成员属性,成员的方法前面加上static关键字就可以了,

  静态成员的访问;

    static public $name="zhang";

    1.在类的内部访问 self::$name;  (推荐);

            类名::$name;   (也可以,但建议使用第一种);

    2.在类的外部访问 类名::$name;  (仅一种方法);

  7.面向对象三大特征;

  封装:白话:对外只告诉你如何操作,内部的结构不需要你知道;

     专业术语:对外只提供操作的接口(方法),对内的数据操作不可见;

    案例:

      class yun{

        private $num=45;

        private $a=2;

        public function fn(){

          return $this->num*$this->$a;

        }

      }

      $p=new yun;

      $p->fn();

  继承:子类可以继承父类的属性和方法,但有限继承;

    public  protected  private  这样修饰的属性可以继承了,protected  public修饰的方法可以继承了,父类的常量也可以继承了;

    注意:私有的,受保护的不能再公共的调用,只能在公共的方法,调用私有或受保护的,在外面调用公共的方法;

  多态:php没有多态,因为php是弱类型语言,不会对变量提前进行类型声明,但是有重载,   

     重载:父类和子类的方法相同,子类会覆盖父类的方法;

  8.关键字parent

    在继承中子类有这个parent,访问父类的常量,父类的方法,父类的静态属性,属性成员不可以访问;

  9.final 关键字,汉语意思为(不可继承的);

    final class fn{}  子类不可继承;

    final function fn(){}  子类可以访问,但是不能创建相同的函数名;

    如果写在类的前面,表明这个类不能被继承;

    如果写在方法的前面,表明这个方法不能被重载;

  10.abstract  关键字  代表抽象类;

    场景联想:如果项目经理需要对所有的子类进行规范,就是说,这些成员必须有,且必须使用那些名字,就需要使用抽象类的概念了;

    1.抽象类不能实例化;

    2.如果一个类里面有其他方法,被申明为抽象类了,这个类就得声明抽象类

    3.只要这个方法被声明抽象方法,就不能写函数体,将函数后面的{}去掉,函数体有子类实现;

    4.在继承一个抽象类的时候,子类必须定义父类中的所用抽象方式;不是抽象方法,子类可以不用定义;

  11.接口:interface

  接口的用途和抽象类差不多,都是为了写一些规范;

  1.使用interface关键字定义接口

   interface pp{

    public function fn();

  }  

  interface aa{

    public function fn();

  }

  接口的方法都是空的,没有函数体;

  2.接口中的所有方法都是public;

  3.使用implements这个操作符;

    class ss implements pp{

      public function fn(){}

    }

  4.一个类可以实现多个接口,接口和接口之间用逗号隔开;

  5.接口和接口之间,方法尽量不要重名,如果重名了,那么参数要保持一致;

    class ss implements pp,aa{

      public function fn(){}

    }

  抽象类和接口的区别?

    1.接口使用implements 而抽象类使用extends实现;

    2.接口中只能声明公有的方法,抽象类:属性,常量,方法,都可以申明;

    3.接口没有构造函数,抽象类有;

    4.接口可以实现多个接口,但抽象类只能继承一个;  (网上这样说    持怀疑态度);