对象：系统中用来描述客观事物的一个实体，构成系统的一个基本单位。
类的 实体化 是框架。
类：使用 class 来声明一个类，后面紧跟 类 的名字，主体用{}括起来。
语法：
class class_name{
....
}
类里面包含属性和方法
属性：用关键字 var 来声明变量，即 创建了类的属性。
语法：
class class_name{
public $var_name;
}
如果是定义了 一个人 的类，那么 人的 名字，年龄，性别等等就可以看做 人 的属性！
方法：
通过在类定义中声明函数，即创建了类的方法。
class class_name{
function function_name(arg1.arg2,...)
{
函数功能代码
}
}
类的应用：
一个定义了 属性 和 方法 的类就是完整的类！
语法： object = new class_name();
实体化一个对象，用 -> 操作符来访问对象 的 成员属性 和 方法。
语法：
object -> var_name;
object -> function_name;
如果要在定义的类里面访问成员的属性或者方法，可以使用伪变量$this,
$this可以表示当前 对象 或者 对象本身。
实例：
<?php
class Person{
//人的属性
public $name; //人的名字
public $age; //人的年龄
//人的成员say()方法
function say(){
echo "我的名字叫:".$this -> name."<br/>";
}
}
构造方法：__construct 创建对象自动调用，给方法一个初始值
例子：
class 对象名1
{
//属性
public $name;
public $weight;
//方法
public function __construct($name, $weight)
{
//功能：初始化
$this->name = $name;
$this->weight = $weight;
}
}
//new一个对象
$对象名2 = new 对象名2(值1,值2);
析构方法：__destuct 销毁对象
魔术方法：__get对象外部访问私有
__set对象外部设置私有
__unset销毁对象私有属性
__isset设置对象私有属性
1.继承 extends 继承后拥有父类的成员属性和方法
格式：class 子类名 extends 父类名
例子：
class Father
{
public $name;
function extends()
{
echo '子类继承父类';
}
}
class Son extends Father
{
public $age;
}
2.重写（重载） 子类方法覆盖父类
①完全重写 ②parent::方法名 能显示父类的方法
例子：
class Father
{
public $name;
public $age;
public $sex;
function work()
{
echo '父亲方法';
}
}
class Son extends Father
{
function work()
{
parent::work();
echo '儿子方法';
}
}
3.final
final:修饰类，这个类不能被继承
final:修饰方法，这个方法不能被重写
4.类常量 const
调用：外部：类名::常量名 或者($obj::常量名字)
内部：self::常量名 或者($this::常量名)
注意：
常量类面前不能加任何权限修饰符，内部只能用const
例子：
class Pig
{
const WUQI = '武器类';
function test()
{
echo self::WUQI;//内部要这样去引用
}
}
$wuneng = new Pig();
$wuneng->test();
5.静态属性和方法 加static
静态的属性的调用：
类的外面：
类名::静态属性名
类的内部:
self::静态的属性名
静态方法的调用：
类的外部：
类名::静态方法名字
类的内部：
self::静态方法名字
6.魔术方法
__invoke 对象当作函数
__toString var_dump一个对象
__debugInfo echo一个对象
__call 调用一个对象
__autoload 自动加载 一个不存在的类
__callStatic 调用一个静态对象
例子：
function __autoload($className)
{
//var_dump($className);打印出来就是 Person
include $className . '.php';
}
$xiaoming = new Person();
$xiaoming->test();
1.抽象类 不能被实例化的叫做抽象类，有抽象方法的抽象类也叫抽象类，抽象类就是拿来继承的
格式：
abstract class 类名
abstract 权限修饰符 function f方法的名字();
注意事项:
1.抽象类不能被实例化
2.抽象类存在的目的就是继承
3.抽象类里面抽象方法，抽象方法必须让子类去重写，也可以有普通的方法
4.抽象类可以继承抽象类,子类里面必须要实现父类里面所有的抽象方法
例子：
abstract class Animal
{
abstract function eat();
}
abstract class Dog extends Animal //1.加abstrsct就是抽象类
{
//抽象方法,没有方法体的方法
abstract function jiao(); //3.子类里面必须重写
abstract protected function jiaopei();//子类里面必须重写
function jump()
{
echo '跳';
}
}
//继承过来才能用
class Tidy extends Dog //2.就是为了继承
{
//父类是一个抽象类，抽象类的所有的抽象方法在子类必须去重写，如果有一个没有被重写，就会报错
function jiao ()
{
echo '父类有 叫';
}
function jiaopei()
{
echo '父类有 交配';
}
function eat()
{
echo 'eat';
}
}
$ritian = new Tidy();
$ritian->jump();
$ritian->jiaopei();
$ritian->eat();
2.接口 特殊的抽象类
语法：
interface 定义
implements 来实现
1.由于接口是一个特殊的抽象类，所以他里面的方法是抽象方法，也可以把abstract省去
2.接口里面不能有变量和普通方法
3.一个类可以实现多个接口
4.接口中的权限修饰符是只能public
5.一个类可以先继承一个父类，然后再去实现接口
6.接口可以继承接口
例子：
<?php
interface Test
{
function hehe();
}
class Animal
{
}
interface Xiaoren extends Test
{
function he();
function piao();
function du();
}
//声明一个接口 用interface
interface Junzi
{
public function honest(); //接口里面不能有变量和普通方法，权限修饰符是只能public
public function rich();
public function talent();
}
//实现接口 用implements
class Person extends Animal implements Junzi,Xiaoren
{
function honest()
{
echo '诚实';
}
function rich()
{
echo '富有';
}
function talent()
{
echo '天才';
}
function he()
{
}
function piao()
{
