面向对象

一直用的都是框架，今天花了几个小时，简单的温习了一下面向对面，在这里进行简单的回顾一遍：

面向对象的三个重要特点：重用性，灵活性，扩展性

第一节：命名空间
如果两个命名空间里面是同一个方法的话
只需要：
use venter\session\Imooc;
use venter\Imooc as Imooc2;

第二节：全局空间的类：
带反斜杠即可
—->var_dump(new \Test1());

第三节：类自动加载

function __autoload($className)
{
    require $className.".php";
}

===>$imooc = new Imooc();
或者：

function spl_autoload_register(function($className){
    require $className.".php"
})

或者：

function test($className)
{
    require $className.".php";
}
spl_autoload_register('test');
$imooc = new Imooc();
var_dump($imooc);

或者：

class Momo
{
    function autoload($className)
    {
        require $className.".php";
    }
}
spl_autoload_register([new Momo,'autoload']);
$imooc = new Imooc();
var_dump($imooc);

第四节：后期静态绑定：

class A{
    public static function who()
    {
        echo "A";
    }
    public static function test()
    {
        self:who();
    }
}
class B extends A{
    public static function who()
    {
        echo "B";
    }
}
B:test(); ---->输出B

第五节：魔术方法：
__set()
__get()

—->案例：

class Test
{
    private $abc = '';
    private $cba = '';
    public function __set($var,$val)
    {
        $this->$var = $val;
    }
    public function __get($var)
    {
        return $this->$var;
    }
}
$test = new Test();
$test->abc = 'abc';
var_dump($test->abc); ---->输出abc

__isset —>私有属性是否存在：

class Test
{
    private $abc = 'abc'; //私有属性
    public function __isset($var)
    {
        return isset($this->var)?true:false;
    }
}
$test = new Test();
var_dump(isset($test->abc));

__unset —>用户删除私有属性的时候，就会去回调：

class Test
{
    private $abc = 'abc';
    public function __unset($var)
    {
        echo ("__unset:".$var);
        unset($this->$var);
    }
}
$test = new Test();
unset($test->abc);

__call —->当我们调用的方法不存在的时候产生错误，可以使用call

class Test
{
    public function __call($func,$arguments)
    {
        echo ($func);
        print_r($arguments);
    }
}
$test = new Test();
$test->go(1,'ok'); ====>go Array([0]=>1,[1]=>ok);

__callStatic —->当静态方法不存在，就调用callStatic

class Test
{
    public static function __callStatic($func,$arguments)
    {
        echo ($func);
        print_r($arguments);
    }
}
Test:go(1,'ok');

__invoke —>当对象以函数的方式被调用时，就用到这个

 class Test
 {
    public function __invoke($arg)
    {
        var_dump($arg)
    }
 }
 $test = new Test();
 $test('go...'); ===>go...

__toString —->当打印对象变量的时候，toStrong就自动调用了：

class Test
{
    public function __invoke($arg)
    {
        var_dump($arg);
    }
    public function __toString()
    {
        return "Hello";
    }
}
$test = new Test();
echo ($test);

第六节：对象拷贝和类型约束：

class A
{
    public $age = 0;
    public $username = "";
    //对象属性：
    public $obj = null;
}
$a = new A();
$b = $a; //浅拷贝 --->剩内存
$b->age = 1;
var_dump($a->age);  ===>1
  深度：对象复制：浅拷贝+深拷贝
  例如：我要出去玩，需要车，叫老爸给我车钥匙，老爸叫我去抽屉拿。东西就一个：车钥匙
  我去拿车钥匙，这一步骤叫地址传递
所以---->
浅拷贝：地址传递
深拷贝：复制一亮车钥匙给我 （值传递）

如果：
$a = new A();
$b = clone $a; //深拷贝
$b->age = 1;
var_dump($a->age);  ----> 0 

加深印象—>

class A
{
    public $age = 0;
    public $username = "";
    //对象属性
    public $obj = null;
}
class B
{
    public $sex = 0;
}
$a = new A();
$a->obj = new B();
$b = $a;   //浅拷贝
$b->obj->sex = 1;
var_dump($a->obj->sex); --->1

如果：
$a = new A();
$a->obj = new B();
$b = clone $a;  //这里仍然是浅拷贝
$b->obj->sex = 1;
var_dump($a->obj->sex); ===>1

如果：
class A
{
    public $age = 0;
    public $username = "";
    //对象属性
    public $obj = null;
    public function __clone()
    {
        $this->obj = clone $this->obj;
    }
}
class B
{
    public $sex = 0;
}
$a = new A();
$a->obk = new B();
$b = clone $a; //这里是深拷贝
$b->obj->sex = 1;
var_dump($a->obj->sex);  --->0

类型约束

class A
{
    public $name = "";
    public function go()
    {
        echo "go....";
    }
}
function test(A $a)
{
    $a->go();
}
test(new A());

第七节：Trait关键字：解决单继承的问题
PHP5.4开始：

trait Bt
{
    public function atest()
    {
        echo "A";
    }
    public function btest()
    {
        echo "B";
    }
    public function ab()
    {
        $this->atest();
        $this->btest();
    }
}
class Test
{
    use Bt;
}
$test = new Test();
$test->ab(); --->AB

再来一波操作：

trait A
{
    public $abc = "abc";
    public function a()
    {
        echo "Hello";
    }
}
trait B
{
    public function b()
    {
        echo "world";
    }
}
trait C
{
    use A,B;
}
class Test
{
    use C;
    public function a()
    {
        echo "hei";
        echo ($this->abc);
    }
}
$test = new Test();
$test->a();
$test->b();
$test->c();
   ===⇒  hello world hei abc

第八节：接口类和抽象类以及设计模式：

interface Person
{
    public function eat();
    public function sleep();
}
class Man implements Person
{
    public function eat()
    {
        echo "大餐";
    }
    public function sleep()
    {
        echo "大觉";
    }
}
class L
{
    public static function factory(Person $user)
    {
        return $user;
    }
}
$user = L::factory(new Man());
//很多业务逻辑代码：：：：
$user->eat();

单例模式跟工厂模式：
单例模式：确保一个类只要一个实例
具体的：http://blog.csdn.net/jungsagacity/article/details/7618587 —>挺不错的