面向对象php 接口 抽象类

　　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.接口可以实现多个接口，但抽象类只能继承一个；  （网上这样说    持怀疑态度）；