php类和对象->作用,php.类与对象

访问控制

属性和方法的访问控制(可见标识)：

public 任何地方

private 类自身

protected 类自身，自子类及自父类

this

this 可以理解为这个类的一个实例

self

self 代表类本身

__construct

实例化时就会自动执行

public function __construct() {}

__destruct

当对象对销毁时自动执行

public function __destruct(){}

类常量

定义合不可改变

const ONE = 1

const TWO = self::ONE + 1;

可以在类外部调用

Class::Two

parent

parent代表父类

public function __construct(){ parent::__construct();}

final

final class Dad(){} 加到类定义前面表示Dad类不想被继承

class Dad(){

final public function run(){} // 加到方法声明前面，表示方法不想被子类重写

}

namespace

namespace必须放在代码文件的第一行

受命名空间影响的类型：类(包括抽像类，traits)、接口、函数和常量。

当没有使用namespace关键字指定命名空间时，当前脚本是存在于全局命名空间的。用\表示。\Class1

类全在指定的命名空间去查找，没找到则抛出错误。

函数与常量，在指定命名空间查找，没找到则到全局命名空间查找，还没打到则抛错。

函数

ns1\ns2\fn()

常量

define定义的常量是全局的，不受命名空间影响。

const定义的常量受命名空间影响。

namespace ns1\ns2;

const ONE = 1;

echo ns1\ns2\ONE;

use

导入类

用use导入命名空间下的类

use ns1\ns2\class1;

用as重命名导入的类

use ns1\ns2\class1 as class2;

导入函数

use function ns1\ns2\fn as fn1;

导入常量

use const ns1\ns2\ONE;

自动加载

__autoload

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

spl_autoload_register

传匿名函数

spl_autoload_register(function($className){ require $className . '.php'; });

传函数名

function test($className){ require $className . '.php'; }

spl_autoload_register('test');

传类

class Momo

{

function autoload($className)

{

require $className . '.php';

}

}

spl_autoload_register([new Momo, 'autoload']);

static

声明静态属性和静态方法，不经过实例化，通过类名即可调用。

class Person()

{

public static $hand = '手';

public static function run()

{

echo 'running...';

}

}

echo Person::$hand;

Person::run();

类内部调用静态属性和静态方法用self关键字

echo self::$hand; self::run();

调用父类的静态属性和静态方法用parent关键字

echo parent::$hand; parent::run();

后期静态绑定

class A

{

public static function who()

{

echo 'A类的who方法';

}

public static function test1()

{

self::who();

}

public static function test2()

{

static::who();

}

}

class B extends A

{

public static function who()

{

echo 'B类的who方法';

}

}

B::test1(); // test1内部用的self，调用的是自身(A类)的静态方法

B::test2(); // 后期绑定。内部用static，根据后期的调用环境确定，调用的是B类的静态方法

魔术方法

__set

class Test

{

private $name = '';

public function __set($var, $val)

{

// 对$val进行数据处理

$this->$var = $val;

}

}

$test = new Test();

$test->name = 'tom'; // 赋值tom

__get

class Test

{

private $name = 'jack';

public function __get($var)

{

return $this->$var;

}

}

$test = new Test();

echo $test->name; // jack

__isset

用于检测私有属性是否存在

class Test

{

private $name = 'mary';

public function __isset($var)

{

return isset($this->$var);

}

}

$test = new Test();

var_dump($test->name); // 如果不设置__isset，返回false,设置后返回true

__unset

用于删除私有属性

class Test

{

private $name = 'Levi';

public function __unset($var)

{

unset()

}

}

$test = new Test;

unset($test->name); // 会触发__unset

__call

避免调用一个不存在的方法时产生错误，当调用的方法不存在时，__call方法会自动调用

class Test

{

public function __call($fn_name, $fn_arguments)

{

echo $fn_name;

print_r($fn_arguments);

}

}

$test = new Test();

$test->go(1, 'ok'); // 自动调用`__call`方法，打印出函数名和参数数组

__callStatic

同__call类似

避免调用一个不存在的静态方法

class Test

{

public static function __callStatic($fn_name, $fn_arguments)

{

echo $fn_name;

print_r($fn_arguments);

}

}

// `__callStatic` 必须声明为静态方法

Test::go(1, 'ok');

__invoke

当对象以函数的形式调用的时候，自动调用__invoke方法

class Test

{

public function __invoke($args)

{

return $args;

}

}

$test = new Test();

$test('go.....'); // 运行__invoke

__toString

当打印对象是会调用__toString方法

class Test

{

public function __toString()

{

return 'Hello world!';

}

}

$test = new Test;

echo $test; // 输出 Hello world!

对象复制

浅拷贝

比较省内存，对象的拷贝默认是浅拷贝。

$a = new Test();

$b = $a; // 浅拷贝。传址。改变$b。$a也会改变。

对象的复制是浅拷贝的。传址。

普通变量的拷贝是深拷贝的。传值。

深拷贝

$a = new Test();

$b = clone $a; // 深拷贝。改变$b，不会改变$a。

__clone

当使用clone关键字时，自动调用__clone方法

class Test

{

public $obj = null;

public function __clone()

{

$this->obj = clone $this->obj;

}

}

class Person

{

public $sex = 0;

}

$a = new Test;

$a->obj = new Person;

$b = clone $a; // 触发`__clone` 对obj进行深拷贝

$b->obj->sex = 1; // $b中的obj对象改变了。而$a中的obj对象没变。

类型约束

class A

{

public function go()

{

echo 'go .....';

}

}

function test(A $a) {

$a->go();

}

test(new A());

Trait

单继承语言PHP的代码复用机制。

Trait Bt

{

public function atest()

{

echo 'Hello ';

}

public function btest()

{

echo 'world';

}

public function ab()

{

$this->atest();

$this->btest();

}

}

class Test

{

use Bt; // 使用Bt Trait，便拥有了Bt所有的方法

}

$test = new Test;

$test->ab();

继承多个Trait

Trait A

{

public $name = 'tom';

public function a()

{

echo 'Hello ';

}

}

Trait B

{

public function b()

{

echo 'world ';

}

}

class Test

{

use A,B;

public function c()

{

echo $this->name;

}

}

$test = new Test;

$test->a();

$test->b();

$test->c(); // Hello world tom

Trait 支持嵌套

Trait A{}

Trait B{}

Trait C

{

use A,B;

}

Class Test

{

use C;

}

interface

接口是类的模板。在接口中只定义需要实现的空方法，这些方法在接口中不做具体实现。

接口是不能被实例化的。

Interface Person

{

public function eat();

public function sleep();

}

class man implements Person

{

public function eat()

{

echo 'eating...';

}

public function sleep()

{

echo 'sleeping...';

}

}

class L

{

public static function factory(Person $user) // 用接口作类型约束

{

return $user;

}

}

$user = L::factory(new Man());

$user->eat();

$user->sleep();

接口可以继承接口。

接口可以继承多个接口。

接口可以使用常量，叫接口常量，和类的常量使用方法相同

Interface Ia

{

const ONE = 1;

public function eat();

}

Interface Ib

{

public function sleep();

}

Interface AB extends Ia,Ib

{}

// class Test implements Ia,Ib 类可以同时继承多个接口

class Test implements AB

{

public function eat()

{

echo 'eating...';

}

public function sleep()

{

echo 'sleeping...';

}

}

$test = new Test;

$test->eat();

$test->sleep();

echo Ia::ONE; // 使用接口常量

abstract

抽象类不能被实例化。

如果至少有一个方法被声明为抽象的，那么这个类必须被声明为抽象的。

抽象方法只能声明，不能有具体功能实现。

抽象类可以有被实现的的方法。

继承抽象类，子类必须实现父类中所有的抽象方法。

这些方法的访问控制必须和父类一样，或者更宽松，不能比父类更严格。

方法的调用方式也必须匹配。类型和参数数量必须一致，但子类可以定义父类中不存在的可选参数。

abstract AB

{

public function run()

{

echo 'running...';

}

abstract public function eat();

abstract public function sleep();

}

class Test extends AB

{

public function eat()

{

echo 'eating...';

}

public function sleep($time = '21:00 PM') // 可以定义父类方法中不存在的可选参数

{

echo 'sleep @ ' . $time;

}

}

单例模式

只能被实例化一次，节省内存空间

class Test

{

private static $instance = null;

private function __constrct()

{}

private function __clone()

{}

public static function getInstance()

{

if (!(self::instance instanceof self)) {

self::instance = new self();

}

return self::instance;

}

}

$test = Test::getInstance(); // 多次调用也只是实例化一次

工厂模式

Interface CacheI

{

public function set($key, $value);

public function get($key);

public function delete($key);

}

class Memcache implements CacheI

{

public function set($key, $value){}

public function get($key){}

public function delete($ke){}

}

class Redis implements CacheI

{

public function set($key, $value){}

public function get($key){}

public function delete($ke){}

}

class Cache

{

public static function factory()

{

return new Memcache(); // 这里可以是继承了CacheI接口的任何类，比如Redis

}

}

$cache = Cache::factory();

$cache->set('name', 'tom');

$cache->get('name');

$cache->delete('name');