PHPクラスとオブジェクト

アクセス制御

プロパティとメソッドのアクセス制御(可視アイデンティティ):
publicどこでも
privateクラス自体
protected親クラスとサブクラスから以来、クラス自体を

これ

thisクラスのインスタンスとして理解することができます

自己

selfクラス自体の代表

__construct

インスタンス化されると自動的に実行される
public function __construct() {}

__destruct

オブジェクトが破棄されたときに自動的に実行される
public function __destruct(){}

クラス定数

定義は変更できません

const ONE = 1
const TWO = self::ONE + 1;

クラス外に呼び出すことができます
Class::Two

parent親クラスの代わりに
public function __construct(){ parent::__construct();}

ファイナル

final class Dad(){}フロント添加クラスがクラスがお父さんを継承したくない定義します

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

名前空間

namespace (抽象クラスを含む、形質)クラス、インタフェース、機能および定数:タイプによって影響を受けるコードファイルの名前空間の1行目に配置されなければなりません。
使用しないときはnamespace名前空間のキーワードを指定し、現在のスクリプトは、グローバル名前空間に存在しています。 \表現。 \Class1
クラスはすべて指定された名前空間で検索され、見つからない場合はエラーがスローされます。
関数や定数、指定された名前空間に見えるが、 没找到则到全局命名空间查找間違ったキャストをヒット、ではありません。

機能

ns1\ns2\fn()

定数

define定義された定数はグローバルで、影響を受ける名前空間ではありません。
const影響を受ける名前空間で定義された定数。

namespace ns1\ns2;
const ONE = 1;

echo ns1\ns2\ONE;

使用

インポートクラス

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']);

静的

静的メソッドと静的メソッドをインスタンス化せずに宣言すると、クラス名で呼び出すことができます。

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());

特性

単一の継承言語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 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 A{}
Trait B{}
Trait C
{
    use A,B;
}
Class Test
{
    use C;
}

インターフェース

インターフェイスはクラスのテンプレートです。 実装する必要がある空のメソッドだけがインターフェイスに定義されています。これらのメソッドはインターフェイスに実装されていません。
インタフェースはインスタンス化できません。

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;    // 使用接口常量

要約

抽象クラスはインスタンス化できません。
少なくとも1つのメソッドが抽象として宣言されている場合、そのクラスは抽象として宣言されなければなりません。
抽象メソッドは宣言することしかできず、実装する特定の関数はありません。
抽象クラスは実装されたメソッドを持つことができます。

抽象クラスを継承する場合、サブクラスはすべての抽象メソッドを親クラスに実装する必要があります。
これらのメソッドのアクセス制御は、親クラスと同じであるか、より緩やかなものでなければならず、親クラスよりも厳密にすることはできません。
メソッドを呼び出すメソッドも一致する必要があります。 型とパラメータの数は同じでなければなりませんが、サブクラスは親クラスに存在しないオプションのパラメータを定義できます。

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');

元のリンク