为了账号安全,请及时绑定邮箱和手机立即绑定

PHP-面向对象

难度初级
时长 2小时30分
学习人数
综合评分9.50
54人评价 查看评价
9.7 内容实用
9.8 简洁易懂
9.0 逻辑清晰
  •   在php中继承的特点是只支持单继承,即一个子类只能继承一个父类, 去获得父类中的方法。但从php5.4开始有trait概念,一个类可以通过use关键字引入多个trait的方法,用trait解决了单继承的问题。

    03:48
    看视频
  • 类型约束有int,string,array,float,bool等。但类也可以作为类型约束的类型之一,如图test(A $a)指的是$a必须是类A的对象,否则会报错。

    10:30
    看视频
  • 浅拷贝:对象赋值$b=$a,2个对象指向同一块内存地址,值发生改变会互相影响。浅拷贝比较省内存。

    深拷贝:用clone关键字,会产生一块新的内存存储对象。clone后相当于有两个值相同的不同的对象。若clone的原对象里有对象属性如$a->obj,由于对象复制默认是浅拷贝,则要用到__clone魔术方法定义对象属性为深拷贝。这样$a->obj->sex才不受$b->obj->sex影响。


    07:32
    看视频
  • self::who()和static::who()的区别在于self指的本类,即父类A,而static会根据代码实际情况判断指的是B类。

    04:06
    看视频
  • static关键字

    当属性和方法加上static关键字后,属性和方法就是类的,可以直接通过类名进行调用,无需实例化。么 当给一个属性加上static关键字,那么这个属性变成了类属性,不需要实例化类(获得对象)就可以直接用类名进行调用。如Person::$foot;方法同理如Person::work();

    13:54
    看视频
  • 命名空间+类名 = 类文件路径.

    用spl_autoload_register()替换字符串后自动加载类文件

    11:55
    看视频

  • 命名空间和全局空间

        1. 在全局空间中引用命名空间的类,用use关键字引入命名空间的类,as起别名。若引入函数则为use function venter\session\iLikeImooc;引入常量则为use const venter\IMOOC;

        2.在命名空间中引用全局空间的类,若为namespace venter,即命名空间为venter,如new Test();类默认为venter\Test();找不到会报错,在类前加反斜杠new \Test();则为找到全局空间的Test类。函数和常量会先在命名空间中找,找不到会去全局找。

    14:15
    看视频
  • 外部想要对私有属性进行读取和修改。


    <?php
    class Test
    {
        private $abc = '';
        public function setAbc($val)    //修改
        {
             $this->abc = $val;        
         }
         
         public function getAbc()     //读取
         {
              return $this->abc;
          }
    }
    
    $test = new Test();
    $test = setAbc('hahaha');    //hahaha赋给参数$val
    var_dump($test->getAbc());     //打印出:string(6)"hahaha"


    若有多个私有属性要被外部访问,上述就不行了,所以有了两个魔术方法:__set 和 __get 。如:

    <?php
    class Test
    {
        private $abc = '';
        private $cba = '';
        public function __set($var,$val)    //修改。 __set(属性名,属性值)
        {
             $this->$var = $val;        
         }
         
         public function __get($var)     //读取。  __get(属性名)
         {
              return $this->$var;
          }
    }
    
    $test = new Test();
    $test->abc = 'hahaha';    //当给私有属性赋值时,会默认自动地调用__set方法,如果类里没有__set方法,就会报错
    var_dump($test->abc);     //打印出:string(6)"hahaha"


    魔术方法 __isset 用于检测私有属性是否存在。

    <?php
    class Test
    {
        private $abc = 'abc';
        
        public function __isset($var)
        {
            return isset($this->$var)?true:false;
         }
    }
    $test = new Test();
    var_dump(isset($test->abc));    //打印出:bool(true)


    魔术方法__unset 删除

    <?php
    class Test
    {
        private $abc = 'aaa';
        
        public function __unset($var)
        {
            unset($this->$var);
         }
    }
    
    $test = new Test();
    unset($test->abc);


    为避免要调用的方法不存在,用魔术方法 __call  当被调用的方法不存在时,__call 会自动被调用。如:

    <?php
    class Test
    {
        public function __call($func,$arguments)     //__call(方法名,参数)
        {
            echo($func . "<br/>");
            print_r($arguments);
         }
    }
    
    $test = new Test();
    $test->go(1,'ok');     //结果为:go
                            //       Array( [0] =>1 [1] => ok )



    当静态方法不存在时,魔术方法__callStatic 会被自动调用。如:

    <?php
    class Test
    {
        public static function __callStatic($method,$arg)    //要加static关键字   __callStatic(方法名,参数)
        {
            echo($method . "<br/>");
            print_r($arg);
         }
    }
    
    Test::go(1,'ok');      //结果为:go
                            //       Array( [0] =>1 [1] => ok )


    当对象以函数的方式被调用时,魔术方法__invoke会自动被调用。

    <?php
    class Test
    {
         public function __invoke($arg)
         {
             var_dump($arg);    
          }
    }
    
    $test = new Test();
    $test('go....');  //这就是对象以函数的方式被调用   结果为:string(6)"go...."


    当对象被打印时,魔术方法__toString() 会自动被调用。

    <?php
    class Test
    {
         public function __toString()
         {
             return "hello.....";    
          }
    }
    
    $test = new Test();
    echo($test);     //结果为:hello......


  • <?php
    class A {    
         public static function who()   
         {        
             echo "AAA";    
          }    
          public static function test()    
          {        
                static::who();      //之后的结果为BBB,若用self::who(),则结果为AAA    
           }                        //因为子类B调用父类的test方法,又调用who方法,子类父类都有who方法,用static是调用子类的who方法,用self是调用父类(也就是self所在类的)who方法
    }
    
    //子类
    class B extends A {    
        public static function who()    
        {        
             echo "BBB";    
         }
    }
    B::test();   //因为这里是B,所以父类A和子类B都有who方法我们也要调用子类B的who方法,


  • imooc.php:

    <?php
    class Imooc
    {
        public function nice()
        {
            echo "imooc nice";
         }
    }


    main.php:

    <?php
    function __autoload($className)    //__autoload()是内置函数,实现类的自动加载
    {
         require $className . ".php";    
     }
     $imooc = new Imooc();
     var_dump($imooc);   //结果为:object(Imooc)#1(0){}
     
     
     //__autoload()函数将在以后PHP版本里不再使用,所以用spl_autoload_register()函数
    <?php
    spl_autoload_register(function($className){
         require $className . ".php";
    });
    $imooc = new Imooc();
    var_dump($imooc);      //结果为:object(Imooc)#1(0){}
    
    //还可以:
     <?php
     function test($className){
          require $className . ".php";
    }
    spl_autoload_register('test');
    
    $imooc = new Imooc();
    var_dump($imooc);      //结果为:object(Imooc)#1(0){}
    
    //若在类里:
    <?php
    class Momo
    {
        function haha($className)
        {
             require $className . ".php";
         }
    }
    spl_autoload_register([new Momo,'haha']);
    
    $imooc = new Imooc();
    var_dump($imooc);     //结果为:object(Imooc)#1(0){}



    现文件级别如下:

    <!--此处有图片-->

    main.php:

    <?php
    spl_autoload_register(function($className){
         include str_replace("\\","/",$className .".php");    //将\转换为/, (两个\\因为其中一个\是转义字符)将在网页上显示models/Imooc,为了显示出路径
    });
    
    $imooc = new models\Imooc();
    var_dump($imooc);     //结果为:object(models/Imooc)#2(0){}



    Static关键字:

    当给属性加上Static关键字,该属性就是类的属性,而不是对象的,不用实例化这个类,就可以通过类名调用。方法也是可以。如:

    <?php
    class Person
    {
        public static $hand = "手";
        public static $foot = "脚";
        
        public static function work()
        {
             return "单纯的工作";
         }
    }
    
    echo(Person::$foot);
    echo(Person::work());
    <?php
    class Person
    {
        public $a = 1;
        
        public static function work()
        {
             echo ($this->$a);     //有static关键字时不能这样,会报错。$this代表的是对象,self是代表的是类
             return "单纯的工作";
         }
    }
    
    echo(Person::work());    //会报错
    
    
    <?php
    class Person
    {
        public static $hand = "手";
        public static $foot = "脚";
        
        public static function work()
        {
             echo(self::$hand);      //因为是类的方法和属性,不是对象的,所以用self
             return "单纯的工作";
         }
    }
    echo(Person::work());   //结果为:手单纯的工作
    
    
    //子类
    class Imooc extends Person
    {
        public function play()
        {
            parent::work();     //parent代表类
         }
    }
    $imooc = new Imooc();
    echo($imooc->play());    //结果为:手单纯的工作



  • 两个类的类名相同,会出现错误。   所以引入了命名空间。


    <!--此处有图片-->


    <!--此处有图片--> 

    和文件中的目录一样,同一目录不存在相同命名的文件,而不同目录存在相同命名的文件。 命名空间借鉴了这种方法。


    1. php:

    <?php
    namespace venter;   //用namespace关键字,Imooc类和iLikeImooc()函数和IMOOC常量就在venter命名空间下
    
    class Imooc
    {
     }
    
    function iLikeImooc(){
        echo "i Like imooc";
    }
    
    //曾经用define()定义一个常量,这个不受命名空间影响,所以用const定义常量
    const IMOOC = 'nice';

    2.php:

    <?php
    namespace venter\session;   //用\表示session是venter下一级,
    
    class Imooc
    {
     }

    main.php:

    <?php
    include '1.php';
    include '2.php';
    
    var_dump(new venter\Imooc());
    var_dump(new venter\session\Imooc());  //两个同名类就都可打印了
    
    venter\iLikeImooc();    //两个同名函数就可调用了
    
    echo(venter\IMOOC);    //同名常量都可打印出来了


    还可以这样:

    main.php:

    <?php
    include '1.php';
    include '2.php';
    
    use venter\session\Imooc;
    var_dump(new Imooc());    //就不需要这样一大串var_dump(new venter\session\Imooc()); 
    use venter\Imooc as Imooc2;     //另一同名类用as取名为Imooc2
    var_dump(new Imooc2()); 
    
    use function venter\iLikeImooc;    //函数,use后需要有function ,能加as命名
    iLikeImooc();
    
    use const venter\IMOOC;   //常量,use后要有const
    var_dump(IMOOC);


    <!--此处有图片-->

    当没有使用namespace来指定当前脚本的命名空间时,则当前脚本存在于全局命名空间。命名空间分两个,一个是有被指定,一个没有指定。


    3.php:

    <?php
    class Test1
    {
    }
    
    function Text2()
    {
    }
    
    const TEST3 = 'test3';

    index.php:

    <?php
    namespace index;
    include '3.php';
    
    var_dump(new \Text1());    //在此脚本文件有命名空间下,会找此命名空间的类,
                    //若是var_dump(new Text1())因为Text1是3.php是全局空间的类,就会报错,找不到类。所以Text1前加\
    
    Test2();  //函数和常量在此命名空间下若没有,会自动在全局空间3.php里找,而类不自动去全局空间找,所以要加\
    echo(TEST3);


  • 被继承的类叫父类。子类继承父类的属性和方法。通过子类扩展了父类的功能,是之前所学的扩展性。

    <?php
    class Dad
    {
        public function Kungfu()
        {
            echo "降龙十八掌";
         }
    }
    
    class Boy extends Dad     //使用 extends 关键字使子类继承父类
    {
     }
     
    $boy = new Boy();
    $boy->Kungfu();    //结果为:降龙十八掌   (子类继承父类的属性和方法)


    当父类的方法是私有的(private),子类不能调用,只有父类本身类的内部能用。

    当父类的方法是受保护的(protected),只能被父类自己和继承的子类调用,其他类和外部不能调用。


    方法名相同时,子类的方法覆盖父类的方法:

    <?php
    class Dad
    {
        public function Kungfu()
        {
            echo "降龙十八掌";
         }
    }
    
    class Boy extends Dad
    {
         public function Kungfu()  //方法名相同时,子类的方法覆盖父类的方法:
         {
             echo "凌波微步无影掌";
          }    
     }
     
    $boy = new Boy();
    $boy->Kungfu();    //结果为:凌波微步无影掌


    当子类没有构造方法时,会自动调用父类的构造方法。

    当子类有自己的构造方法时,就调用自己的构造方法,而不会调用父类的构造方法。若既想调用父类的构造方法也有子类的,用 parent 关键字。如:

    <?php
    class Dad
    {
        public function __construct()
        {
            echo "dad dad...";
         }
         public function Kungfu()
         {
             echo "降龙十八掌";
          }
    }
    
    class Boy extends Dad
    {
        public function __construct()
        {
            parent::__construct();   //若既想调用父类的构造方法也有子类的,用 parent 关键字。
            echo "boy boy..";
         }
     }
     
    $boy = new Boy();
    $boy->Kungfu();    //结果为:dad dad...boy boy...降龙十八掌


    父类不想被子类继承,用 final 关键字,如:

    final class Dad

      

    父类的某个方法不想被子类继承,用 final 关键字,如:

    final public function Kongfu()


  • 在实例化一个对象的时候,通常需要初始化。 对象被销毁的时候,需要有回收。所以就用到了类里面的两个内置的方法:构造方法和析构方法。

    构造方法:

    <?php
    class Computer{
        public function __construct()   //内置的构造方法,不用调用直接就会执行
        {
            echo "cpu就绪。。";
            echo "主板就绪。。";
            echo "内存就绪。。";
         }
         public function game()
         {
             echo "---玩游戏---";
          }
    }
    $computer = new Computer();
    $computer->game();  //结果为:cpu就绪。。主板就绪。。内存就绪。。---玩游戏---
    <?php
    class Computer{
        public function __construct($high = 0)   
        {
            if($high){
                echo "高配的cpu就绪。。";
                echo "高配的主板就绪。。";
                echo "高配的内存就绪。。";
             }else{
                echo "cpu就绪。。";
                echo "主板就绪。。";
                echo "内存就绪。。";
             }
         }
         public function game()
         {
             echo "---玩游戏---";
          }
    }
    $computer = new Computer(1);   // 1这个参数就是构造方法的参数
    $computer->game();  //结果为:高配的cpu就绪。。高配的主板就绪。。高配的内存就绪。。---玩游戏---

    析构方法:

    <?php
    class Computer{
        public function game()
        {
            echo "---玩游戏---";
         }
         public function __destruct()    //是析构方法,直接可执行
         {  
              echo "关闭电源。。。";
          }
    }
    $computer = new Computer();
    $computer->game();   //结果为:---玩游戏---关闭电源。。。
    //还可以这样 手动释放对象变量
    unset($computer);
    echo "good job";    //结果为:---玩游戏---关闭电源。。。good job


    类常量:

    <?php
    class Computer
    {
        const YES = ture;     //const关键字定义类常量,类常量一般是大写字母和下划线组成
        const NO = false;
        const ONE = 1;
        
        const TWO = self::ONE + 1;    //在类里用self调用类里的常量
        const THREE = self::TWO + 1;
    }
    var_dump(Computer::THREE);  //在类外面可直接调用类里的常量,结果为:int(3)


  • 调用静态方法self:: 与static::的区别

    selft代表自身;static可以实现后期绑定

  • 命名空间

    例如:namespace venter;

             namespace venter\session

    调用:命名空间(venter)\ 成员(Imooc())

    将类,函数,常量导入命名空间

    例如:

        use venter\session\Imooc();

        use venter\Imooc as Imooc2;

        use function venter\iLIkeImooc;

        use const venter\Imooc;

    命名空间需要调用全局空间定义的类需要添加“\”;而方法或者常量不需要,因为方法或者常量发现在当前命名空间没找到的话,会去全局命名空间找




  • 子类继承父类,如果子类没有构造方法,实例化子类的时候会调用父类的构造方法。如果子类中有构造方法,会调用自身子类的构造方法。如果子类中也想调用父类的构造方法,可以用parent调用

    组合和继承?

  • 构造函数必须是public,否则不能创建对象。但是如果设置为private,就可以实现单例模式

  • 对象是类的实例,先有类,才有对象。就像配置单和电脑的关系。

    类是一个代码模板         <!--此处有图片-->

    //定义一个类
    <?php           //类名以字母或下划线开头,后面可跟字母、数字、下划线。
    class Computer {      //类名一般开头的字母大写,为了清晰。当然也可以用小写。
    }
    $computer = new Computer();  //这个对象赋给了这个变量,这个对象叫做Computer类的一个实例。
    var_dump($computer);   //打印出:object(Computer)#1(0){}

    <!--此处有图片-->                  <!--此处有图片-->

    <?php
    class Computer {     
        public $cpu = 'amd 5000';     //属性     
        public $mainboard = '华硕9000x';  //属性     
        private $hd = 1024;         //属性  
                
        public function game($gameName='')    //方法     
        {                
           echo $this->hd;    //要在类里面调用属性,就用this 可以理解为这个类的一个实例(对象)     
         }                  //打印出:1024     
         public function job($work='写代码')   //方法     
         {           
               echo ($this->game());         
          }
     }
     $computer = new Computer();
     var_dump($computer);    //打印出所有的属性:object(Computer)#1 (3) { ["cpu"]=> string(8) "amd 5000"["mainboard"]=> string(11) "华硕9000x" ["hd":"Computer" :private]=>int(1024)}
     var_dump($computer->cpu);   //调用属性 打印出:string(8)"amd 5000"
     var_dump($computer->hd);  //是私有的,不能给外部对象调用  打印出错  ,只能在类的内部使用。
     ?>
     
     <?php
     class Computer {
        public $cpu = 'amd 5000';      //属性  
        public $mainboard = '华硕9000x';  //属性     
        private $hd = 512;         //属性          
        public function game($gameName='')    //方法     
        {                
            if($this->getHdSize() < 1024){      
               echo "硬盘太小玩不了游戏";  
               return false;          
             }             
             return true;        
          }              
          public function job($work='写代码')   //方法     
          {      
              echo ($this->game());  //整个的结果就是打印出:硬盘太小玩不了游戏     
           }     
           public function getHdSize()       //方法     
           {        
                return $this->hd;   //获取硬盘大小     
            }
    }
    $computer = new Computer();


  • <!--此处有图片-->

    面向对象编程 可使项目模块化

    重用性:设计的每一个模块都可在项目中重复使用

    灵活性:每一个模块都可以很轻松地被替换

    扩展性:在现有的模块上添加新功能

        面向对象:项目由一个个对象组建而成,每个对象都是独立的,他们各司其职,最后像搭积木一样,将各种组合起来,就实现了一个项目。

  • 类 的复用可直接用:use 类名

    02:30
    看视频
  • 对象复制是浅拷贝,会改变对象值,前面加clone,这不会改变原来值。

    04:24
    看视频
  • class A {
        public static function who()
        {
            echo "A类的who方法";
        }
        public static function test()
        {
             self::who();//输出A类的who方法
             static::who();//后期绑定输出B类的who方法    }    
    }
    class B extends A {
        public static function who()
        {
            echo "B类的who方法";
        }
    }

    04:45
    看视频
  • $this在当前方法使用

    self指向当前类

    parent指向父类

  • <?php

    class Person
    {
        public ststic $hand = "手";
        public ststic function work()
        {
            return "工作";
         }
    }

    echo (Person::$hand);
    echo (Person::$work());

    //当属性或方法定义为static后,输出时就不需要实例化类了,直接调用


    13:55
    看视频
  • 1.

    spl_autoload_register( function( $className ){

        require $className . '.php';

    } )

    2.

    function autoload( $className ){

        require $className . '.php';

    }

    spl_autoload_register( 'autoload' )

    3.方法是在类里面

    class Momo{

        function autoload( $className ){

             require $className . '.php';

        }

    }

    spl_autoload_register( [new Momo, 'autoload' ] )// 第一个参数实例,第二个参数是类的方法

    $imooc = new Imooc();
    var_dump(#imooc);

    06:31
    看视频
  • 命名空间一般对类起作用,方法会自动寻找类名。

    16:33
    看视频
首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
学习该课程需要熟悉PHP语法基础,了解PHP的基本使用
老师告诉你能学到什么?
1 对象的基本概念 2 什么是面向对象思想 3 面向对象的特性和规则 4 如何使用面向对象

微信扫码,参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!