当前位置：首页 > PHP教程 > php面向对象 > 列表

php学习笔记之面向对象

发布:smiling　来源: PHP粉丝网 　添加日期：2021-04-25 10:30:34　浏览: 评论：0　

面向对象是一种计算机编程架构，比面向过程编辑具有更强的灵活性和扩展性。这里想提醒一下初学者：要想在编程这条路上走得比别人远，就一定要掌握面向对象编程技术。

public   公有的：本类，子类，外部对象都可以调用

protected 受保护的：本类 子类，可以执行，外部对象不可以调用

private 私有的：只能本类执行，子类与外部对象都不可调用

面向对象编程的三大特点

1)封闭性

封闭性，也可以称为信息隐藏。就是将一个类的使用和实现分开，只保留有限的接口(方法)与外部联系。对于用到该类的开发人员，只要知道这个类如何使用即可，而不用去关心这个类是如何实现的。这样做可以让开发人员更好地把精力集中起来专注别的事情，同时也避免了程序之间的相互依赖而带来的不便。

2)继承性

继承性就是派生类(子类)自动继承一个或多个基类(父类)中的属性与方法，并可以重写或添加新的属性和方法。继承这个特性简化了对象和类的创建，增加了代码的可重性。继承分单继承和多继承，PHP所支持的是单继承，也就是说，一个子类有且只有一个父类。

3)多态性

多态性是指同一个类的不同对象，使用同一个方法可以获得不同的结果，这种技术称为多态性。多态性增强了软件的灵活性和重用性。

类的定义

一个类可以包含有属于自己的常量，变量（称为“属性”）以及函数（称为“方法”）。

和很多面向对象的语言一样，PHP也是通过class关键字加类名来定义类的。类的格式如下：
  1. <?php 
  2.   Class myobject{ 
  3.     //…… 
  4. } 
  5. ?> 

定义：物以类聚，把具有相似特性的对象归到一个类中，类定义了这些相似对象拥有的相同属性和方法。类是相似对象的描述，称为类的定义，是该类对象的蓝图或原型。

类的对象称为类的一个实例。要创建一个类的实例，必须使用 new 关键字。

001ZpQGYty6MeYnSNUh25&690

代码如下:

  1. <?php 
  2. //类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写 
  3.     class NbaPlayer{ 
  4.         public $name = "Jordan"; //定义属性 
  5.         public $height = "198cm"; 
  6.         public $team = "Bull"; 
  7.         public $playerNumber = "23"; 
  8.         //定义方法 
  9.     public function run(){ 
  10.         echo "Running\n"; 
  11.     } 
  12.     public function dribblr(){ 
  13.         echo "Dribbling\n"; 
  14.     } 
  15.     public function pass(){ 
  16.         echo "Passing\n"; 
  17.     } 
  18. }//www.phpfensi.com 
  19.     //类到对象的实例化 
  20.     //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号 
  21.     $jordan = new NbaPlayer();  
  22.  
  23.     //对象中的属性成员可以通过"->"符号来访问 
  24.     echo $jordan->name."\n"; 
  25.  
  26.     //对象中的成员方法可以通过"->"符号来访问 
  27.     $jordan->dribble(); 
  28.     $jordan->run(); 
  29. ?> 

成员方法

类中的函数被称为成员方法。函数和成员方法唯一的区别就是，函数实现的是某个独立的功能，而成员方法是实现类中的一个行为，是类的一部分。

下面就来扩充上面的myobject类，为它添加一个成员方法，代码如下：

  1. <?php 
  2. classmyobject{ 
  3.    function getobjectname($name){ 
  4.       echo "商品名称为：".$name; 
  5.    } 
  6. } 
  7. ?> 

该方法的作用是输出商品名称，商品名称是通过方法的参数传进来的。

类是一个抽象的描述，是功能相似的一组对象的集合。如果想用到类中的方法和变量，首先就要把它具体落实到一个实体，也就是对象上。

类常量

既然有变量，当然也会有常量了。常量就是不会改变的量，是一个恒值。众所周知的一个常量就是圆周率Pi。定义常量使用关键字const如：

ConstPI=3.14159;

构造函数

PHP 5 允行开发者在一个类中定义一个方法作为构造函数。具有构造函数的类会在每次创建新对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作，代码如下:

  1. <?php 
  2. //类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写 
  3.     class NbaPlayer{ 
  4.         public $name = "Jordan"; //定义属性 
  5.         public $height = "198cm"; 
  6.         public $team = "Bull"; 
  7.         public $playerNumber = "23"; 
  8.         //构造函数，在对象被实例化的时候自动调用 
  9.         function __construct($name,$height,$weight,$team){ 
  10.             echo "It is an  NbaPlayer constructor\n"; 
  11.             $this->name = $name; 
  12.             //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法 
  13.             $this->height = $height; 
  14.             $this->weight = $weight; 
  15.             $this->team = $team; 
  16.         } 
  17.  
  18.         //定义方法 
  19.     public function run(){ 
  20.         echo "Running\n"; 
  21.     } 
  22.     public function dribblr(){ 
  23.         echo "Dribbling\n"; 
  24.     } 
  25.     public function pass(){ 
  26.         echo "Passing\n"; 
  27.     } 
  28. } 
  29.     //类到对象的实例化 
  30.     //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号 
  31.     $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");    
  32.  
  33.     //对象中的属性成员可以通过"->"符号来访问 
  34.     echo $jordan->name."\n"; 
  35.  
  36.     //对象中的成员方法可以通过"->"符号来访问 
  37.     $jordan->dribble(); 
  38.     $jordan->run(); 
  39.  
  40.     //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数 
  41.     $james = new NbaPlayer("James","203cm","120kg","Heat") 
  42.     echo $james->name."\n"; 
  43. ?> 

析构函数，代码如下:

  1. <?php 
  2. //类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写 
  3.     class NbaPlayer{ 
  4.         public $name = "Jordan"; //定义属性 
  5.         public $height = "198cm"; 
  6.         public $team = "Bull"; 
  7.         public $playerNumber = "23"; 
  8.         
  9.         //构造函数，在对象被实例化的时候自动调用 
  10.         function __construct($name,$height,$weight,$team){ 
  11.             echo "It is an  NbaPlayer constructor\n"; 
  12.             $this->name = $name; 
  13.             //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法 
  14.             $this->height = $height; 
  15.             $this->weight = $weight; 
  16.             $this->team = $team; 
  17.         } 
  18.         
  19.         //析构函数，在程序执行结束的时候会自动调用 
  20.         //析构函数通常被用于清理程序使用的资源。比如程序使用了打印机，那么可以再析构函数里面释放打印机资源 
  21.         function __destruct(){ 
  22.             echo "Destroying".$this->name."\n"; 
  23.         } 
  24.         
  25.         //定义方法 
  26.     public function run(){ 
  27.         echo "Running\n"; 
  28.     } 
  29.     public function dribblr(){ 
  30.         echo "Dribbling\n"; 
  31.     } 
  32.     public function pass(){ 
  33.         echo "Passing\n"; 
  34.     } 
  35. } 
  36.     //类到对象的实例化 
  37.     //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号 
  38.     $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");    
  39.     
  40.     //对象中的属性成员可以通过"->"符号来访问 
  41.     echo $jordan->name."\n"; 
  42.     
  43.     //对象中的成员方法可以通过"->"符号来访问 
  44.     $jordan->dribble(); 
  45.     $jordan->run(); 
  46.     
  47.     //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数 
  48.     $james = new NbaPlayer("James","203cm","120kg","Heat") 
  49.     echo $james->name."\n"; 
  50.     
  51.     //通过把变量设为null，可以触发析构函数的调用 
  52.     //当对象不再使用的时候会触发析构函数 
  53.     $james = null; 
  54.     echo "from now on James will not be used.\n" 
  55. ?> 

析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

对象的引用，代码如下:

  1. <?php 
  2. //类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写 
  3.     class NbaPlayer{ 
  4.         public $name = "Jordan"; //定义属性 
  5.         public $height = "198cm"; 
  6.         public $team = "Bull"; 
  7.         public $playerNumber = "23"; 
  8.         //构造函数，在对象被实例化的时候自动调用 
  9.         function __construct($name,$height,$weight,$team){ 
  10.             echo "It is an  NbaPlayer constructor\n"; 
  11.             $this->name = $name; 
  12.             //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法 
  13.             $this->height = $height; 
  14.             $this->weight = $weight; 
  15.             $this->team = $team; 
  16.         } 
  17.  
  18.         //析构函数，在程序执行结束的时候会自动调用 
  19.         //析构函数通常被用于清理程序使用的资源。比如程序使用了打印机，那么可以再析构函数里面释放打印机资源 
  20.         function __destruct(){ 
  21.             echo "Destroying".$this->name."\n"; 
  22.         } 
  23.  
  24.         //定义方法 
  25.     public function run(){ 
  26.         echo "Running\n"; 
  27.     } 
  28.     public function dribblr(){ 
  29.         echo "Dribbling\n"; 
  30.     } 
  31.     public function pass(){ 
  32.         echo "Passing\n"; 
  33.     } 
  34. } 
  35.     //类到对象的实例化 
  36.     //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号 
  37.     $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");    
  38.  
  39.     //对象中的属性成员可以通过"->"符号来访问 
  40.     echo $jordan->name."\n"; 
  41.  
  42.     //对象中的成员方法可以通过"->"符号来访问 
  43.     $jordan->dribble(); 
  44.     $jordan->run(); 
  45.  
  46.     //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数 
  47.     $james = new NbaPlayer("James","203cm","120kg","Heat") 
  48.     echo $james->name."\n"; 
  49.  
  50.     //对象的引用用于访问对象的属性和方法，$james,$james1和$james2都是对象的引用 
  51.     //$james和$james1是对象的两个独立引用 
  52.     //$james2是$james的影子，使用对象的同一个引用，任何一个赋值为null相当于删除了同一个引用 
  53.     $james1 = $james; 
  54.     $james2 = &$james 
  55.  
  56.     $james = null; 
  57.     echo "from now on James will not be used.\n" 
  58. ?> 

Tags: php面向对象

分享到：

相关文章

推荐文章

热门文章

最新评论文章