PHP 类与对象

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

• 类以class+类名定义，类定义后调用时就是对象。

• 类里后跟大括号｛｝一对，里面包含有类的属性与方法的定义。
  

• 类名以字母或下划线开头，后面跟着若干字母，数字或下划线。

语法：

访问控制

• public（公有,默认为公有）表示可以在任何范围哦被调用，包括类体内部、该类的子类和类实例的对象

• protected（受保护）表示可以在类中或该类的子类中被调用

• private（私有）表示只能在类中被调用

案例：

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }
    // 声明一个公有的方法
    public function MyPublic() { }
    // 声明一个受保护的方法
    protected function MyProtected() { }
    // 声明一个私有的方法
    private function MyPrivate() { }
    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass; //实例化对象MyClass,后面就可以调用
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行

?>

类常量

• 可以把在类中始终保持不变的值定义为常量。

• 不需要使用 $ 符号，使用const关键词

• 常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用

• 自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字（如 self，parent 或 static）。

案例：

<?php
class MyLei
{
    const constant = 'constant value';

    function showaction() {
        echo  self::constant;
    }
}
echo MyLei::constant;
$classname = "MyLei";
echo $classname::constant; // 自 5.3.0 起

$class = new MyLei();
$class->showaction();

echo $class::constant; // 自 PHP 5.3.0 起

?>

在类体内部调用staitc方法，使用self关键词加“::”调用,类外直接使用类名加“::”引用,调用父类使用parent加“::”

类属性

类的变量成员叫做“属性”，类的变量使用 var 来声明（使用public等来声明则不需要var）, 用 ->（对象运算符）访问,方法也是。

案例：

<?php
class MyClass
{
   // 错误的属性声明
   //public $var1 = 'hello ' . 'world';
   //public $var2 = 1+2;
   //public $var3 = self::myStaticMethod();
   //public $var4 = $myVar;

   // 正确的属性声明
   public $var5 = "myConstant";
   var $var6 = array(true, false);
   function funn(){
      echo $this->var5; //$this用来表示类内部的属性和方法的代号
   }
}
$v=new MyClass();
print_r($v->var5);   //输出myConstant
print_r($v->funn()); //输出myConstant
?>

PHP 构造函数和析构函数

构造函数和析构函数都是特别方法，定义在类中，在构造函数每次创建新对象时先自动调用此方法，析构函数当对象结束其生命周期时自动调用。

构造函数语法：

析构函数语法：

案例：

<?php

class noeClass {
   function __construct() {
       print "自动调用，";
   }
   function __destruct() {
       print "自动销毁";
   }
}

$a= new noeClass;
?>

结果：

自动调用，自动销毁

PHP继承类

使用关键字 extends 来继承一个类。子类就会继承父类所有公有的和受保护的方法。可以理解为对类的扩展。

语法：

案例：

<?php

class noeClass {
   function fangfa() {
       print "父类方法";
   }
}
class twoClass extends noeClass{
   function diaoyong() {
       print "子类调用";
	   $this->fangfa();
   }
}

$a= new twoClass;
$a->diaoyong();//输出 子类调用父类方法

?>

PHP方法重载

方法重载是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同，PHP不支持重载，但是可以利用灵活性模拟JAVA的重载，PHP所提供的"重载"（overloading）是指动态地"创建"类属性和方法。

案例：

function overloadTest()
{
    $name = "overload" . func_num_args();//返回输入的元素数目 
    $name();
}
function overload0()
{
    echo 'overload0';
}
function overload1()
{
    echo 'overload1';
}
function overload2()
{
    echo 'overload2';
}
overloadTest(); //overload0
overloadTest(1); //overload1
overloadTest(1,1); //overload2

PHP方法重写

方法重写是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型。

案例：

class fu
{
    public function xie(){
        echo '父类';
    }
}
class erzi extends fu{
    public function xie()
    {
        echo '儿子';//重写xie

    }
}
$erzi = new erzi();
$erzi->xie(); //结果：儿子

Final 关键字

如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

案例：

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called";
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called" ;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called";
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

Static 关键字

• 声明类属性或方法为静态，就可以不实例化类而直接使用，类名加“::”访问。

• 自 PHP 5.3.0 起，可以用一个变量来动态调用类。

• 伪变量 $this 在静态方法中不可用

案例：

<?php
class cla {
  public static $Mystatic = 'fun'; //static声明类属性
  
  public function staticfun() {
     return self::$Mystatic;      //$this关键字不可用
  }
}

print cla::$Mystatic;  //直接调用类中属性
$cla = new cla();

print $cla->staticfun();
?>

结果：

cla

cla

抽象类

抽象类就是为了共用的，是为了自己或者别人以后扩展方便，比如硬盘与文件夹，抽象类相当于硬盘（相同特征的规定这样做），文件夹代表方法，如果是一个公司公用电脑，定义一个抽象类就是一个硬盘D是要规定放公司相关文件的，而且至少要有两个文件夹，一个放文本文件起名“工作文件(工号1)”的，一个放图片起名“工作图片（工号1）”，文件夹名字要相同，工号（参数）可变，可多建文件但不能少建立（否则不能添加，抽象类特点报错）。

• 抽象类，类似与（类的模版）,比如框架系统的底层设置；

• 如果一个类包含了一个抽象方法，那么该类也必须是抽象类；

• 继承抽象类的任何子类必须重写抽象方法，除非子类本身也是抽象类；

• 抽象类不能产生对象，它只能充当父类;

• 抽象类不一定有抽象方法，再抽象类也可以有普通方法；

• 抽象类除了类有abstract修饰符，它内部跟普通类一样；

案例：

<?php
abstract class CXLClass
{
   // 强制要求子类定义这些方法
   abstract protected function myfile();
   abstract protected function myphoto($parameter);

   // 普通方法（非抽象方法)
    public function myfile2() {
        print $this->myfile();
    }
}

class ZCXLClass extends CXLClass
{
    public function myfile() {
        return "工作文件";
   }
   public function myphoto($parameter) {
       return "工作图片{$parameter}";
    }
}

$ZCXLClass = new ZCXLClass;
echo $ZCXLClass->myfile();
echo $ZCXLClass->myphoto('工号1') ;
?>

结果：

工作文件

工作图片工号1

php接口

接口就是不同设备的通信，比如网站数据和手机app的数据共享互相传递。

• 使用interface关键词定义接口，并且定义方法，方法内容为空；

• 使用implements关键字实现接口，必须使用和接口中所定义的方法数量和名称完全一致；

• 一个类可以继承多个接口；

• 接口中不可以声明成员变量（包括类静态变量），但是可以声明类常量；

• 接口没有构造函数；

• 接口中的方法默认都是public类型的；

案例：

<?php

// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}

// 实现接口
// 下面的写法是正确的
class Template implements iTemplate
{
    private $vars = array();
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
        return $template;
    }
}

// 下面的写法是错误的，会报错，因为没有实现 getHtml()：
//class BadTemplate implements iTemplate
//{
//    private $vars = array();
//  
//    public function setVariable($name, $var)
//    {
//        $this->vars[$name] = $var;
//    }
//}

?>