//对象遍历：
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)
{
"$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。
