//對象遍歷：

class MyClass{

public

$var1?=?"value 1";

public

$var2?=?"value 2";

public

$var3?=?"value 3";

protected

$protected?=?"pro var";

private?$private?=?"pri

var";

function

interateVisible()

{

echo "MyClass::interateVisible:\n";

foreach ($this as $key=>$value)

{

print

"$key => $value";

}

}

}

// $class?=?new MyClass();

// foreach ($class as $key=>$value)

// {

//?print "$key => $value";

// }

// echo "\n";

//

$class->interateVisible();//通過在類的內部來循環，使得可以循環類內部的不可見變量

//使用Iterator接口來定義對象該怎么遍歷

// class NewCla?implements?Iterator

// {

//?private $postion?=?0;

//?private $array?=?[

//?"firstelement",

//?"secondelement",

//?"lastelement"

//?];

//?public function __construct()

//?{

//?$this->postion?=?0;

//?}

//?public function current()

//?{

//?var_dump(__METHOD__);

//?return

$this->array[$this->postion];

//?}

//?public function key()

//?{

//?var_dump(__FUNCTION__);

//?return

$this->postion;

//?}

//?public function rewind()

//?{

//?var_dump(__METHOD__);

//?$this->postion?=?0;

//?}

//?public function valid()

//?{

//?var_dump(__METHOD__);

//?return

isset($this->array[$this->postion]);

//?}

//?public function next()

//?{

//?var_dump(__METHOD__);

//?++$this->postion;

//?}

// }

// $it =?new

NewCla();

// foreach ($it?as

$k=>$v)

// {

//?var_dump($k,$v);

//?echo"\n";

// }

//

// class TestIterator implements Iterator {

//

//?private $_test = array('dog', 'cat',

'pig');

//

//?private $_key = 0;

//

//?private $_step = 0;

//

//?public function rewind() {

//?echo

'第'.++$this->_step.'步：執行 '.__METHOD__.'

';

//?$this->_key = 0;

//?}

//

//?public function valid() {

//?echo

'第'.++$this->_step.'步：執行 '.__METHOD__.'

';

//?return

isset($this->_test[$this->_key]);//如果使用迭代器，必須在valid里面檢驗當前游標指向的值是否有效，并把結果返回

//?//只有返回檢驗結果，才能正常的迭代，否則沒有返回檢驗結果，將會終止迭代

//?}

//

//?public function next() {

//?echo

'第'.++$this->_step.'步：執行 '.__METHOD__.'

';

//?$this->_key++;

//?}

//

//?public function current() {

//?echo

'第'.++$this->_step.'步：執行 '.__METHOD__.'

';

//?return

$this->_test[$this->_key];//在迭代其中，需要把current獲取當前游標所指向的元素返回，在foreach中才可以

//?//獲取當權循環所返回的值

//?}

//

//?public function key() {

//?echo

'第'.++$this->_step.'步：執行 '.__METHOD__.'

';

//?return

$this->_key;//在迭代器中，需要把key獲取到

//?}

// }

// $iterator = new TestIterator();

// foreach($iterator as $key => $value){

//?echo

"輸出索引為{$key}的元素".":$value".'

';

// }

//利用內置Iterator來迭代變量如何遍歷

class NewIteratorCla?implements?Iterator

{

private?$iteratorArr?=?[];

private?$step?=?0;

private?$num?=?0;

public function

__construct($iterArr)

{

$this->iteratorArr?=?$iterArr;

}

public function

rewind(){

echo "這是第".++$this->num."步：執行

".__METHOD__."

";

//重置游標

$this->step=0;

}

public function

valid(){

echo "這是第".++$this->num."步：執行

".__METHOD__."

";

//檢驗當前索引所指向的值是否有效

return

isset($this->iteratorArr[$this->step]);

}

public function

current(){

echo "這是第".++$this->num."步：執行

".__METHOD__."

";

//返回當前游標所指向的值

return

$this->iteratorArr[$this->step];

}

public function

next(){

echo "這是第".++$this->num."步：執行

".__METHOD__."

";

//設置當前游標所在位置加1

$this->step++;

}

public function

key(){

echo "這是第".++$this->num."步：執行

".__METHOD__."

";

//

return $this->step;

}

}

// $itera?=?['dog','cat','pig'];

// $iteCla =?new

NewIteratorCla($itera);

// foreach ($iteCla?as

$k=>$v)

// {

//?echo

"索引為".$k."時，值為$v"."

";

// }

class MyCollection?implements

IteratorAggregate

{

private

$items?=?[];

private

$count?=?0;

public function

getIterator()

{

return new

NewIteratorCla($this->items);

}

public function

add($value)

{

$this->items[$this->count++]?=?$value;

}

}

// $myc?=?new MyCollection();

// $myc->add("value 1");

// $myc->add("value 2");

// $myc->add("value 3");

// foreach ($myc?as

$k=>$v)

// {

//?echo

"key/value[$k -> $v]\n\n";

// }

//魔術方法

//__construct:構造方法，在php5中定義了構造方法，在創建一個初始化一個對象的時候，可以做一些前提工作。

//在繼承的時候，如果子類中沒有定義，那么就會繼承父類的構造方法，前提是沒被定義為private，如果子類中定義了構造方法

//則不會隱式繼承，如果想要訪問父類中的構造方法，應該在子類的構造函數里使用parent::__construct來調用父類中的構造函數

//__destruct:析構方法，析構函數在一個對象的所有引用或者顯示銷毀一個對象時被調用。

//set 給一個不可訪問的類屬性設置值時被調用,get獲取一個不可訪問的類屬性時被調用 ,isset

使用isset或者empty判斷一個不可見屬性時被調用 ,unset使用unset銷毀一個屬性時被調用

//call 調用一個不可訪問的成員方法時被調用,callStatic調用一個static的不可見方法時被調用。

//__sleep:在使用serialize串行化一個對象的時候，serialize首先檢驗是否存在__sleep方法。如果存在，首先調用__sleep方法來清理對象，__sleep返回一個可以被串行化的屬性數組。

//__wakeup:在使用unserialize反串行化一個對象的時候，unserialize首先檢驗被序列化的對象是否存在__wakeup

class Connection{

protected?$link;

private?$server,$username,$password,$db;

public function

__construct($server,$username,$password,$db)

{

$this->server?=?$server;

$this->username =?$username;

$this->password =?$password;

$this->db?=?$db;

$this->connect();

}

private function

connect()

{

$this->link =?mysqli_connect($this->server,$this->username,$this->password);

mysqli_select_db($this->link,$this->db);

}

public function

__sleep()

{

return

['server','username','password','db'];

}

public function

__wakeup()

{

$this->connect();

}

}

// $dblike =?new

Connection("localhost", "root", "root", "test");

// var_dump($abc?=?serialize($dblike),unserialize($abc));

class user

{

public $name;

public $id;

public function

__construct()

{

$this->id?=?uniqid();

}

function __sleep()

{

return ['name'];

}

function

__wakeup()

{

$this->id?=?uniqid();

}

}

// $u?=?new user();

// $u->name?=?"Leo";

// $s?=?serialize($u);

// $us =?unserialize($s);

// print_r($s);

// print_r($us);

//__invoke：當在程序中，類以函數形式被調用的時候，將直接調用__invoke

class AdsCallabled

{

function

__invoke($x)

{

var_dump($x);

}

}

// $obj?=?new AdsCallabled();

// $obj(5);

// var_dump(is_callable($obj));

// call_user_func(new AdsCallabled,4);

class A

{

public $var1;

public $var2;

public static function

__set_state($an_array)

{

$obj?=?new A;

$obj->var1?=?$an_array['var1'];

$obj->var2?=?$an_array['var2'];

return $obj;

}

}

// $a?=?new A;

// $a->var1?=?5;

// $a->var2?=?'foo';

// eval_r('$b='.var_export($a,true).';');

// var_dump($b);

//__toString:在把一個對象作為字符串的時候，會自動調用該方法,如果沒有該方法，相會報錯，在__toString中不可以拋出異常

class tostrCla

{

public function

__toString()

{

return "try to echo one object is

wrong";

}

}

// $to =?new

tostrCla();

// var_dump(strlen("$to"));//31

//final關鍵字，final字段的用處在于，當類中一個方法被定義為final時，類在被繼承的時候，該方法不能被覆蓋

//當類被關鍵字final修飾時，那么該類不能被繼承

class finFunc

{

final?public function setFin()

{

echo "i am mast be extend";

}

}

class extCla?extends

finFunc

{

//?public function setFin()//報錯可以被覆蓋

//?{

//?echo "i wang to try";

//?}

}

//final類

final class?finCla

{

public function

getClass()

{

echo "asd";

}

}

// class extFin?extends

finCla//Fatal error: Class extFin may not inherit from final class

(finCla),不可以被繼承

// {

//?public function aas(){}

// }

//但可以被實例化

//?$str?=?new finCla();

//?$str->getClass();

abstract class basCla

{

abstract public function

asd();

}

class extAbs?extends

basCla

{

public function

asd()

{

}

}

// $err?=?new extAbs();

//interface：可以被繼承，但不可以被實例化，而且接口類中的所有方法的訪問控制都應該為public，這也是接口的特性

//但是接口中的所有方法，都只是以聲明的形式，并沒有真正的方法體即實際操作，在被繼承的時候都應該在子類中被定義

//abstract：被修飾為abstract的類中，不能被實例化，只能被繼承，在類里面，可以沒有抽象方法，但只要類中有一個方法被定義為

//abstract，那么該類也必須被定義為抽象類，被定義為抽象的方法，必須被子類定義，并且在被定義的時候，所有方法的訪問控制都必須

//要和原來的訪問控制相同或者更寬松。抽象類中的所有抽象方法，不可以被定義為private私有化

//final：被final修飾的方法，子類繼承是不能被定義，被final修飾的類不能被繼承，但可以被實例化，屬性不能被定義為

final，只有類和方法才能被定義為 final。

總結

以上是生活随笔為你收集整理的php 对象 final,PHP7_OOP_对象重载以及魔术方法_对象遍历_final关键字的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。