php 面向对象

最新推荐文章于 2024-04-12 00:45:00 发布

原创最新推荐文章于 2024-04-12 00:45:00 发布 · 95 阅读

CC 4.0 BY-SA版权

<?php
/**
* public 全局（所有）
* protected 受保护（本类，子类，父类）
* private 私有（本类）
* __construct()作为类的默认的构造函数（优先执行）,类似同名函数
* __destruct() 当删除一个对象或对象操作终止的时候，调用该方法。
* __get()取得当前类中封装过属性或方法转换成公有属性
* __set()取得当前类中封装过私有属性或方法重新执行或赋值
* __tostring()打印对象句柄，获得该方法的基本信息
* __call()调用一些不存在的对象方法的异常处理，使程序正常运行
* __clone克隆在内存中生成两个一样的对象或升级原对象
* __autoload()快速取得对象名称并自动载入当前页面(定义在类外边)
* final 不能被继承（类）不能被重载（方法）
* self 一般用来访问当前类中[静态成员，常量，或其他定义内容](不需实例化)----类似this（需实例化）
* static 静态属性或方法（不能出现非静态内容），独占内存（避免重复占用资源），（未被实例化使用）
* const 定义类中的常量（尽量大写，不需$），用关键字self访问。类似php外部的define（），
* 抽象类abstract：
*   1、类中至少有一个抽象方法
*   2、抽象方法前需加abstract
* 接口interface：一种成员属性全部为抽象或常量的(特殊抽象类)
*      1、类中全部为抽象方法
*      2、抽象方法前不用加abstract
*   3、接口抽象方法属性为public
*   4、成员属性必须为常量
* [抽象类|接口]:
*   1、本身都不能被实例化，必须被继承或者引用
*   2、继承或者引用后，需要把所有抽象方法重载方可使用
*/
//自动载入类页面
function __autoload($class){
include_once("{$class}.php");
}
$obj = new myPc();//自动载入myPc页面

class myPc{
function __tostring(){
return "类的信息";
}
function __call($k,$v){
var_dump("不存在的方法".$k,$v);
}
function __destruct(){
echo "释放缓存";
}
function __clone(){
echo "克隆的默认方法";
}
}
$pc = new myPc();
$cl = clone $pc;//克隆
//echo $pc;//类的信息
echo $pc->cc(1234);

//接口
interface demo{
const NAMES = "ZSC";
function f1();
function f2();
}
//普通类引用接口
class dm implements demo,demo2,demo3{

}
//抽象类引用接口
abstract class dm implements demo,demo2,demo3{

}
//先继承后接口，单继承多接口
class dm extends root implements demo,demo2,demo3{

}
//接口继承接口
interface demo extends demo2{

}
//instanceof 判断类名是否相等boolean
class A{}
$s = new A;
if($s instanceof A){
echo "\$s的类名是A";
}
//多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。
interface myusb{
function type();
function alert();
}
class zip implements myusb {
function type(){
  echo "2.0";
}
function alert(){
  echo "u盘";
}
}
class mp3 implements myusb {
function type(){
  echo "1.0";
}
function alert(){
  echo "mp3";
}
}
class pc{
function pcusb($w){
  $w->type();
  $w->alert();
}
}
$zip = new zip;
$mp3 = new mp3;
$pc = new pc;

$pc->pcusb($zip);
//多态 end

class MyPc{
public $public_var;
protected $protected_var;
private $private_var;
const NAMES = "zzzz";
function __construct($str=null){
  return $this->public_var=$this->protected_var=$this->private_var=$str;
}

function __get($starts){//外部调用私有变量
  return $this->$starts();
}

private function starts(){
  return $this->private_var."这个是私有的";
}

function __set($key,$val){//外部给私有变量赋值
  return $this->$key = $val;
}
function estarts(){
  return $this->starts();
}
static function sta(){
  echo self::NAMES;
}

}
$myPc = new MyPc("zsc");
//echo $myPc->private_var=0;
//echo $myPc->starts(); 不可用私有
//echo $myPc->estarts();
echo MyPc::NAMES;

(1)runkit_method_rename
这个函数可以动态的改变我们所调用的函数的名字。
class Test   {
function foo() {
return "foo! ";
   }
}
runkit_method_rename(
'Test', //类名
'foo',//实际调用的函数
'bar'//显示调用的函数
);
echo Test::bar();
程序将输出　
foo!

(2) runkit_method_add
//这个PHP5魔术函数可以动态的向类中添加函数
class Test   {
function foo() {
return "foo! ";
}
}
runkit_method_add(
Test, //类名
'add', //新函数名
'$num1, $num2',//传入参数
'return $num1 + $num2;',//执行的代码
RUNKIT_ACC_PUBLIC
);
// 调用
echo $e->add(12, 4);

(3)runkit_method_copy
//可以把A类中的函数拷贝到类B中并对PHP5魔术函数重命名

class Foo {
function example() {
return "foo! ";
   }
}
class Bar {
//空类
}
//执行拷贝
runkit_method_copy('Bar', 'baz', 'Foo', 'example');
//执行拷贝后的函数
echo Bar::baz();

(4) runkit_method_redefine
//动态的修改函数的返回值
//这个PHP5魔术函数可以让我们轻松的实现对类的MOCK测试！是不是很COOL呢
class Example {
    function foo() {
        return "foo! ";
    }
}
//创建一个测试对象
$e = new Example();
// 在测试对象之前输出
echo "Before: " . $e->foo();
// 修改返回值
runkit_method_redefine(
    'Example',
    'foo',
    '',
    'return "bar! ";',
    RUNKIT_ACC_PUBLIC
);
// 执行输出
echo "After: " . $e->foo();

(5)runkit_method_remove
这个PHP5魔术函数就很简单了，看名字就能看出来了，动态的从类中移除函数
class Test {
function foo() {
return "foo! ";
}
function bar() {
return "bar! ";
}
}
// 移除foo函数
runkit_method_remove(
'Test',
'foo'
);
echo implode(' ', get_class_methods('Test'));
程序输出 bar 以上所介绍的代码就是关于PHP5魔术函数的具体应用方式。

__sleep 和 __wakeup
串行化serialize可以把变量包括对象,转化成连续bytes数据. 你可以将串行化后的变量存在一个文件里或在网络上传输. 然后再反串行化还原为原来的数据. 你在反串行化类的对象之前定义的类,PHP可以成功地存储其对象的属性和方法. 有时你可能需要一个对象在反串行化后立即执行. 为了这样的目的,PHP会自动寻找__sleep和__wakeup方法.
当一个对象被串行化,PHP会调用__sleep方法(如果存在的话). 在反串行化一个对象后,PHP 会调用__wakeup方法. 这两个方法都不接受参数. __sleep方法必须返回一个数组,包含需要串行化的属性. PHP会抛弃其它属性的值. 如果没有__sleep方法,PHP将保存所有属性.
下例显示了如何用__sleep和__wakeup方法来串行化一个对象. Id属性是一个不打算保留在对象中的临时属性. __sleep方法保证在串行化的对象中不包含id属性. 当反串行化一个User对象,__wakeup方法建立id属性的新值. 这个例子被设计成自我保持. 在实际开发中,你可能发现包含资源(如图像或数据流)的对象需要这些方法

class User
{
public $name;
public $id;

function __construct()
{
//give user a unique ID 赋予一个不同的ID
$this->id = uniqid();
}

function __sleep()
{
//do not serialize this->id 不串行化id
return(array("name"));
}

function __wakeup()
{
//give user a unique ID
$this->id = uniqid();
}
}

//create object 建立一个对象
$u = new User;
$u->name = "Leon";

//serialize it 串行化注意不串行化id属性,id的值被抛弃
$s = serialize($u);

//unserialize it 反串行化 id被重新赋值
$u2 = unserialize($s);

//$u and $u2 have different IDs $u和$u2有不同的ID
print_r($u);
print_r($u2);

//__set_state and __invoke
得出以下结论,__set_state作用是用来复制一个对象,并且可以在__set_state中定义在复制对象的时候对复制得到的对象进行一些改变。和__clone不同的是__set_state可以接受参数,__set_state使用起来更加强大!虽然个人觉得这个东西不是很好用= =!
//测试代码如下:
class A {
    public static function __set_state($args) {
        $obj = new A ();
        foreach ( $args as $k => $v ) {
            $obj->$k = $v;
        }
        return $obj;
    }
}

$a = new A ();
$a->name = 'cluries';
$a->sex = 'female';
eval ( '$b = ' . var_export ( $a, true ) . ';' );
print_r ( $b );
//程序输出
object(A)#2 (2) {
["name"]=> string(7) "cluries"
["sex"]=> string(6) "female"
}

然后再说下__invoke：
手册上有个非常显眼的：Note: This feature is available since PHP 5.3.0.
方法将会在代码试图把对象当作函数来使用时候调用？有点稀奇,这个功能有什么用处呢？
然后看下提供的例子:*/

class CallableClass {
    function __invoke($x) {
        var_dump ( $x );
    }
}

$obj = new CallableClass ();
$obj ( 5 );
var_dump ( is_callable ( $obj ) );
//程序输出：
int(5)
bool(true)
//还真是把对象当函数使用…
?>