PHP面向对象开发基础与实例

<1> 面向对象涉及到软件开发的各个方面，如面向对象分析（OOA），面向对象的设计（OOD），面向对象的编程实现（OOP）。


<2> 面向对象的要素包括：抽象性；封装性；共享性；强调对象结构而不是程序结构。


<3> 封装，继承与多态是面向对象开发的三大特点，缺一不可。


<4> 类（Class）实际上是对某种类型的对象定义变量和方法的原型。它包含有关对象动作方式的信息，包括它的名称、方法、属性和事件。实际上它本身并不是对象，因为它不存在于内存中。当引用类的代码运行时，类的一个新的实例，即对象，就在内存中创建了。虽然只有一个类，但能从这个类在内存中创建多个相同类型的对象。


可以把类看作“理论上”的对象，也就是说，它为对象提供蓝图，但在内存中并不存在。从这个蓝图可以创建任何数量的对象。从类创建的所有对象都有相同的成员：属性、方法和事件。但是，每个对象都象一个独立的实体一样动作。例如，一个对象的属性可以设置成与同类型的其他对象不同的值。


1.类的成员属性与成员方法


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class Bike{                    // 使用CLASS创建一个类
var $name;                    // 定义成员属性
var $price;
function run () {             //定义成员方法       
return "1200km";
}
}
?>
对象的实例化


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class Bike{                                  // 使用CLASS创建一个类
var $name;                                  // 定义成员属性
var $price;
function run () {                           //定义成员方法       
return "1200km";
}
}
$bk=new Bike();                         // 使用NEW函数实例化对象  
echo $bk->name;                      // 使用->访问对象内容
?>


2.类的封装
出于保护与安全的需要，对程序的相关属性和方法进行隐藏。


封装关键字


public ： 全局变量，在类的内外均可访问。
      protected ：保护属性，只有在本类、子类、父类中可以访问。
      private ：私有属性，只能在当前类中使用。 


使用 public 全局变量，对其定义的对象既可以访问，也可以修改，如：


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class mobile{
public $name;                               // $name 具有公共属性
function __construct($name=""){
$this->name=$name;
}
}
$mb1=new mobile("手机");
$mb1->name="移动电话";             // 可以改变name的值
echo $mb1->name;                      // 可以访问name的值 
?>
使用 private 私有变量，将对象的属性私有化。


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class mobile{
private $name;                                // $name具有私有属性
function __construct($name=""){
$this->name=$name;
}
function call(){                                 // 通过公有的对象方法下$this关键字来访问name的值
 return $this->name."正在开机中，请稍候......";
 }
}
$mb1=new mobile("手机");
echo $mb1->call();                          // 通过访问公有的对象方法call来访问私有了的name的值
?>
3.构造函数与析构函数
系统变量：$this


用来访问当前对象中的对象属性和对象方法。
      [注] $this仅能在当前对象中使用。


构造函数


以下为引用内容：
/***
  * desteps.com  Michael
***/
class Bike{
function __construct(){
//初始化操作
}
}
析构函数


能够在对象释放时自动被调用的方法。
      当对象内部的操作执行完毕时，__destruct()被调用，然后对象所使用的内存被释放出来。


实例：


<1> $this 方式访问对象


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class Bike{
public $name;
function sport(){
return "$this->name:健身";
}
function game(){
return "$this->name:比赛";
}
function traffic(){
return "上班";
}
}
$bk1=new Bike();
$bk2=new Bike();
$bk1->name="赛车";
$bk2->name="健身车";
echo $bk1->game(),"<hr align='left' width='160px'/>";
echo $bk2->sport(),",",$bk2->traffic();
?>
<2> __construct 函数


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class Bike{
public $name;
function __construct($name=""){
$this->name=$name;
}
 function sport(){
return "$this->name:健身";
}
function game(){
return "$this->name:比赛";
}
function traffic(){
return "上班";
}
}
$bk1=new Bike("赛车");
$bk2=new Bike("健身车");
echo $bk1->game(),"<hr align='left' width='160px'/>";
echo $bk2->sport(),",",$bk2->traffic();
?>


<3> 析构函数__destruct


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class Bike{
public $name;
function __construct($name=""){
$this->name=$name;
}
function sport(){
return "$this->name:健身";
}
function game(){
return "$this->name:比赛";
}
function traffic(){
return "上班";
}
function __destruct(){
 echo "<hr color='#ff6600' align='left' width='160px'/>********$this->name";
 }
}
$bk1=new Bike("赛车");
$bk2=new Bike("健身车");
echo $bk1->game(),"<hr align='left' width='160px'/>";
echo $bk2->sport(),",",$bk2->traffic();
?>
4,类的继承与访问


类的继承


继承关键字：extends ，子类（派生类）继承父类（基类），利用 extends 单一继承的方法，共享被继承类（父类）的内容。


继承规则


class1  extends  class2  extends   class3  
      [注] 子类与父类的属性和方法应避免重名。


演示实例：


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
class ku{
function kx(){
return "基类中的内容<br/>";
}
}
class su extends ku{                     // 类的继承
function sx(){
return "继承类中的内容";
}
}
$su=new su();                               // 对继承类SU进行实例化
echo $su->kx();                             // 继承类SU是否已经继承基类KU中的内容
?>
同时访问基类和继承类中的内容


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
class ku{
function kx(){
return "基类中的内容<br/>";
}
}
class su extends ku{
function sx(){
return $this->kx()."继承类中的内容";        // 用this关键字来实现基类和继承类内容的同时访问
} 
}
$su=new su();
echo $su->sx();
?>
5.基类方法的重载


基类方法的重载


在派生类里使用与基类方法重名的方法名称来执行重载。


基类方法的访问


重载时需要调用原始基类的内容，再增加新的内容，可以使用：
      基类名::方法名称


重载访问演示实例


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
class ku{
function kx(){                    
return "基类中的内容<br/>";
}
}
class su extends ku{
function kx(){                                          // 与基类方法重名
return ku::kx()."继承类中的内容";       // 重载的访问
} 
}
$su=new su();
echo $su->kx();
?>
用protected对基类方法进行封装


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
class ku{
protected function kx(){                           //   用protected对基类方法进行封装            
return "基类中的内容<br/>";
}
}
class su extends ku{
function kx(){
return ku::kx()."继承类中的内容";
} 
}
$su=new su();
echo $su->kx();
?>
[注]  用protected对基类方法进行封装，可以在本类和继承类中进行访问；而private只能在本类中进行访问。


6.抽象方法和抽象类


抽象的类


抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
      PHP中使用abstract来声明一个抽象类或抽象方法。


定义抽象方法和抽象类


类中至少有一个方法是抽象的，这个类称之为抽象类；
      如果定义抽象类须首先定义抽象方法。


以下为引用内容：
abstract class ku{
abstract function kx()
......
}
[注] 类中至少有一个抽象方法；
            抽象方法中没有{  } ；
            抽象方法前必须要加abstract 。


抽象类的特点


不能被实例化，只能被继承。
      继承的派生类当中要把所有抽象方法重载才能实例化。


抽象方法重载演示实例


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
abstract class ku{
abstract function kx1();
abstract function kx2();
abstract function kx3();
function kx4(){
return "一共有三种抽象方法，这是重载的";
}
}
class su extends ku{
function kx1(){
echo "第一种抽象方法";
}
function kx2(){
echo ku::kx4()."第二种抽象方法";
}
function kx3(){
echo "第三种抽象方法";
} 
}
$su=new su();
$su->kx2();
?>
7.final关键字详解


关键字 final


用来定义类和方法的一个关键字，当定义类时该类将不能被继承；当定义方法时该方法将不能被重载。


以下为引用内容：
final  class cla{
final function fun(){
......
}
......
}
类的继承与方法重载的示例


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class mobile{
public $name="手机";
function call(){
return $this->name."具有电话功能<br/>";
}
}
class mmobile extends mobile{
function call(){
echo mobile::call(). "音乐手机继承了手机原有的电话功能"; 
}
}
$mb1=new mmobile();
echo $mb1->call();
?>
当使用 final 来定义方法时，该方法不能被重载。


8.静态成员及其访问


self 关键字


用来用类访问当前类中的内容的关键字，类似 $this 关键字，但 $this 需要类实例化以后才可以使用，而 self 则可以直接访问当前类中的内部成员（属性或方法）。


self ::  类内部成员（属性或方法）等同：类名称 ::  类内部成员（属性或方法）


[注] self 一般用来访问类中的“静态成员”，常量或其它定义内容。


static 关键字


用来定义类的静态属性或方法，可以在类未被实例化时使用，静态属性单独占用内存，而不会因创建多个对象时而导致同样的方法或属性重复占用。


以下为引用内容：
class cla{
static $name;
static function fun(){
......
}
}
[注] 静态方法内部禁止出现非静态内容。


静态成员的访问


<1> 在类内部访问静态成员：
      类名称 :: 静态成员
      self :: 静态成员


<2> 在类外部访问静态成员：
      类名称 :: 静态成员


类属性的静态化及其访问


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
final class mobile{
static $name="手机";
final function call(){
return self::$name."具有电话功能<br/>";
}
}
$mb1=new mobile();
echo $mb1->call();
?>
9.const关键字详解


const 关键字


在定义一个常量的时候我们可以使用 const 来修饰这个常量；


只能申明类中的成员属性而不能申明成员方法；


使用 const 修饰的常量与其它的常量有点不同的是常量名前不要使用”$”；


当然这个常量值也是不能修改的，一旦定义就不能在程序的任何地方进行“人为”的修改；


还有就是使用 const 来定义当然也遵守其它常量的命名规则――使用大字的字母。


演示实例


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
final class mobile{
const NAME="手机";
static function call(){
return self::NAME."具有电话功能";
}
}
$mb=new mobile;
echo $mb->call();
?>
输出：手机具有电话功能


10.接口的创建与引用


接口的概念


接口是一种成员属性全部为抽象或常量的特殊抽象类。


接口与抽象类的区别
      抽象类：
      <1> 类中至少有一个抽象方法。
      <2> 抽象方法前需加 abstract 。
      接口：
      <1> 类中全部为抽象方法。
      <2> 抽象方法前不用加 abstract 。
      <3> 定义抽象方法时，抽象方法为公共属性( public )。
      <4> 成员属性必须为常量。


接口与抽象类的共同点
      <1> 本身不能被实例化，必须被继承或引用。
      <2> 继承或引用后，需要把所有抽象方法重载方可使用。


创建接口


关键字：interface 
      格式：


以下为引用内容：
interface demo{
const NAME="常量";
function fun1();
function fun2();
}
接口的引用与规则


关键字：implements 。
      可以有多个引用，并用"，"分开。


设已有基类 mob ，接口demo1，demo2，demo3。


<1> 普通类引用接口


以下为引用内容：
class mob implements demo1,demo2,demo3{
......
}
<2> 抽象类引用接口


以下为引用内容：
abstract class mob implements demo1,demo2,demo3{
......
}
11.多态应用详解


什么是多态


多态是接抽象和继承之后，面向对象语言的第三个特征，具有表现多种形态的能力，在OOP中是指语言具有根据对象的类型以不同方法处理。
      OOP模式并不仅仅是很多函数和功能的集合，而是使用类、继承、多态的方式使我们描述的对象代码更具有“物”的意义，帮助减少一些重复性的代码和条件的判断。


运算符：instanceof


是PHP的一个类型运算符，用来测定一个给定的对象是否来自指定的对象类。


以下为引用内容：
class A{}
class B{}
$thing = new A ;
if ($thing instanceof A){
echo "A";
}
if($thing instanceof B){
echo "B";
}
多态的应用示例


假定现有两个类UP和MP4，U盘（UP）和MP4分别插入电脑（PC）USB接口。


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
interface usb{                                                  // 创建一个USB接口
function type();                                                // 型号
function alert();                                                // 提示
}
class up implements usb{                            // UP
function type(){
echo "型号：2.0<br/>";
}
function alert(){
echo "正在检查U盘驱动 . . . . . .";
}
}
class mp4 implements usb{                           //MP4
function type(){
echo"型号：1.0<br/>"; 
}
function alert(){
echo "正在检查mp4驱动 . . . . . .";
}
}
class pc{                                                              // 创建一个电脑的类
function pcusb($wt){                                          // 电脑USB接口方法
$wt->type();                                                          // 判断接口类型
$wt->alert();                                                          // 执行检查驱动
} 
}
$pc=new pc;
$up=new up;
$mp4=new mp4;
$pc->pcusb($up);                                                 // 在电脑接口上插入U盘时
?>
12.PHP面向对象之对象描述的配置


对象描述的配置


方法名：_ _ tostring()


可以直接打印对象句柄，从而获得该方法的基本信息或其它信息。


tostring 方法的用法：


以下为引用内容：
class descript{
function __tostring(){
return " 描述descript类的一些基本信息";
}
}
$ds=new descript ;
echo $ds;
tostring 方法演示实例


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
class descript{
public $name="tostring 方法";
function __tostring(){
return $this->name."可以直接打印对象句柄，从而获得该方法的基本信息。";
}
}
$ds=new descript;
echo $ds;
?>
运行结果：


tostring 方法可以直接打印对象句柄，从而获得该方法的基本信息。


13.PHP面向对象对象方法的异常处理


对象方法的异常处理


方法名：_ _call($funname,$arr_value)


调用一些不存在的对象方法的异常处理，使程序继续正常运行。


call方法的用法：


以下为引用内容：
/***
  * desteps.com  Michael
***/
class dispose{
function __call($n,$v){
echo "错误的方法".$n;
echo "错误的参数".print_r($v);
}
}
call方法的演示实例


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
class dispose{
public $name="call 方法";
function __tostring(){
return $this->name."调用一些不存在的对象方法的异常处理，使程序继续正常运行。<br/>";
}
function __call($n,$v){
echo "不存在的方法为：".$n."<br/>不存在的值是：";
echo print_r($v);
}
}
$ds=new dispose;
echo $ds;
$ds->noth("nothing",2050);
?>
运行结果：


call 方法调用一些不存在的对象方法的异常处理，使程序继续正常运行。
      不存在的方法为：noth
      不存在的值是：Array ( [0] => nothing [1] => 2050 ) 1


14.PHP面向对象克隆对象方法详解


克隆对象


方法名：_ _clone
      关键字：clone
      通过克隆的方式可以在内存中生成两个一样的对象或升级原对象。


克隆的原理


<1> 内存中只有一个对象


以下为引用内容：
$a=new cla;
$b=$a;
<2>内存中会有两个对象


以下为引用内容：
$a=new cla;
$b=clone $a;
<3>clone 方法


以下为引用内容：
class cla{
function __clone(){
echo "克隆时自动初始化的函数";
}
}
clone（克隆）对象示例


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
class clo{
public $name="等于的方法";
function fun(){
return $this->name."只是将一个类赋值给另一个类，所以此时内存中仍是一个对象";
}
function __destruct(){
echo "<br/>清理了一个对象"; 
}
}
$ds=new clo;
$dt=$ds;
echo $dt->fun();
?>
运行结果：
      等于的方法只是将一个类赋值给另一个类，所以此时内存中仍是一个对象
      清理了一个对象


以下为引用内容：
/***
  * desteps.com  Michael
***/
 <?php
class clo{
public $name="等于方法";
function fun(){
return $this->name."克隆出了一个新的类，所以此时内存中有两个对象";
}
function __destruct(){
echo "<br/>清理了一个对象"; 
}
function __clone(){
$this->name="clone 方法"; 
}
}
$ds=new clo;
$dt= clone $ds;
echo $dt->fun();
?>
运行结果：


clone 方法克隆出了一个新的类，所以此时内存中有两个对象
      清理了一个对象
      清理了一个对象


15.PHP面向对象自动载入对象详解


方法名：_ _autoload()


取得对象名称并自动载入当前页面。


自动载入方法


以下为引用内容：
function __autoload($class_n){
includ($class_n.".php");
}
$cla=new cla;
$clb=new clb;
等同于 include 方法


以下为引用内容：
include("cla.php");
include("clb.php");
自动载入对象示例


先新建两个文件作为载入对象（cla.php ；clb.php）


cla.php


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php 
class cla{
function fun1(){
echo "这是一个cla类";
}
}
?>
clb.php


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
class clb{
function fun2(){
echo "这是一个clb类";
}
}
?>
引用文件 auto.php


以下为引用内容：
/***
  * desteps.com  Michael
***/
<?php
function __autoload($name){
include("$name.php");
}
$cla=new cla;
$cla->fun1();
echo "<br/>";
$clb=new clb;
$clb->fun2();
?>