php 对象 final,PHP7_OOP_对象重载以及魔术方法_对象遍历_final关键字

//对象遍历：

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。