面向对象

面向对象 对象概念是面向对象技术的核心。在显示世界里我们所面对的事情都是对象，如计算机、电视机、自行车等。在面向对象的程序设计中，对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象.

oop主要三个特性
封装：成员变量变为私有的，通过方法间接操作成员变量，在方法里面加限制条件，让类更安全。

封装一个类需要两步 第一步是私有化一个类 第二步是用set和get 做出读取赋值的操作。他的好处是：隐藏类的实现细节，可以方便加入逻辑控制性，限制对属性的不合理操作，便于修改增强代码的可维护性。

继承：子类可以继承父类的一切，在子类里面对父类进行方法重写。单继承：一个子类可以有多个父类，一个父类可以派生出多个子类。
多态：父类引用子类实例，由于子类里面对父类的方法进行重写，父类引用在调用该方法的时候表现出的不同状态。

面向对象模型

面向对象的概念：
oop(面向对象的编程)它能是其代码更加简洁易于维护并且具有更强的可重性

什么是类：
类是具有相同属性和服务的一组对象的集合比如说人，书，轮船，车都属于类，他为属于该类的对象做了一个统一的抽象描述，在编程的语言中类是一个单独的程序，它应该有一个类名包括属性的说明和服务两个部分。

什么是对象：
对象是系统中描述客观事件的一个实体，他是构成系统的一个基本单位。*数据与代码都被捆绑在一个实体当中*，一个对象由一组属性和对这组属性进行操作的一组行为组成。
从抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象。他反映该事物在系统中保存的信息和发挥的作用：它是一组属性和有权对这些属性进行操作的一个封装体。客观世界是由对象和对象之间的联系组成的。
类和对象的关系：
类与对象的关系就如模具和铸件的关系，类的实例化的结果就是对象，而对对象的抽象就是类，类描述了一组有相同特性（属性）和相同行为的对象。

类与属性和方法
PHP中定义类语法格式：

class classname [可选属性]{//声明类
public $property [=value];… //用public声明一个公共标识 然后给予一个变量 变量也可以赋值
function functionname ( args ){ //类的方法里的成员函数
代码} …
//类的方法（成员函数）
}

生成对象(类的实例化): $对象名=new classname( );

使用对象的属性
在一个类中，可以访问一个特殊指针$this当在该类中通过一个操作设置或访问该变量时,使用$this->name来引用。

对象的生成
定义好类后用一个new来声明，由于对象资料的封装特性，对象是无法由主程序区块直接访问的须通过对象来调用类中所定义的属性和行为函数，间接地达成存取控制类中资料的目的。

对象和类的关系:
对象是实际存在的，占有动态资源。
类是对象的蓝图，可能占有静态资源。
对象属性占有动态资源。

即，类本身不占空间，但当有静态类时，占有一部分空间。对象本身占有空间。

性能考虑:
每个对象要单独占用数据空间。
增加的调用层次可能消耗执行时间。

方法的参数形式和传递方式：
方法的参数可以是基本数据类型、数组和类对象。
基本数据类型：值参传递
数组：值参传递
类对象：引用传递（可以将一个变量通过引用传递给函数，这样该函数就可以修改其参数的值。）

function foo(&$var){
  $var++;  
}
$a = 5;
foo($a);//输出6

访问控制：

1.public:公共的，类外使用，类外使用，子类也可使用

2.protected：受保护的,外部不可以调用,自身和子类可调用

3.private:私有，不可被继承;自己可用，子类、外部不可调用。  外部通过公共方法可以获取私有的

魔术方法：

__set($_propertyName,$_propertyValue):运行过程中为私有的成员属性，设置值，没有返回值。

__get($_propertyName):在对象外部自动获取私有成员的属性值。

__isset($_propertyName):判断变量是否存在。

__unset($_propertyName):销毁变量。

__clone():当执行克隆clone(100%复制，不可修改)时会自动调用的方法。此方法可在内部修改变量等。

__toString():快速获取对象的字符串，当echo时会被自动调用。

　　   1.必须返回字符串的值，意味着使用echo输出。

　　   2.echo object是会被直接调用

　　   3.方法中，必须使用return $this->变量/方法调用内部内容

__call(方法名,数组形式的参数列表):当调用的对象中不存在方法时，被调用，并产生错误。

__autoload():自动加载类，以’类名.class.php‘规则形式。

__construct() 构造函数，实例化对象时被调用，即初始化时被第一个调用。

__destruct ()析构函数，当对象销毁时被调用。

静态方法：

　　关键字-static：声明类成员或方法为static，就可以不实例化类而直接访问。

　　"::"：范围解析操作符，不需要实例化对象，可直接调用。

　　注意，静态方法中不可以有非静态的内容;静态属性是共享的;若方法中没有$this，则默认为静态方法。

　　　　定义方式：修饰符 static 变量名='变量值'//修饰符 static function 方法名(){}；  类中：类名::$静态属性/方法；类的方法中：self::$静态属性/方法

static function p(){
    echo self::$country;
    echo self::PI;//访问常量
    //echo $this->name;在静态方法中只能操作静态属性
    //self::p();
}

常量调用：

　　关键字-const：访问方式与static差不多，但不使用'$'符号。

const CONSTANT = 'constant value'; 生成一个常量
echo self::CONSTANT;//类内部访问
echo ClassName::CONSTANT;//类外部访问

继承性
B类的对象拥有A类的全部属性与行为，称作B对A类的继承。
假如一个类从多个类中继承了属性与服务，这称为多继承，通常我们成为继承类为子类被继承类为父类，在PHP中只有单继承，但一个父类可以被多个类继承，但是一个子类只能有一个父类，但是允许关联继承，通过继承可以减化类的定义。
extende声明继承关系
语法格式：class B extends A 此范例指明 B继承了A
类的外部访问对子类是有效的
子类与父类的属性与方法
子类继承父类的所有内容，但父类中的private部分不能直接访问
子类中新增加的属性和方法是对父类的扩展
子类中定义的与父类同名的属性是对父类属性的覆盖，同名的方法也是对父类方法的覆盖。

重写的方法
在子类中，使用parent访问父类中的被覆盖的属性和方法

parent::__construce();
parent::$name;
parent::fun();

覆盖父类原有属性
clone克窿对象 语法格式$c=clone $p; $c克窿的对象$p 输出echo $c->name;

对象比较
===两个比较运算符。
==是比较两个对象的内容。
===是比较对象的句柄，即引用地址。

instanceof操作符用于检测对象实力是否属于某一个类的类型 属于返回true 不属于返回false
__clone()如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法

function __clone(){
$this->name="我是一个克隆人";
}

关键字-final表示一个类是最终版本 也就是说它不能在被子类中被调用。

多态性

多态性是指在父类中定义的属性或行为被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。
就是说同一种方法在子类与父类中执行的结果形态不同。

class A {
function info(){
echo “A INFO”;
}
}
class B extends A {
function info(){
echo “B INFO”;
}
}
class C extends A {
function info(){
echo “C INFO”;
}
}
function printinfo($obj){
function printinfo(A $obj){
if($obj instanceof A)
$obj->info();
$obj->info();
}
}
$a=new A(); $b=new B(); $c=new C();
printinfo($a); //输出A INFO
printinfo($b); //输出B INFO
printinfo($c); //输出C INFO

抽象方法和抽象类

抽象方法是做为子类模版使用的。

abstract class Person{
public $name;
abstract function getInfo();
}

特点，

  1.不能实例化  ,只能被继承

  2.抽象方法不能包含方法体，既没有花括号，直接分号结束

  3.如果至少有一个方法是抽象方法，这个类就必须声明抽象类

  4.父类中的抽象方法，在子类中必须实现或重写

 接口：

　　使用interface定义，implements声明，方法全部是抽象方法的抽象类，当一个类继承了一个接口之后，它要覆盖接口的所有方法，接口只能声明常量，接口的方法必须定义为共有否则无法继承，接口可以与多个接口间继承。

语法：

interface PCI{
    const TYPE="PCI";
    //public $name; error
    function start();
    function stop();
}

接口中的方法可以声明为static

interface A{ function a();}
interface B{ function b();}
interface C extends A{ function c();}
class D implements B,C{
    function a(){}
    function b(){}
    function c(){}
}

note：用于实现子类继承多个不同父类的方法，一旦实现则接口中的所有方法都被继承，不能遗漏。

　　1.定义方式：interface 接口名{}

　　2.拓展：interface Two extends One{}  接口Two继承接口One

　　3.普通类链接接口：class Four implements One{}

接口是规定某类必须实现接口中定义的方法，通过关键字interface定义，但是接口中不需要定义方法的具体内容，既不需要有方法体。且，所有的方法都必须是公共的（默认public）。

好处是规范，每个类都统一。平级的类都必须实现接口中的方法，只是实现的方式不一样。

使用的规范是：

　　不能实例化，只能通过implements来声明。使用‘,’间隔，可以声明多个接口。

　　接口中的属性必须是常量。

　　接口中的方法必须是public，且没有方法体。

　　接口间可以互相继承。

接口与抽象类的区别：

　　1.抽象类中有实现好的普通方法，并且是子类用来继承的，但其中方法子类可以不实现。

　　2.接口中全部为抽象方法，实现一个接口就必须实现其中所有的抽象方法，不能有遗漏。

 git文档 传送