面向对象(二)

前言:续上集,继续完成面向对象的知识.....

(一) 自动加载

　　出现的原因:早期的开发过程中，程序开发人员通常会将所有的可能要使用的类文件通过include的方式，引入到当前的程序脚本中。但是这么做，会使得程序加载效率过低，拖慢程序的整体执行速度,"自动加载"技术就是：什么使用要用到这个类，就将这个类所在的类文件引入进项目中来。

　　触发执行自动加载的时机：当使用到某个类时，而当前整个程序脚本中又没有这个类的定义，就会触发PHP执行走自动加载，寻找类的定义。

　　

　　1.默认的自动加载

<?php

//默认的自动加载函数  $className保存的是使用到的类的类名
function __autoload($className){ 
    
    var_dump( $className ); echo '<hr/>';
    if( $className=='A' ){
        include './prepare/A.class.php';
    }elseif( $className=='B' ){
        include './prepare/B.class.php';
    }
}

$a1 = new A;
var_dump( $a1 ); echo '<hr/>';

$b1 = new B;
var_dump( $b1 );

　　2.自定义自动加载

<?php
//1.自定义函数

//自定义的自动加载函数
function f1($className){ 
    
    var_dump( $className ); echo '<hr/>';
    if( $className=='A' ){
        include './prepare/A.class.php';
    }elseif( $className=='B' ){
        include './prepare/B.class.php';
    }
}

//注册自动加载函数
spl_autoload_register('f1');

$a1 = new A;
var_dump( $a1 ); echo '<hr/>';

$b1 = new B;
var_dump( $b1 ); 

<?php
//2.自定义非静态方法
class Tool{

    //自定义的非静态方法f1
    public function f1($className){ 
    
        var_dump( $className ); echo '<hr/>';
        if( $className=='A' ){
            include './prepare/A.class.php';
        }elseif( $className=='B' ){
            include './prepare/B.class.php';
        }
    }
}

$obj = new Tool;

//注册自动加载
spl_autoload_register(array($obj, 'f1'));

$a1 = new A;
var_dump( $a1 ); echo '<hr/>';

$b1 = new B;
var_dump( $b1 ); 

<?php
//3.自定义静态方法
class Tool{

    //静态方法f1
    public static function f1($className){ 
    
        var_dump( $className ); echo '<hr/>';
        if( $className=='A' ){
            include './prepare/A.class.php';
        }elseif( $className=='B' ){
            include './prepare/B.class.php';
        }
    }
}

//注册自动加载
//spl_autoload_register(array('Tool', 'f1'));
spl_autoload_register('Tool::f1');//这种写法和上面的写法效果是一样的

$a1 = new A;
var_dump( $a1 ); echo '<hr/>';

$b1 = new B;
var_dump( $b1 ); 

(二)类的继承

　　概念：属于类A的成员，同时也属于类B，我们就说类B继承了类A。

//extends是关键字的语法
class 子类类名 extends 父类类名{
    子类的类成员；
}

<?php
//继承案例1
#动物类
class Animal{
    
    public $name='动物';
    public $age='生命周期';

    public function move(){ 
        echo '哈哈，我能移动！'; 
    }
}

//通过extends关键字实现类的继承
class Birds extends Animal{

    public $firther='有羽毛';
}

$b1 = new Birds;
var_dump( $b1 ); echo '<hr/>';

$b1->move();

继承中的三个概念

父类：就是被继承的那个类；

派生：派生是一个过程，通过一个已有的类，产生一个新类的过程，就叫派生；

子类：继承别的类的这个类（子类也叫派生类）；

小结:

1. 继承不是简单的将父类的成员拷贝到子类中,而是会将形成继承关系一直保持下去;

2. 如果在程序中之后基于子类创建了对象,则子类中的非静态成员和父类中的非静态成员在对象空间中将会分别开辟两个小空间放置,以保持他们之间的继承关系;

　　 3.类只能单继承，不能多继承，但是能够形成一个长串的继承链；

　　4.类只能继承父类中的非私有成员（不能使用但是可以看）；

(三) parent关键字

　　作用：parent关键字就是专门在子类中代替父类的类名的。

<?php

class Father{
    
    public $car='比亚迪';
    public static $deposit=1000;

    public static function singing($name){ 
        echo '我会唱：' . $name; 
    }
}

class C1{
    public static $var1='哈哈哈哈吼吼';
}

class Son extends Father{

    public function test(){ 
        var_dump( Father::$deposit ); echo '<br/>';
        Father::singing('两只老虎'); echo '<hr/>';
        //parent在子类中代替父类的类名
        var_dump( parent::$deposit ); echo '<br/>';
        parent::singing('让我们荡起双桨');
    }
}

$s  = new Son;
$s->test();

(四) 访问修饰符

　　引言：访问限定修饰符，顾名思义就是一种符号，专门用来限定用户访问的。

• public 表示在类的内部，类的外部和类的继承链中都能直接访问；

• protected 表示在类的内部和继承链中能被直接访问；

• private 表示只能在本类的内部被直接访问；

　　1.public 表示公有的

<?php
#案例1  测试public 在外部访问
class PublicTest{
    
    #public
    public $var1='public_var1';
    public static $var2='public_static_var2';

    public function f1(){ 
        echo 'public_function_f1'; 
    }
    public static function f2(){ 
        echo 'public_static_function_f2'; 
    }
}

#在类的外部  直接  访问被public修饰的成员
$obj = new PublicTest;
var_dump( $obj->var1 ); echo '<br/>';
var_dump( PublicTest::$var2 ); echo '<br/>';

$obj->f1(); echo '<br/>';
PublicTest::f2();

<?php

#案例2  测试public 在内部访问

class PublicTest{

#public
public $var1='public_var1';
public static $var2='public_static_var2';

public function f1(){
echo 'public_function_f1';
}
public static function f2(){
echo 'public_static_function_f2';
}

#在类的内部 直接 访问public修饰的成员
public function test(){

var_dump( $this->var1 ); echo '<br/>';
var_dump( self::$var2 ); echo '<br/>';
$this->f1(); echo '<br/>';
self::f2();
}
}

$obj = new PublicTest;
$obj->test();

<?php
#案例3 测试public 在继承访问

<?php

class PublicTest{
#public
public $var1='public_var1';
public static $var2='public_static_var2';

public function f1(){
echo 'public_function_f1';
}
public static function f2(){
echo 'public_static_function_f2';
}
}

class PublicTestSon extends PublicTest{

//在继承链中访问父类的public修饰的成员
public function son_test(){

var_dump( $this->var1 ); echo '<br/>';
var_dump( self::$var2 ); echo '<br/>';
$this->f1();echo '<br/>';
self::f2();
}
}

$obj = new PublicTestSon;
$obj->son_test();

小结:

　　这里就不贴另外两个代码了只要熟悉下面这可以了:

• public 表示在类的内部，类的外部和类的继承链中都能直接访问；

• protected 表示在类的内部和继承链中能被直接访问；

• private 表示只能在本类的内部被直接访问

(五) 重写（override）

　　概念：所谓的重写，指的就是对父类中已有方法的重新定义,发生在继承中,且是可用的才行.

<?php

#动物类
class Animal{
    
    public $name='动物';
    public $age='生命周期';

    public function move(){ 
        echo '哈哈，我能移动！'; 
    }
}


class Birds extends Animal{

    public $firther='有羽毛';

    public function move(){ 
        echo '灭嘿嘿嘿～我能飞～'; 
    }
}

class Fish extends Animal{

    public $fin='鱼鳍';

    public function move(){ 
        echo '賊哈哈哈哈～我能仰泳～'; 
    }
}

$b1 = new Birds;
$b1->move();echo '<hr/>';

$f1 = new Fish;
$f1->move();

(六)解决魔术方法被重写的问题

　　parent::方法名([形参列表]);

<?php


class Father1{
    
    public $father_name;
    public $father_age;

    public function __construct($name, $age){ 
        
        $this->mysql_acc = $name;
        $this->mysql_pwd = $age;

    }
}

class Son extends Father1{

    public $son_name;
    public $son_age;

    public function __construct($v1, $v2, $v3, $v4){ 

        //率先执行一次父类的构造方法
        parent::__construct($v1, $v2);

        $this->son_name = $v3;
        $this->son_age = $v4;
    }
}

$s1 = new Son('root', '123abc', 'mahuateng', 40);
echo '<pre>';
print_r( $s1 );