php面向对象方法实例（详细）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hj960511/article/details/51479755

一、php面向对象的简单列子 

以人为列子：

<?php
header("Content-type: text/html; charset=utf-8");
class person{
	//下面是人的成员属性
	var $name;
	//人的名字
	var $sex;
	//人的性别
	var $age;
	//人的年龄
	//定义一个构造方法参数为姓名$name,性别$sex和年龄$age
	function __construct($name,$sex,$age){
		//通过构造方法传进来的$name给成员属性$this->name赋初始值
		$this->name=$name;
		//通过构造方法传进来的$sex给成员属性$this->sex赋初始值
		$this->sex=$sex;
		//通过构造方法传进来的$age给成员属性$this->age赋初始值
		$this->age="$age";
	}
	//下面是人的成员方法
	function say()
	//这个人可以说话的方法
	{
		echo "我的名字叫：".$this->name."性别；".$this->sex."我的年龄是：".$this->age."<br>";
	}
	function run() //这个人可以走路的方法
	{
		echo "这个人在走路";
	}
	//这是一个析构函数，在对象销毁前调用
	function __destruct()
	{
		echo "再见".$this->name."<br>";
	}
}
	//通过构造方法创建3个对象$p1,$p2,$p3，分别传入三个不同的实参为姓名性别和年龄
	$p1=new person("小明","男",20);
	$p2=new person("熊","女",30);
	$p3=new person("向日葵","男",25);
	//下面访问3个对象的说话方式$p1->say();$p2->say();$p3->say();
	$p1->say();		//输出：我的名字叫：小明性别；男我的年龄是：20
	$p2->say();		//输出：我的名字叫：熊性别；女我的年龄是：30
	$p3->say();		//输出：我的名字叫：向日葵性别；男我的年龄是：25
	
	//输出：再见向日葵
	//输出：再见熊
	//输出：再见小明

?> 

二、php面向对象的几个步骤 
第一类的定义：

<?php
  Class myobject{
    //……
}
?>

第二成员方法：

<?php
class myobject{
   function getobjectname($name){
      echo "商品名称为：".$name;
   }
}
?>

第三类的实例化：

<?php
class myobject{
  function getobjectname($name){
     echo "商品名称为：".$name;
   }
}
$c_book=new myobject();           //实例化对象
echo $c_book->getobjectname("计算机图书");  //调用getbookname()方法     //输出：商品名称为：计算机图书
?>

第四成员变量：

<?php
class myobject{
  public $object_name;
  function setobjectname($name){
        $this->object_name=$name;
  }
  function getobjectname(){
        return $this->object_name;
  }
}
$c_book=new myobject();
$c_book->setobjectname("计算机图书");
echo $c_book->object_name."<br>";    //输出：计算机图书
echo $c_book->getobjectname();       //输出：计算机图书
?>

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

<?php
class myobject{                        
  const book_type="计算机图书";             //声明常量book_type
  public $object_name;                               //声明变量
  function setobjectname($name){                     //声明方法setobjectname()
        $this->object_name=$name;                      //设置成员的变量值
  }
  function getobjectname(){                //声明方法getobject()
        return$this->object_name;                        
  }
}
$c_book=new myobject();                    //实例化对象
$c_book->setobjectname("PHP的类");         //调用方法setobjectname
echo myobject::book_type."<br>";          //输出常量的值		        //输出：计算机图书
echo $c_book->getobjectname();            //调用方法getobjectname	//输出：PHP的类
?>

第六面向对象类的构造方法

<?php
class myobject{                        
   public $object_name;   //商品名称
   public $object_price;  //商品价格
   public $object_num;    //商品数量
   public $object_agio;   //商品折扣
   …………
}            
?>

声明一个myobject类的对象，并对这个类的一些成员变量赋初值。代码如下：

<?php
class myobject{                        
   public $object_name;
   public $object_price;
   public $object_num;
   public $object_agio;
   function getobjectname(){
          return $this->object_name;
          return $this->object_price;
          return $this->object_num;
          return $this->object_agio;
   }
}         
$dress=new myobject();
$dress->object_name="western-style clothes";
$dress->object_price=1500;
$dress->object_num=5;
$dress->object_agio=8;
echo $dress->getobjectname();	//输出：western-style clothes  
?>
Void__construect([mixed args,[……]])

注意：函数中的__是两条下划线，不是一条。 
实例2：

扫描二维码关注公众号，回复： 4145577 查看本文章

<?php
class myobject{                        
	  public $object_name;
	  public $object_price;
	  public $object_num;
	  public $object_agio;
	  function __construct($name,$price,$num,$agio){   //通过参数给成员变量赋值
		  $this->object_name=$name;
		  $this->object_price=$price;
		  $this->object_num=$num;
		  $this->object_agio=$agio;
	  }
	  function setobjectname($name){
		  $this->object_name=$name;
	  }
	  function getobjectname1(){
		  return $this->object_name;
	  }
	  function getobjectname2(){
		  return $this->object_price;
	  }
}            
$c_book=new myobject("western-styleclothes",1500,5,8);
echo $c_book->getobjectname1();		//输出：western-styleclothes
echo "<br>";
echo $c_book->getobjectname2();		//输出：1500
?>

第七析构方法： 
概念 
析构方法的作用和构造方法正好相反，是对象被销毁时被调用的，作用是释放内存。析构方法的格式为： 
Void__destruct(void) 
例：

<?php
class myobject{                        
	  public $object_name;
	  public $object_price;
	  public $object_num;
	  public $object_agio;
	  function __construct($name,$price,$num,$agio){   //通过参数给成员变量赋值
		  	  $this->object_name=$name;
			  $this->object_price=$price;
			  $this->object_num=$num;
			  $this->object_agio=$agio;
	  }
	  function setobjectname($name){
			  $this->object_name=$name;
	  }
	  function getobjectname1(){
			  return $this->object_name;
	  }
	  function getobjectname2(){
			  return $this->object_price;
	  }
	  function __destruct(){
			  echo "<p><b>对象被销毁，调用析构函数。</b></p>";
	  }
}            
$c_book=new myobject("western-styleclothes",1500,5,8);
echo $c_book->getobjectname1();		//输出：western-styleclothes
echo "<br>";
echo $c_book->getobjectname2();		//输出：1500
unset($c_book);				//输出：对象被销毁，调用析构函数。
?>

PHP使用的是一种“垃圾回收”机制，自动清除不再使用的对象，释放内存。就是说即使不使用unset函数，析构方法也会自动被调用，这里只是明确一下析构函数在何时被调用。一般情况下是不需要手动创建析构方法的。

<?php
class myobject{                        
	   public $object_name;
	   public $object_price;
	   public $object_num;
	   public $object_agio;
	   function __construct($name,$price,$num,$agio){    //通过参数给成员变量赋值
			  $this->object_name=$name;
			  $this->object_price=$price;
			  $this->object_num=$num;
			  $this->object_agio=$agio;
	  }
	  function setobjectname($name){
			  $this->object_name=$name;
	  }
	  function getobjectname1(){
			  return $this->object_name;
	  }
	  function getobjectname2(){
			  return $this->object_price;
	  }
	  function __destruct(){
			  echo"<p><b>对象被销毁，调用析构函数。</b></p>";
	  }
}            
$c_book=new myobject("western-styleclothes",1500,5,8);
echo $c_book->getobjectname1();		//输出：western-styleclothes
echo "<br>";
echo $c_book->getobjectname2();		//输出：1500
//输出：对象被销毁，调用析构函数。
?>

第八继承和多状态的实现

Class subclass extends superclass{
   ……
}

说明：subclass为子类的名称，superclass为父类名称。 
例：

<?php
class myobject{                        
	  public $object_name;
	  public $object_price;
	  public $object_num;
	  public $object_agio;
	  function __construct($name,$price,$num,$agio){   //通过参数给成员变量赋值
			 $this->object_name=$name;
			 $this->object_price=$price;
			 $this->object_num=$num;
			 $this->object_agio=$agio;
	  }
	  function showme(){
		      echo "这句话会输出吗？答案是不会。";
	  }
}
class book extends myobject{         
      public $book_type;
      function __construct($type,$num){
         	$this->book_type=$type;
         	$this->object_num=$num;  
      }
      function showme(){                            //重写父类中的showme()方法。
            return "本次新进".$this->book_type."图书".$this->object_num."本"."<br>";
      }
}
class elec extends myobject{
      function showme(){                             //重写父类中的showme()方法
            return "热卖商品：".$this->object_name."<br>"."原 价：".$this->object_price."<br>"."特 价".$this->object_price*$this->object_agio;
      }
}
$c_book=new book("计算机类",1000);   //声明一个book子类对象。
$h_elec=new elec("待机王XX系列",1200,3,0.8);    //声明一个elec子类对象。
echo $c_book->showme()."<br>";   //输出book子类的showme()方法	    //输出：本次新进计算机类图书1000本
echo $h_elec->showme();          //输出elec子类的是showme()方法	    //输出：热卖商品：待机王XX系列	原 价：1200	特 价960
?>

子类继承了父类的所有成员变量和方法，包括构造函数。这就是继承的实现。 
当子类被创建时，PHP会先在子类中查找构造方法。如果子类有自己的构造方法，PHP会先调用子类中的方法，当子类中没有时，PHP则会去调用父类中的构造方法。 
两个子类重写了父类的方法showme()，所以两个对象虽然调用的都是showme()方法，但返回的却是两段不同的信息。这就是多态性的实现。

第九this−>和操作符的使用1、this−>和操作符的使用1、this-> 
在 前面类的实例化中，对如何调用成员方法有了基本的了解，那就是用对象名加方法名，格式为“对象名->方法名”。但在定义类时(如 myobject)，根本无法得知对象的名称是什么。这时如果调用类中的方法，就要用伪变量this−>。this−>。this的意思就是本身，所 以$this->只可以在类的内部使用。 
例：
 

<?php
class example{   //创建类example
  	 function exam(){   //创建成员方法
		 if(isset($this)){            //判断变量$this是否存在
			   echo "\$this的值为：".get_class($this);    //如果存在，输出$this所属类的名字
		 }
		 else{
			   echo "$this未定义。";
		 }
  	 }
}
$class_name=new example();   //实例化对象
$class_name->exam();         //调用方法exam()		//输出：$this的值为：example
?>

Get_class函数返回对象所属类的名字，如果不是对象，则返回false。 
2、操作符:: 
相比伪变量$this只能在类的内部使用，操作符::可是真正的强大。操作符::可以在没有声明任何实例的情况下访问类中的成员方法和成员变量。使用：：操作符的通用格式为： 
关键字::变量名/常量名/方法名 
这里的关键字分为3种情况： 
Parent关键字：可以调用父类中的成员变量、成员方法和常量。 
Self关键字：可以调用当前类中的静态成员和常量。 
类名：可以调用本类中的变量、常量和方法。 
例：
 

<?php
class book{
	const name="conputer";      //声明常量name
	function __construct(){        //构造方法
		 echo "本月图书类冠军为：".book::name."<br>";   //输出默认值
	}
}
class l_book extends book{          //book类的子类
	const name="foreign language";      //声明常量
	function __construct(){                  //子类的构造方法
		 parent::__construct();       //调用父类的构造方法
	         echo "本月图书类冠军为：".self::name;    //输出本类中的默认值
	}
}
$obj=new l_book();		
//输出：本月图书类冠军为：conputer
//输出：本月图书类冠军为：foreign language
?>

说明：关于静态方法(变量)的声明及使用可参考以下内容。

第十公共、私有和保护 
1、 public公共成员 
顾名思义，就是可以公开的、没有必要隐藏的数据信息。可以在程序的任何地点(类内、类外)被其他的类和对象调用。子类可以继承和使用父类中所有的公共成员。 
所有的变量都被声明为public，而所有的方法在默认的状态下也是public。所以对变量 
和方法的调用显示得十分混乱。为了解决这个问题，就需要使用第二个关键字：private。 
2、 private私有成员 
被private关键字修饰的变量和方法，只能在所属类的内部被调用和修改，不可以在类外被访问。在子类中也不可以。 
例：
 

<?php
class book{
	private $name="computer";
	public function setname($name){
	   $this->name=$name;
	}
	public function getname(){
	   return $this->name;
	}
}
class lbook extends book{
}
$lbook=new lbook();
echo "正确操作私有变量的方法：";	    //输出：正确操作私有变量的方法：
$lbook->setname("PHP应用开发！");	
echo $lbook->getname();		    //输出：PHP应用开发！
echo "直接操作私有变量的结果：";	    //输出：直接操作私有变量的结果：
echo book::name;                    //输出：Fatal error: Undefined class constant 'name' in C:\wamp\www\test\private.php on line 26
?>

对于成员方法，如果没有写关键字，那么默认就是public。从本节开始，以后所有的方法及变量都会带个关键字，这是一种良好的书写习惯。 
3、 protected保护成员 
private 关键字可以将数据完全隐藏起来，除了在本类外，其他地方都不可以调用。子类也不可以。但对于有些变量希望子类能够调用，但对另外的类来说，还要做到封装。 这时，就可以使用protected。被protected修改的类成员，可以在类和子类中被调用，其他地方则不可以被调用。 
例：
 

<?php
class book{
 	 protected $name="computer";
}
class lbook extends book{
 	 public function showme(){
      	 echo "对于protected修饰的变量，在子类中是可以直接调用的。如：\$name=".$this->name."<br>";
     }
}
$lbook=new lbook();
$lbook->showme();		//输出：对于protected修饰的变量，在子类中是可以直接调用的。如：$name=computer
echo "但在其他的地方是不可以调用的，否则：";	//输出：但在其他的地方是不可以调用的，否则：
$lbook->name="history";		//输出： Fatal error: Cannot access protected property lbook::$name in C:\wamp\www\test\protected.php on line 21
?>

第十一 PHP对象的高级应用 
1. final关键字 
final，中文含义是最终的、最后的。被final修饰过的类和方法就是“最终版本”; 
如果有一个类的格式为：

Final class class_name{
}

说明该类不可以再被继承，也不能再有子类。 
如果有一个方法的格式为： 
Final function method_name(); 
说明该方法在子类中不可以进行重写，也不可以被覆盖。 
例：

<?php
final class myobject{
	 function __construct(){
		  echo "initialize object";
	 }
}
class mybook extends myobject{
  	 static function exam(){
      	 echo "you can't see me.";
   }
}
mybook::exam();		
?>

输出的结果是：

Fatal error: Class mybookmay not inherit from final class (myobject) in C:\webserver\wwwroot\2.phpon line 19

1. 抽象类 
   抽象类是一种不能被实例化的类，只能作为其他类的父类来使用。抽象类使用abstract关键字来声明，格式为：

Abstract class abstractname{
}

抽象类和普通类相似，都包含成员变量、成员方法。两者的区别在于，抽象类至少要包含一个抽象方法。抽象方法没有方法体，其功能的实现只能在子类中完成。抽象方法也是使用abstract关键字修饰的。它的格式为： 
Abstract function abstractname(); 
注意：在抽象方法后面要有分号“;” 
抽象类和抽象方法主要应用于复杂的层次关系中，这种层次关系要求每一个子类都包含并重写某些特定的方法。举一个例子：中国的美食是多种多样的，有吉菜、鲁菜、川菜、粤菜等。每种菜系使用的都是煎、炒、炸等手法，只是在具体的步骤上，各有各的不同。如果把中国美食当作一个大类cate，下面的各大菜系就是cate的子类，而煎炒烹炸则是每个类中都有的方法。每个方法在子类中的实现都是不同的，在父类中无法规定。为了统一规范，不同子类的方法要有一个相同的方法名：decoct(煎)、stir_fry(炒)、cook(烹)、fry(炸)。 
例：
 

<?php
    /* 抽象类myobject */
        abstract class myobject{    //抽象方法servie
            abstract function service($getname,$price,$num);
        }
        //声明抽象类的子类mybook
        class mybook extends myobject{    //实现抽象方法service
            function service($getname,$price,$num){
                      echo "您购买的商品是".$getname.",该商品的价格是：".$price."元";
                      echo "您购买的数量为：".$num."本。";
                      echo "如发现缺页、损坏、请在3日内更换。";
               }
        }
        //声明另一个抽象类的子类mycomputer
        class mycomputer extends myobject{   //实现抽象方法service
            function service($getname,$price,$num){
                      echo "您购买的商品是：".$getname.",该商品的价格是：".$price."元。";
                      echo "您购买的数量为：".$num."台。";
                      echo "如发生非人为质量问题，请在3个月内更换。";
               }
        }
        $book=new mybook();    //实例化对象$book
        $computer=new mycomputer();   //实例化对象$computer
        $book->service("《PHP从入门到精通》",85,3);   //调用$book对象的service方法
        echo "<br />";   
        $computer->service("XX笔记本",8500,1);    //调用computer对象的service方法
	//输出：您购买的商品是《PHP从入门到精通》,该商品的价格是：85元您购买的数量为：3本。如发现缺页、损坏、请在3日内更换。
	//输出：您购买的商品是：XX笔记本,该商品的价格是：8500元。您购买的数量为：1台。如发生非人为质量问题，请在3个月内更换。
		
?>

1. 接口的使用 
   继承特性简化了对象、类的创建，增加了代码的可重性。但PHP只支持单继承。如果想实现多重继承，就要使用接口。PHP可以实现多个接口。 
   接口类通过interface关键字来声明，并且类中只能包含未实现的方法和一些成员变量，格式如下：

Interface interfacename{
  Function interfacename1();
  Function interfacename2();
  ………………
}

注意：不要用public以外的关键字来修饰接口中的类成员，对于方法，不写关键字也可以。这是一个接口类自身的天性决定的。 
子类是通过implements关键字来实现接口的，如果要实现多个接口，那么每个接口之间使用逗号“，”连接。而且所有未实现的方法需要在子类中全部实现，否则PHP将会出现错误。格式如下：
 

Class subclass implementsinterfacename1,interfacename2{
    Function interfacename1(){
       //功能实现
     }
    Function interfacename2(){
       //功能实现
     }
     …………
}

例：本例首先声明了两个接口mpopedom和mpurview，接着声明了两个类member和manager，其中member类继承了mpopedom接口;manager继承了mpopedom和mpurview接口。分别实现各自的成员方法后，实例化两个对象member和member和manager。最后调用实现的方法。

<?php
interface mpopedom{
           function popedom();
}
        interface mpurview{
           function purview();
        }
        class member implements mpurview{
            function purview(){
                    echo "会员拥有的权限";
            }
        }
        class manager implements mpurview,mpopedom{
            function purview(){
                echo "管理员拥有会员的全部权限。";
            }
            function popedom(){
                echo "管理员还有会员没有的权限。";
            }
        }
        $member = new member();
        $manager = new manager();
        $member -> purview();		//输出：会员拥有的权限
        echo "<br />";
        $manager -> purview();	        //输出：管理员拥有会员的全部权限。
        $manager -> popedom();	        //输出：管理员还有会员没有的权限。

?>

通过上面的实例可以发现，抽象类和接口实现的功能十分相似。抽象类的优点是可以在抽象类中实现公共的方法，而接口则可以实现多继承。至于何时使用抽象类和接口就要看具体实现了。 
4. 克隆对象 
（1）、克隆对象 
在PHP4中，对象被当作普通的数据类型来使用。如果想引开对象，需要使用&来声明，否则会按照PHP4的默认方式来按值传递对象。 
例：本实例首先实例化一个myobject类的对象book1，book1，book1的默认值是book，然后将对象book1使用普通数据类型的赋值方式给对象book1使用普通数据类型的赋值方式给对象book2赋值。改变book2的值为computer，再输出对象book2的值为computer，再输出对象book1的值。
 

<?php
     class myobject{
               private $object_type="book";
               public function settype($type){
                   $this->object_type=$type;  
               }
               public function gettype(){
                   return $this->object_type;
               }
        }
        $book1=new myobject();
        $book2=$book1;
        $book2->settype("computer");
        echo "对象\$book1的值为：".$book1->gettype();		//输出：对象$book1的值为：computer
?>

上面的实例，在PHP5中的返回值为：对象book1的值为：computer。因为book1的值为：computer。因为book2只是book1的一个引用，而在PHP4中的返回值是：对象book1的一个引用，而在PHP4中的返回值是：对象book1的值为：book，因为对象book2是book2是book1的一个备份。 
在PHP5中如果需要将对象复制，也就是克隆一个对象。需要使用关键字clone来实现。克隆一个对象的格式为：
 

$object1=new classname();
$object2=clone $object1;

（2）、__clone()方法

有时除了单纯地克隆对象外，还需要克隆出来的对象可以拥有自己的属性和行为。这时就可以使用_clone()方法来实现。__clone()方法的作用是：在克隆对象的过程中，调用_clone()方法，可以使用克隆出来的对象保持自己的一些行为及属性。 
例：

<?php
     class myobject{
                 private $object_type="book";
                 public function settype($type){
                      $this->object_type=$type;
                 }
                 public function gettype(){
                      return $this->object_type;
                 }
                 public function __clone(){
                     $this->object_type="computer";
                                            }      
        }
        $book1=new myobject();
        $book2=clone $book1;
        echo "对象$book1的变量值为：".$book1->gettype();		
        echo"<br />";
        echo "对象$book2的变量值为：".$book2->gettype();
	//输出：Notice: Undefined variable: book1的变量值为： in C:\wamp\www\test\clone2.php on line 24   对象book
	//输出：Notice: Undefined variable: book2的变量值为： in C:\wamp\www\test\clone2.php on line 26   对象computer
?>

1.对象比较 

通过克隆对象，相信读者已经理解表达式boject2=boject2=object1和object2=cloneobject2=cloneobject1所表示的不同含义。但在实际开发中，应如何判断两个对象之间的关系是克隆还是引用？ 

这是可以使用比较运算符==和===。两个等号是比较两个对象的内容，3个等号===是比较对象的引用地址。 

例：
 

来源：https://blog.csdn.net/hj960511/article/details/51479755