php.类与对象

头像
轻风掠翼
    阅读 7 分钟
    2

    访问控制

    属性和方法的访问控制（可见标识）：
    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');
    类对象php
    轻风掠翼
    18 声望0 粉丝
    « 上一篇
    git.工作区&暂存区
    下一篇 »
    树莓派连接WIFI无线网络配置

    引用和评论

    推荐阅读
    头像
    win10配置wampServer局域网访问站点

    轻风掠翼阅读 3.3k

    头像
    如何实现一个楼中楼的评论系统

    小蚊酱赞 24阅读 10.3k

    头像
    Just for fun——迅速写完快速排序

    ufdf赞 3阅读 2.6k

    头像
    这些年

    注销赞 2阅读 3.9k

    头像
    php-fpm reload 会取消正在处理的请求的解决方案

    陆安赞 2阅读 2.7k

    头像
    一个用JavaScript生成思维导图(mindmap)的github repo

    注销赞 1阅读 6k

    头像
    从零开始 Elasticsearh Docker 单机集群

    zzMeow赞 1阅读 2.7k

    0 条评论
    得票最新