js面向对象
类：具有相同特征的一些对象的集合；
对象：具体某一个事物了，都可以叫对象；
类：通过function定义的类，所以js里类的本质为函数；
类的标志：首字母大写（函数名 ） 函数内部使用this 调用函数使用new关键字；
1.类和函数天生有prototype和__proto__两个属性，prototype又是一个对象，天生有一个constructor的属性，属性值函数或类本身；
2.普通对象：天生有一个__proto__的属性，这个属性又是一个对象，指向他的父类；
引用关系：
fn.prototype.init=function(){}
fn.prototype={ init:function(){} }
他们的区别？
前者不会改变原有引用关系，后者会改变原有的引用关系；
注意：每个变量只能有一个地址
拷贝：浅拷贝，深拷贝；
php的面向对象
类的创建：class创建；
class Person{}
对象的创建：使用new关键字：
$p:new Person(); (如果里面没有参数，可以不加括号)；
成员的添加：需要3个修饰符：public protected private
public：定义公共的属性，任何地方都可以使用，类的外部，类的内部，子类（公共）
protected：定义受保护的属性和方法，只能在类的内部和子类使用（受保护）
private：定义私有的属性和方法，只能在自身的类使用（私有）
案例：
public $word="hello world"; (解析：定义公共的变量word)
方法成员的前面如果不加修饰符，默认为public；
成员的调用： 需要使用->符号；
$p->fn() （使用成员的属性和方法的时候，属性和方法前面不带$符）
特殊对象：$this 指向实例化的对象；
案例：
class person{
public $name="lisi"; //(php每个语句后面一定要加；)
function fn(){
echo $this->name; //通过->调用属性和方法；
}
$s=new Person;
$s->fn();
}
如果类的方法里想用类的其他属性和方法，需要使用$this对象；
构造方法：__construct() 构造函数在实例化的时候，系统会自动调用；
析构的方法：__destruct() 我们每次new实例化，系统都会给这个对象分一个内存空间，如果不销毁，系统的压力很大，所以系统有一个析构的方法__destruct() 实例化之后，系统会自动调用；
内存销毁的原则：先进后出；
案例：构造和析构联合使用
class Person{
public $name;
//构造的方法；
function __construct($par){
$this->name=$par
}
//析构的方法；
function __destruct(){
echo $this->name;
}
}
$p=new Person("zhang");
最后输出zhang 翻译为 函数传参使$name="zhang"; 使用完毕后，会销毁内存； 析构会直接输出 无需调用；
成员的赋值
$p->name=456;
echo $p->name; 单独赋值的方法;
注意：对象中的方法不会展开var_dump() 不能用这个展开对象；
继承的关键字：extends
class Child extends Person{}
$c=new Child;
var_dump($c) 这样继承所有属性 但是方法却看不见
范围的修饰符 ::
常量的使用const的关键字定义常量，常量定义和使用时不能带$符
注意：使用的时候不能用$this ，范围修饰符:: 前面还是这个类名，self关键字指向当前类名，parent关键字指向父类的类名；
如果子类向访问父类的常量使用parent；
案例：
//父类
class Person{
cont age="23",
}
//子类
class Child extends Person{
const name="zhang";
function fn(){
echo self::age; //指向当前类名
echo parent::name; //指向父类
}
}
$p=new Child;
$p->fn();
静态变量：在变量的前面加上关键字static，静态的属性不能使用->访问，只能使用 类名::$变量名；
案例：
class Perosn{
static $name="zhang";
}
echo Person::$name;
12.重载。覆盖；final关键字的使用
子类继承父类的方法时，如果子类有和父类同名的方法从父类继承的方法就会被覆盖掉，这就是重载；
但如果父类的方法前面加上final则子类无法重载父类的方法，就会报错
案例：
//父类：
class Person{
final function fn(){
echo "我的孩子，不能起我的名字，否则会报错"
}
}
class Child extends Person{
function fn(){
echo "我不能用我爸的名字 我要报错"
}
}
$p=new Child;
$p->fn;
子类想使用父类的构造函数，只能使用 parent::__construct() 使用的时侯直接调用了；
案例：
//父类
class Person{
public $name="zhang";
function __construct(){
echo $this->name;
}
}
//子类
class Child extends Person{
function __construct(){
parent::__construct();
}
}
$p=new Child;
public protected private 的区别？
案例：了解即可：
//父类
class Person{
public function a(){
echo "a";
}
protected function b(){
echo "b";
}
private function c(){
echo "c";
}
}
$p=new Person;
$p->a(); 不会报错
$p->b(); 会报错
$p->c(); 会报错
//子类
class Child extends Person{
function d(){
parent::a() //调用父类的a方法
}
function e(){
parent::b()
}
function f(){
parent::c()
}
}
$c=new Child;
echo $c->d(); 不会报错
echo $c->e(); 不会报错
echo $c->f(); 会报错
