php 面向对象

最新推荐文章于 2024-06-26 12:39:39 发布
最新推荐文章于 2024-06-26 12:39:39 发布
阅读量579 收藏
点赞数
分类专栏： PHP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010861514/article/details/39910383
版权 
<?php
    header("content-type:text/html;charset=utf-8");
   
 
        对象：客观存在的任何一个物体
        类：  对对象的一个描述
        先有类  然后  通过类 实例化对象
 
        面向过程的编程：基于步骤
        面向对象的编程：基于对象
 
        三大优势：重用性   扩展性   灵活性
 
        三大特性：封装   继承   多态
 
//    关键字与方法      //
 
    //关键字
    /class new          public protected private                        static      final       instanceof          const       extends         clone
      final                   //可以修饰类和方法          被修饰的方法不能被重写   被修饰的类不能被继承
  
      instanceof         //可以认为是一个运算符   判断左边的对象是不是右边的类的实例化
 
      static                 //可以修饰属性和方法        访问方式使用范围操作符，不再通过对象访问
                                //类名::$静态属性名              类名::静态方法()
        self            // self是指向类本身，也就是self是不指向任何已经实例化的对象，一般self使用来指向类中的静态变量。     
 
        extends            // 类的继承
                                //class A{}
                                //class B extends A{}       类B继承了A
        interface   implements          //接口
        abstract        抽象类
 
    // 魔术方法  （自动调用）
            __construct             //实类化类的时候自动执行
            __destruct               //实类化类的结束时候最后一个执行的程序
 
            __set($key,$val)     protected private  //没有权限操作的时候调用此方法
            __get($key)             protected private  //没有权限操作的时候调用此方法
            __isset($key)
            __unset($val)
 
            __sleep            serialize    串行化    将对象转化为字符串
            __wakeup        unerialize      饭串行化    将已经转化为对象的字符串转化为对象
 
            //注：只能调用方法
            __call （$a（方法名）,$b（数组））               //调用一个不存在的       （方法 ）     时自动调用
            __callStatic （$a（方法名）,$b（数组））       //调用一个不存在的   （静态方法）  时自动调用
 
            
            __toString （）         //返回值必须是一个字符串 用于一个类被当成字符串时应怎样回应
 
            __clone （）        clone    //被克隆的与原来的对象是同一个对象
 
            __autoload （待加载的类$class）     //实例化对象时自动加载        （主要是加载未定义的类）
 
 
实例：
 __construct
 __destruct         
构造方法 __construct与析构方法 __destruct 的实例；
//先进后出,后进先出。类似于瓶子放东西的道理。
 class test{
    public function __construct($name){
        $this->name=$name;
        echo "{$this->name}被构造。。。<br>";
    }
    public function __destruct(){
        echo "{$this->name}被析构。。。<br>";
    }
}
 
$t1 = new test("A");
$t2 = new test("B");
$t3 = new test('C');
$t4 = new test('D');
执行结果：
                A被构造。。。
                B被构造。。。
                C被构造。。。
                D被构造。。。
                D被析构。。。
                C被析构。。。
                B被析构。。。
                A被析构。。。
 
class A{
    public function __construct(){
        echo "class A....";
    }
}
class B extends A{
    public function __construct(){
        parent::__construct();
        echo "class B ....";
    }
}
$b = new B;
结果：class A....class B ....
-----------------------------------------------------------------------------------------
__set（$key,$val）  protected private  //没有权限操作的时候调用此方法,键值操作
__get（$key）         protected private  //没有权限操作的时候调用此方法，键操作
 
 
class base{
    protected $age = 18;
    private $name = '张三';
 
    public function __set($key,$val){   //参数：键和值
        $this->$key = $val;             //键的赋值
        return '设置'.$key.'的值是'.$val;
    }
 
    public function __get($key){    //参数：键
        return '获取的键是'.$key.'得到的值是'.$this->$key;
    }
}
 
$base = new base;
$base->age = 20;   //__set($key,$val)的键值设置
echo $base->age;
 
echo '<br>';
 
echo $base->name;       //__get($key),值得获取
---------------------------------------------------------------------------------------------
__isset（$key,$val）          isset
__unset（$val）
__isset( $property ) 当在一个未定义的属性上调用isset()函数时调用此方法
__unset( $property ) 当在一个未定义的属性上调用unset()函数时调用此方法
与__get方法和__set方法相同，这里的没有声明包括当使用对象调用时，访问控制为proteced,private的属性（即没有权限访问的属性）
class A
{
    public $name = 'aaaaaaaaaaaaa';
    protected $age = 18;
    private = 'B';
 
    public function __isset($key){
        return isset($this->$key);
    }
}
$a = new A;
if(isset($a->aaa)){
    echo 'Y';
}else{
    echo 'N';
}
---------------------------------------------------------------------------------------
__sleep             serialize        串行化        将对象转化为字符串
__wakeup        unerialize      反串行化     将已经转化为对象的字符串转化为对象
            class B
            {
                public $name = 'xxxxxxx';
                public $age = 18;
                public $sex = 'aaaaaaaaa';
 
                public function __sleep(){
                    return array('sex','age');          //反回一个数组，数组的元素（值）就是允许被串行化的属性
                }
 
                public function __wakeup(){
                    echo '<br>aaaaaaaa<br>';
                }
            }
 
            $b = new B;
 
            $str = serialize($b);
            echo $str;
 
            $obj = unserialize($str);
            var_dump($obj);
 
--------------------------------------------------------------------------------
__call （$a（方法名）,$b（数组））               //调用一个不存在的       （方法 ）     时自动调用
__callStatic （$a（方法名）,$b（数组））       //调用一个不存在的   （静态方法）  时自动调用
//注：只能调用方法
 
    class A
    {
        public function __call($a,$b){
            echo '调用不存在的    方法      是自动调用';
        }
    }
 
    class B
    {
        public static function __callStatic($a,$b){
            echo '动用不存在的        静态方法        是自动调用';
        }
    }
 
    $a = new A;
    $a->say('属性名','数组');        //不存在的      方法      会自动调用  __call  方法
    $a->say();                               //可以没有参数
 
    B::say('属性名','数组');          //不存在的      静态方法      会自动调用  __callStatic  方法
    B::say();                                //可以没有参数
--------------------------------------------------------------------------------
__toString      //用于一个类被当成字符串时应怎样回应
    class A
    {
        public function __toString(){
            return '必须返回一个字符串';         //返回值必须是一个字符串
        }
    }
 
    $a = new A;
    echo $a;
 
--------------------------------------------------------------------------------
__clone     clone
 
                class A
                {
                    public function __clone(){
                        echo '__clone克隆!!!!!!!<br>';
                    }
                }
 
                $a = new A;
                $b = clone $a;              //需要使用  clone   关键字
 
                if($a == $b){     //不能使用===判断，因为是两个对象，可以使用instanceof来判断
                    echo '$a,$b两个是同一个对象';       //被克隆的与原来的对象是同一个对象
                }else{
                    echo '$a,$b两个不是同一个对象';
                }
--------------------------------------------------------------------------------
__autoload （待自动加载的类）     //实例化对象时自动加载（主要是加载类）   
单独写出来不在类中实现。
//__autoload 不是写在类中，而是写在类的外面
function __autoload($classname){        //$classname 必须参数，待加载的类名。
    $classpath = './'.$classname.'.class.php';  //加载类的文件路径
    if(file_exists($classpath)){
        include_once("$classpath");          //在有继承的情况下之加载一次。
    }else{
        echo '不存在';
    }
}
$a = new user;      //当被实例化时自动加载的类。
 
user.class.php     类文件
class user{
    public function __construct(){
        echo '我是自动加载的类';
    }
}
/   范围操作符       
 
            静态访问符    ::             成员操作符    ->                 parent  父类                  self     自己            $this   当前对象
 
            $this      对象    当前对象       使用的时候只能在类里面的方法里面
            parent     类      父类
            self       类      当前类
 
范围操作符：
            静态方法   A::show();
            静态属性   A::$属性名
            常量          A::常量名
 
 
class A
{
    public $name;
    public $age;
    public $sex;
 
    public function __construct($name,$age,$sex){
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
}
 
class B extends A{
    public $size;
 
    public function __donstruct($name,$age,$sex,$size){
        parent::__construct($name,$age,$sex);  
       //或者  A::__construct($name,$age,$sex);  
        $this->size = $size;
    }
}
 
$b = new B('name','age','sex','size');
var_dump($b);
 
---------------------------------------------------------------------------------------
//static 静态方法与属性的访问不是通过对象访问，而是通过操作符 ::
//作用：   无论实例化了多少个对象，static定义的属性和方法只有一个。
class A{
    public static $name = '我的名字';
    public static function one(){
        // echo A::$name;    这两个输出是相同的意思，调用自己。
        echo self::$name;   //  操作符是 ::    
    }
}
// 可以不用实例化
A::one();           //访问静态方法的访问中间的操作符  ::
echo A::$name;      //访问静态属性。
----------------------------------------------
 final关键字，修饰方法和类
//final只能修饰的类和方法
//被修饰的类不能被继承，被修饰的方法不能重写。
//final 不能修饰属性
class A{   
     // final $name;     final 关键字不能修饰属性
     final public function one(){       //final修饰的方法
        echo 'aaaaaaaaaaaaaaaaaa';
    }
}
 
final class B{} //final要写在 class 的前面
 
-------------------------------------------------------------------------------------------------
/*
        define 定义常量，可以使用表达式，不能写在类里面
        const  定义常量，不能使用表达式，可以写在类里面
 
        类里面常量的访问方式，和静态一致，使用范围操作符来访问  如：  A::USER;
*/
//     面向对象的封装：///
             
                                public           protected           private
        外面                     Yes                  NO                  NO
        相关的类              Yes                  Yes                  NO
        自己                     Yes                  Yes                  Yes
 
        yes 支持    no 不支持
///      面向对象的继承    /
extends 继承
/*        
            描述：
                    php的继承只能是单继承（只能继承一个类）   但是可以被多个类继承
                    php的继承可以是多层继承    C继承B    B继承A    那么C里面就有了ABC三个类里面的所有东西
 
            属性的继承：
                   （可见属性 public protected ） 在子类中出现同名的属性，会被重写
                    （不可见属性 private） 在子类中出现同名的属性，会产生一个新的属性，互不影响
 
            方法的继承：
                    （可见属性 public protected ） 在子类中出现同名的方法，会被重写
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
	
                    （不可见属性 private） 在子类中出现同名的方法，会产生一个新的方法，互不影响
                    使用父类中的东西，可以使用范围操作符  parent::父类方法
*/
class A{
    public $name = '属性';
    public function one(){
        echo 'oneoneonoenoneoneone';
    }
}
class B extends A{
    public function one(){
        parent::one();  //重写的父类方法，
        echo '自己外加的';
    }
}
$b = new B();
$b->one();
///    单态设计模式：（最终只能得到一个对象）   
        
class A{
    public static $link = null;
 
    public function __construct(){
        echo '链接数据库';
    }
    public static function getconnect(){
        if(is_null(self::$link)){
            return self::$link = new A;
        }else{
            return self::$link;
        }
    }
}
$a = A::getconnect();
echo '<br>';
$b =  A::getconnect();
if($a === $b){
    echo 'Y';
}else{
    echo 'N';
}
 
结果：  //证明这是同一个对象。
链接数据库
Y
   多态设计模式：（不同对象通过同一个类产生不同结果） 
 
    class A{
    public function aa($obj){
        $obj->eat();
        echo '<br>';
        $obj->say();
    }
}
 
interface B{
    public function eat();
    public function say();
}
 
class Ba implements B{
    public function eat(){
        echo 'BaBaBaBaBaBaeateateateateateateat';
    }
    public function say(){
        echo 'BaBaBaBaBaBasaysaysaysaysaysaysaysaysaysaysaysaysay';
    }
}
 
class Bb implements B{
    public function eat(){
        echo 'BbBbBbBbBbBbeateateateateateateateateateat';
    }
 
    public function say(){
        echo 'BbBbBbBbBbBbsaysaysaysaysaysaysaysayssaysaysaysay';
    }
}
 
$a = new A;
$Ba = new Ba;
$Bb = new Bb;
 
$a->aa($Ba);
echo '<hr>';
$a->aa($Bb);
 
 
 
     抽象类       /
 
 abstract    抽象类 
 作用：抽象类不实现具体方法，具体方法由子类完成。
//定义抽象类 abstract
abstract class A{
    //abstract 定义抽象类的方法，这里没有花括号。子类必须实现这个抽象方法。
    abstract public function say();
 
    //抽象类可以有参数
    abstract public function eat($argument);
    //在抽象类中可以定义普通的方法。
     
    public function run(){
        echo '这是run方法';
    }
}
class B extends A{
    //子类必须实现父类的抽象方法，否则是致命的错误。
    public function say(){
        echo '这是say方法,实现了抽象方法';
    }
    public function eat($argument){
        echo '抽象类可以有参数 ，输出参数：'.$argument;
    }
}
$b =new B;
$b->say();
echo '<br>';
$b->eat('apple');
echo '<br>';
$b->run();
 
     接口       /
 
// interface 接口 implements 实现接口    是单继承 ，多实现。作用：定义规范。
 
interface  A{   //接口 没有 class 关键字。
    const AA = '接口可以有常量';       //接口中可以有常量，但是没有变量
    public function atest();    //接口方法没有修饰词，不能有（花括号）方法体。
}
interface B{
    public function btest();
}
interface C{
    public function ctest($argument);   //接口方法可以有参数。
}
//接口可以多实现，单继承
class D implements A,B,C{
    public function atest(){}       //每个接口的方法都必须实现。
    public function btest(){}
    public function ctest($argument){
        echo '这是ctest方法';
    }
}
echo A::AA;     //常量的访问。
echo '<br>';
$d = new D;
$d->ctest('参数');
 
 
//接口可以单继承，多实现。
class E{
    public function etest(){}
}
class F extends E implements A,B,C{ //extends 与 implements 顺序不能写反
    public function atest(){}
    public function btest(){}
    public function ctest($argument){}
}


水月情缘雪飞飞
关注
专栏目录
shell条件嵌套（if条件语句）
weixin_30512043的博客
04-14 1631
【注意1】：和Java、PHP等语言不一样，sh的流程控制不可为空，如： 代码如下: <?php if (isset($_GET["q"])) { search(q); } else { //do nothing } ?> 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样： ...
深入PHP面向对象模式与实践第2版
04-08
《深入PHP面向对象模式与实践第2版》是一本专注于PHP面向对象编程的书籍，它不仅涉及到面向对象编程的基础知识，还深入讲解了面向对象设计模式以及如何在实际项目中应用这些模式。该书是对PHP开发者掌握面向对象技术...
解析PHP面向对象的三大特征
weixin_30951231的博客
06-10 100
class BenHang extends Card{ /*构造函数与及构造的继承*/ function __construct($cardno,$pwd, $name,$money){ parent::__construct($cardno,$pwd, $name,$money); } function ta...
$this->$key
webnoties的专栏
12-09 1267
class CI_Pagination { var $base_url = ''; // The page we are linking to var $prefix = ''; // A custom prefix added to the path. var $suffix = ''; // A custom suffix added to the path. /** * C
php 魔术方法学习笔记
weixin_34265814的博客
03-06 77
__get() __set() __isset() __unset __call __callstatic __call是调用不可见（不存在或者没权限）的方法时，自动调用。 $lisi->say(1,2,3) 对象中并不存在say 方法 __call("say",array(1,2,3))运行 __get()用来获取私有成员的属性值，有一个参数，参数传入你要获...
php面向对象
weixin_44576725的博客
04-14 2010
面向对象 引入：计算机编程在历史的发展长河中，经历了多次版本变革，变化的轨迹是伴随着硬件的发展和人们对于计算机的认知以及需求。 机器语言：即开发者（科学家）使用 0 和 1 组成命令，然后在特定计算机上执行 优点：执行效率高 缺点：开发难度大、移植性差、开发成本高 汇编语言：开发者使用简洁英文字母和符号组成，让计算机读取后根据符号进行加工执行 优点：指令简单明了、推广性高 缺点：移植性差、功能简单 高级计算机语言：开发者使用类似自然语言的符号组成，高级语言根据编程思想分为
PHP面向对象
df1755的博客
06-08 1168
PHP面向对象基本概念 1.面向对象的基本概念 1.面向对象编程（OOP） 面向对象分析（Object Oriented Analysis,OOA） 面向对象设计（Object Oriented Design,OOD） 面向对象编程（Object Oriented Programming） 2.类 概念 类是属性和方法的集合.是面向对象编程最核心的东西。也是它的基础。所以通过类呢，我们可以将一些零散的用来去实现某一个功能的代码进行一些管理。 3.对象 概念 对象呢，是类进行实例化之后的一个
PHP面向对象概念
无痕之意的博客
09-12 3163
一、面向对象的概念 1、面向对象实现了软件工程的三个目标：重用性、灵活性和扩展性 2、使其编程的代码更简洁，更易于维护，并且具有更强的可重用性 3、面向对象的特点: 封装：隐藏对象的属性和实现细节 继承：从一个基类得到一个或多个类的机制 多态：根据使用类的上下文来重新定义或改变类的性质或行为 二、类和对象的关系 1、类是用于生成对象的代码模板 2、PHP中使用关键字class...
PHP面向对象编程
代码炼金术
12-18 6448
万物皆对象，将构成问题的事务分解到各个对象上，建立对象的目的不是为了完成一个工作，而是为了描述某个事务在解决问题中的行为，更符合人的思维习惯，代码重用性高，可扩展性好。具有抽象方法的类为抽象类，抽象方法即为没有内容的空方法，要求子类进行完善内容，抽象类不能实例化，只能继承，通过 extends 来实现，抽象类中也可以定义普通方法。接口（Interface）是一种定义了一组方法的抽象类型，它只定义了方法的签名（名称、参数和返回类型），而没有具体的实现。抽象类可以包含具体的方法实现，也可以包含抽象方法的声明。
PHP 面向对象编程（OOP）入门指南
最新发布
Perfect—完美的博客
06-26 1351
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，通过使用对象来设计和组织代码。PHP作为一种广泛使用的服务器端脚本语言，支持面向对象编程。本文将介绍PHP面向对象编程的基本概念和用法，并提供示例代码帮助理解。
PHP面向对象简介
CooSheng
04-12 2102
面向对象就是将要处理的问题抽象为对象，然后通过对象的属性和行为来解决对象的实际问题。我们通常所说的面向对象准确的说应该叫面向对象编程（OOP），它是面向对象的一部分。 面向对象主要分为三个部分，如下所示： 面向对象分析（Object Oriented Analysis，OOA）； 面向对象设计（Object Oriented Design，OOD）； 面向对象编程（Object Oriented Programming，OOP）。 本节我们主要介绍的是面向对象编程。 什么是面向对象编程 面向对象
PHP面向对象程序设计实例分析
10-22
PHP面向对象程序设计是PHP语言的重要组成部分，它提供了一种全新的编程范式。本文通过实例详细分析了PHP面向对象程序设计中类的声明、实例化以及方法调用的技巧，这些内容对于理解面向对象编程概念至关重要。 首先...
全面解析PHP面向对象的三大特征
12-17
PHP面向对象的三大特征： 继承，封装，多态 一.继承 1、如何实现继承？ 给子类使用extends关键字，让子类继承父类； class Student extends Person{} 2、实现继承的注意事项？ ① 子类只能继承父类的非私有属性。 ②...
深入PHP面向对象、模式与实践_第3版_高清PDF(附完整源码)
10-23
《深入PHP面向对象、模式与实践》第三版是一本针对PHP开发者深入理解面向对象编程、设计模式和实战技巧的专业书籍。作者通过清晰的讲解和丰富的实例，帮助读者提升PHP编程能力，实现更高层次的软件开发。 PHP是一种...
php phpqrcode 生成二维码
热门推荐
水月情缘~雪飞飞
06-10 1万+
<?php // ==============php phpqrcode 生成二维码======================== // 下载地址：http://sourceforge.net/projects/phpqrcode/files/latest/download // 只需要包含 phpqrcode.php 文件就可以。 // 一：直接输出 include "./phpqrcode
PHP根据两点间的经纬度计算距离
水月情缘~雪飞飞
06-05 1万+
/** *转载自：http://www.jb51.net/article/56967.htm * @desc 根据两点间的经纬度计算距离 * @param float $lat 纬度值 * @param float $lng 经度值 */ function getDistance($lat1, $lng1, $lat2, $lng2){ $earthRadius = 6367000;
php类操作符 -> 连续访问多个方法
水月情缘~雪飞飞
11-08 3204
class a{ private $b = 0; public function c( $Num = 0 ) { $this->b = $Num; return $this; //关键就在这里，有这条就可以连续调用了， } public function d($d) { $this->b = $this->b+$d; retur
Snoopy 网页抓取
水月情缘~雪飞飞
07-08 2427
<?php // ============Snoopy 网页抓取====================== // 使用方式： http://www.itokit.com/2011/1105/72479.html $snoopy = new Snoopy; $url = "http://www.baidu.com"; $snoopy->fetch($url); //获取所有内容 fet
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水月情缘雪飞飞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值