面向对象,PHP面向对象

By admin in 4858.com on 2019年3月1日
  1. 指标中的属性可能函数是 private 大概是
    protect的时候,当实例化那个指标的时候,外部是不可能访问到那脾气情和函数的。

PHP数组

  • 索引数组,数组的键是整数的数组,并且键的整数顺序是从0开头

$arr = array("apple","orange","pear");
print_r($arr);//输出数组建及对应的值

结果为:

Array
(
    [0] => apple
    [1] => orange
    [2] => pear
)
  • 论及数组,数组的键是字符串的数组

$arr = array('apple'=>"苹果",'orange'=>"橘子",'pear'=>"梨子");
print_r($arr);

结果为:

Array
(
    [apple] => 苹果
    [orange] => 橘子
    [pear] => 梨子
)

 
PHP面向对象                                               
  

在面向对象的次序设计(匈牙利(Hungary)语:Object-oriented
programming,缩写:OOP)中,对象是多少个由消息及对音信进行拍卖的叙说所结合的完全,是对现实世界的架空。

4858.com 14858.com 2

面向对象,PHP面向对象。成立数组

  • 使用array()函数

$fruits = array('apple','orange');
  • 直白对数组变量赋值

$fruits[]='pear';

假设方括号中并未点名索引,则取当前最大整数索引值+1。假若当前还从未整数索引,则键宿将为0。倘使钦赐的键名已经有值了,该值将被掩盖

  • 使用range()开创钦点范围单元的数组

$num = range(1,10);

      面向对象编制程序(Object Oriented
Programming, OOP, 面向对象程序设计):

在切实可行世界里我们所面对的业务都以指标,如总计机、TV、自行车等。

 <?php
  class TestClass
  {
      //private $name;
      public $name;
      public static $staticName;
      protected function getName()
      {   
          return $this->name;
      }   

      protected static function getStaticName()
      //public static function getStaticName()
      {   
          return self::$staticName;
      }   

  }

  $test = new TestClass();
  //$getName = $test->getName();
  $getStaticName = TestClass::getStaticName();
  var_dump(1111, $getStaticName);exit;

  ?>

PHP函数

  1. 定义
    • 利用首要字function开始
    • function前面跟函数名
    • 大括号中编写函数体

function say{
    echo "hello world"
}
  1. 调用:函数名加参数
  2. 判定函数是还是不是留存
    function_exists("fn")认清函数fn是或不是留存

     
是一种计算机编制程序架构,OOP的一条主干规则是电脑程序是由单个能够起到子程序效率的单元或对象组合而成,OOP达到了软件工程的七个目的:重用性、灵活性和扩大性。为了落到实处完整运算,每一个对象都能够收到新闻、处理数量和向此外对象发送音信。

对象的重中之重八本性状:

View Code

PHP类与面向对象

类是充饥画饼的概念,对象是切实可行的实例。类经过首要字class概念,通过重庆大学字new来制造1个实例,通过->做客对象的性子和格局

//定义一个类
class Car {
//属性
    public $name  = "汽车";
    //方法
    public function getName(){
        //方法内部可以使用$this调用对象的方法和属性
        return $this->name;
    }

}
//创建一个对象
$car = new Car();

属性(方法)注脚是由重点字publicprotectedprivate开头

  • public 公有(默认)
  • protected 受珍贵的
  • private 私有的

受保险的习性(方法)和村办的性情(方法)不允许外部调用,在类的分子方法内部能够调用

       对象的概念:

  • 目的的表现:可以对 对象施加那个操作,开灯,关灯便是作为。
  • 对象的造型:当施加那么些方法是目的怎么着响应,颜色,尺寸,外型。
  • 目的的代表:对象的代表就一定于身份证,具体区分在相同的行为与气象下有啥两样。

 

构造函数和析构函数

  • 构造函数
    PHP5能够在类中动用__construct()概念1个构造函数,构造函数会在指标创造时候调用,常用来对象成立时的初步化学工业作。

class Car{
    function __construct(){
        ...
    }
}
$car = new Car();//实例化会调用__construct

子类中定义了__construct则不会调用父类的__construct,要是急需调用父类的构造函数,须求使用parent::__construct()来得调用

  • 析构函数
    PHP5中使用_destruct(),定义,析构函数指的是当有些对象的拥有引用被删除,或然指标被出示的灭绝时会执行的函数。

class Car{
    function __destruct(){
        ...
    }
}
$car = new Car();
unset($car);//销毁时调用析构函数

     
对象是系统中用来叙述客观事物的3个实体,它是构成系统的叁当中坚单位。三个对象由一组属性和对那组属性进行操作的一组服务组合。从更抽象
的角度来说,对象是难点域或落到实处域中某个事物的3个华而不实,它体现该事物在系统中须要保留的音讯和表述的功力;它是一组属性和有权对这几个属性进行操作的一组
服务的封装体。客观世界是由对象和对象时期的维系组成的。

例如 Animal(动物)
是一个抽象类,大家得以具体到1只狗跟3只羊,而狗跟羊就是现实的靶子,他们有颜色属性,可以写,能够跑等行为情形。

Static静态关键字

静态属性和措施能够在不实例化类的情状下调用,间接行使类名::方法名的法门调用,静态属性不容许对象使用->操作符调用

class Car {
    static $speed = 10;
}
echo Car::$speed;

静态方法中不容许使用$this伪变量。能够利用selfparent在其间调用静态方法与天性

      类的概念:

4858.com 3

访问控制

访问控制通过publicprotectedprivate驷不及舌字来贯彻。公有的类成员可以在另各州方被访问,受保障的类成员能够被其本人以及其子类和父类访问,私有的类成员只可以被其定义所在的类访问。
类属性必须定义为公有、受保护、私有之一。

calss Car{
    $speed = 10;//错误,属性必须定义访问控制
    public $name;  //定义公有属性
}

类的措施若是没有安装那个主要字,默许公有
假如构造函数定义成了个人方法,则不容许直接实例化对象,能够经过静态方法实例化对象

class Car{
    private function __construct(){
        ...
    }
    private static $_obj = null;
    public static function getInstance(){
        if(empty(self::$_obj))){
            self::$_obj = new Car();
        }
        return self::$_obj;
    }
}
//$car = new Car()//不允许直接实例化
$car = Car::getInstance(); //通过静态方法获得一个实例

     
类是颇具同样属性和劳务的一组对象的联谊。它为属于此类的拥有目标提供了合并的架空描述,其里面包含属性和服务多少个主要部分。在面向对象的编制程序语言中,类是3个单独的顺序单位,它应当有二个类名并包罗属性表明和服务表明八个重庆大学多数。

面向对象内容

  •  −
    定义了一件东西的画饼充饥特点。类的定义包涵了数量的样式以及对数码的操作。

  • 对象 − 是类的实例。

  • 成员变量 −
    定义在类内部的变量。该变量的值对外是不可知的,可是足以经过分子函数访问,在类被实例化为指标后,该变量即可称为对象的习性。

  • 分子函数 − 定义在类的个中,可用来访问对象的数码。

  • 继承 −
    继承性是子类自动共享父类数据结构和措施的编写制定,那是类之间的一种关系。在概念和落实3个类的时候,能够在1个已经存在的类的功底之上来举行,把这一个曾经存在的类所定义的始末作为团结的内容,并投入若干新的内容。

  • 父类 − 叁个类被其余类继承,可将此类称为父类,或基类,或超类。

  • 子类 − 一个类继承其余类称为子类,也可称为派生类。

  • 多态 −
    多态性是指同一的操作或函数、进程可效果于七种类型的靶子上并拿走差异的结果。不一致的对象,收到一模一样音信能够生出不相同的结果,那种气象叫做多态性。

  • 重载 −
    简单说,正是函数可能措施有一致的名目,不过参数列表不平等的情景,那样的同名区别参数的函数只怕措施之间,相互称之为重载函数或许措施。

  • 抽象性 −
    抽象性是指将全数同样的数据结构(属性)和表现(操作)的靶子抽象成类。1个类就是那样一种浮泛,它显示了与应用有关的要紧性质,而忽视任何部分毫不相干内容。任何类的细分都以莫明其妙的,但不能够不与具象的施用有关。

  • 封装 −
    封装是指将具体世界中存在的某部客体的质量与行为绑定在共同,并放置在1个逻辑单元内。

  • 构造函数 − 主要用于在创制对象时开首化对象,
    即为对象成员变量赋初阶值,总与new运算符一起行使在成立对象的言语中。

  • 析构函数 − 析构函数(destructor)
    与构造函数相反,当对象甘休其生命周期时(例如对象所在的函数已调用达成),系统自动执行析构函数。析构函数往往用来做”清理善后”
    的办事(例如在创立指标时用new开辟了一片内存空间,应在剥离前在析构函数中用delete释放)。

下图中大家经过 Car 类 创制了多个对象:Mercedes, Bmw, 和 奥迪(Audi)。

$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car ();

4858.com 4

对象继承

使用extends贯彻类的持续,共享属性和章程

class Truck extends Car{
    ...
}
//定义继承于Car的Truck类

     怎么着抽出3个类:

PHP 类定义

PHP 定义类经常语法格式如下:

<?php
class phpClass {
  var $var1;
  var $var2 = "constant string";

  function myfunc ($arg1, $arg2) {
     [..]
  }
  [..]
}
?>

分析如下:

  • 类使用 class 关键字后加上类名定义。

  • 类名后的一对大括号({})内得以定义变量和艺术。

  • 类的变量使用 var 来申明, 变量也足以早先化值。

  • 函数定义类似 PHP
    函数的概念,但函数只可以通过此类及实际例化的靶子访问。

PHP对象的重载

重载指的是动态的创建属性和办法。
天性是经过魔术点子来促成。__set__get__isset__unset各自完成对不存在的性情的赋值,读取,判断属性是还是不是设置,销毁属性。

class Car {
    private $ary = array();

    public function __set($key, $val) {
        $this->ary[$key] = $val;
    }

    public function __get($key) {
        if (isset($this->ary[$key])) {
            return $this->ary[$key];
        }
        return null;
    }

    public function __isset($key) {
        if (isset($this->ary[$key])) {
            return true;
        }
        return false;
    }

    public function __unset($key) {
        unset($this->ary[$key]);
    }
}
$car = new Car();
$car->name = '汽车';  //name属性动态创建并赋值
echo $car->name;

措施的重载通过__call来落到实处,当调用不存在的主意的时候,将会转为参数调用__call措施,当调用不设有的静态方法时会使用__callStatic重载

class Car {
    public $speed = 0;

    public function __call($name, $args) {
        if ($name == 'speedUp') {
            $this->speed += 10;
        }
    }
}
$car = new Car();
$car->speedUp(); //调用不存在的方法会使用重载
echo $car->speed;
class 类名
{
}

实例

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;

  /* 成员函数 */
  function setUrl($par){
     $this->url = $par;
  }

  function getUrl(){
     echo $this->url . PHP_EOL;
  }

  function setTitle($par){
     $this->title = $par;
  }

  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}
?>

变量 $this 代表作者的对象。

PHP_EOL 为换行符。


 例子:

PHP 中创设对象

类创制后,我们能够使用 new 运算符来实例化该类的对象:

$runoob = new Site;
$taobao = new Site;
$google = new Site;

以上代码我们成立了五个对象,八个对象分别都以单身的,接下去大家来探望怎样访问成员方法与成员变量。

class 人
{
    成员属性:姓名、性别、年龄、身高、体重、电话、家庭住址
    成员方法:可以开车, 会说英语, 可以使用电脑
}

调用成员方法

在实例化对象后,大家得以行使该对象调用成员方法,该对象的分子方法只能操作该指标的分子变量:

// 调用成员函数,设置标题和URL
$runoob->setTitle( "菜鸟教程" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );

$runoob->setUrl( 'www.runoob.com' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

// 调用成员函数,获取标题和URL
$runoob->getTitle();
$taobao->getTitle();
$google->getTitle();

$runoob->getUrl();
$taobao->getUrl();
$google->getUrl();

完整代码如下:

<?php 
class Site { 
  /* 成员变量 */ 
  var $url; 
  var $title; 

  /* 成员函数 */ 
  function setUrl($par){ 
     $this->url = $par; 
  } 

  function getUrl(){ 
     echo $this->url . PHP_EOL; 
  } 

  function setTitle($par){ 
     $this->title = $par; 
  } 

  function getTitle(){ 
     echo $this->title . PHP_EOL; 
  } 
} 

$runoob = new Site; 
$taobao = new Site; 
$google = new Site; 

// 调用成员函数,设置标题和URL 
$runoob->setTitle( "菜鸟教程" ); 
$taobao->setTitle( "淘宝" ); 
$google->setTitle( "Google 搜索" ); 

$runoob->setUrl( 'www.runoob.com' ); 
$taobao->setUrl( 'www.taobao.com' ); 
$google->setUrl( 'www.google.com' ); 

// 调用成员函数,获取标题和URL 
$runoob->getTitle(); 
$taobao->getTitle(); 
$google->getTitle(); 

$runoob->getUrl(); 
$taobao->getUrl(); 
$google->getUrl(); 
?>

实践以上代码,输出结果为:

菜鸟教程
淘宝
Google 搜索
www.runoob.com
www.taobao.com
www.google.com

 

PHP 构造函数

构造函数 ,是一种非常的法门。首要用以在创立对象时开端化对象,
即为指标成员变量赋开头值,总与new运算符一起使用在创制对象的言语中。

PHP 5 允行开发者在2个类中定义一个格局作为构造函数,语法格式如下:

void __construct ([ mixed $args [, $... ]] )

在地点的例证中大家就能够由此构造方法来伊始化 $url 和 $title 变量:

function __construct( $par1, $par2 ) {
   $this->url = $par1;
   $this->title = $par2;
}

当今我们就不必要再调用 setTitle 和 setUrl 方法了:

$runoob = new Site('www.runoob.com', '菜鸟教程'); 
$taobao = new Site('www.taobao.com', '淘宝'); 
$google = new Site('www.google.com', 'Google 搜索'); 

// 调用成员函数,获取标题和URL 
$runoob->getTitle(); 
$taobao->getTitle(); 
$google->getTitle(); 

$runoob->getUrl(); 
$taobao->getUrl(); 
$google->getUrl();
class Person
{
    // 下面是人的成员属性
    var $name;  //人的名子
    var $sex;   //人的性别
    var $age;   //人的年龄

    // 下面是人的成员方法
    function FANGFA() 
    {
       return;
    }
}

析构函数

析构函数(destructor)
与构造函数相反,当目的结束其生命周期时(例如对象所在的函数已调用完成),系统活动执行析构函数。

PHP 5 引入了析构函数的概念,那类似于任何面向对象的语言,其语法格式如下:

void __destruct ( void )

 计算矩形面积:

实例

<?php
class MyDestructableClass {
   function __construct() {
       print "构造函数\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "销毁 " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

实践以上代码,输出结果为:

构造函数
销毁 MyDestructableClass
class 矩形
{
    // 矩形的属性
    矩形的长;
    矩形的宽;

    // 矩形的方法
    矩形的周长;
    矩形的面积;
}

继承

PHP 使用重要字 extends 来继承三个类,PHP 不帮忙多几次三番,格式如下:

class Child extends Parent {
   // 代码部分
}

 实例:

实例

实例中 Child_Site 类继承了 Site 类,并扩张了效益:

<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

    function setCate($par){
        $this->category = $par;
    }

    function getCate(){
        echo $this->category . PHP_EOL;
    }
}
class Rect
{
    var $kuan;
    var $gao;

    function zhouChang()
    {
        计算矩形的周长;
    }

    function mianJi()
    {
        计算矩形的面积;
    }
}

主意重写

固然从父类继承的主意无法满意子类的供给,能够对其实行改写,那个进度叫方法的掩盖(override),也号称方法的重写。

实例中重写了 getUrl 与 getTitle 方法:

function getUrl() {
   echo $this->url . PHP_EOL;
   return $this->url;
}

function getTitle(){
   echo $this->title . PHP_EOL;
   return $this->title;
}

  

访问控制

PHP 对品质或艺术的访问控制,是透过在前头添加关键字
public(公有),protected(受保证)或 private(私有)来落实的。

  • public(公有):国有的类成员能够在其余地点被访问。
  • protected(受保护):受保险的类成员则足以被其本身以及其子类和父类访问。
  • private(私有):民用的类成员则不得不被其定义所在的类访问。

 哪些实例化对象:  对象名称 = new
 类名称();

品质的访问控制

类属性必须定义为国有,受保险,私有之一。假如用 var 定义,则被视为公有。

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义,但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined

?>
class Person
{
    //下面是人的成员属性
    var $name; //人的名字
    var $sex; //人的性别
    var $age; //人的年龄

    //下面是人的成员方法
    function say() { //这个人可以说话的方法
        echo "这个人在说话";
    }

    function run() { //这个人可以走路的方法
        echo "这个人在走路";
    }
}

$p1=new Person();
$p2=new Person();
$p3=new Person();

方式的访问控制

类中的方法可以被定义为国有,私有或受保险。假诺没有安装这个关键字,则该方法暗中同意为国有。

<?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->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有,受保护,私有都可以执行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行,但私有的不行

class Bar 
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }

    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar 
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }

    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate 
                // Foo::testPublic
?>

 应用对象:

接口

运用接口(interface),能够内定有个别类必须完成如何措施,但不须求定义这几个方式的具体内容。

接口是经过 interface 关键字来定义的,就好像定义2个行业内部的类一样,但内部定义全数的艺术皆以空的。

接口中定义的装有办法都必须是国有,这是接口的表征。

要兑现多个接口,使用 implements 操作符。类中务必贯彻接口中定义的具备办法,不然会报1个沉重错误。类能够兑现七个接口,用逗号来分隔四个接口的称号。

<?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;
    }
}

   对象->属性         $p1->name; $p2->age; $p3->sex;

常量

可以把在类中始终维持不变的值定义为常量。在概念和接纳常量的时候不要求运用
$ 符号。

常量的值必须是多个定值,不可能是变量,类性质,数学生运动算的结果或函数调用。

自 PHP 5.3.0
起,能够用1个变量来动态调用类。但该变量的值不能够为根本字(如
self,parent 或 static)。

   对象->方法         $p1->say(); $p2->run(); 

实例

<?php
class MyClass
{
    const constant = '常量值';

    function showConstant() {
        echo  self::constant . PHP_EOL;
    }
}

echo MyClass::constant . PHP_EOL;

$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>

   

抽象类

其余二个类,借使它当中足足有一个主意是被声称为架空的,那么这几个类就无法不被声称为架空的。

概念为架空的类不可能被实例化。

被定义为架空的方法只是声称了其调用情势(参数),无法定义其具体的效劳达成。

继续2个抽象类的时候,子类必须定义父类中的全数抽象方法;其余,这几个主意的访问控制必须和父类中一致(恐怕更为宽松)。例如某些抽象方法被声称为受保证的,那么子类中落到实处的主意就相应评释为受保险的只怕国有的,而不能够定义为民用的。其余方法的调用格局必须合营,即类型和所需参数数量必须一致。例如,子类定义了2个可选参数,而父类抽象方法的注解里从未,则两者的宣示并无顶牛。

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法(非抽象方法)
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

施行以上代码,输出结果为:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
$p1->name = "张三"; //属性对象
$p1->sex = "男";
$p1->age = 20;

Static 关键字

宣示类属性或方法为 static(静态),就足以不实例化类而一向访问。

静态属性无法经过一个类已实例化的靶子来拜会(但静态方法可以)。

鉴于静态方法不须求经过对象即可调用,所以伪变量 $this
在静态方法中不可用。

静态属性不得以由对象通过 -> 操作符来访问。

自 PHP 5.3.0 起,能够用一个变量来动态调用类。但该变量的值不可能为主要字
self,parent 或 static。

<?php
class Foo {
  public static $my_static = 'foo';

  public function staticValue() {
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>    

推行以上程序,输出结果为:

foo
foo

  

Final 关键字

PHP 5 新增了多少个 final 关键字。假诺父类中的方法被声称为
final,则子类无法掩盖该模式。尽管一个类被声称为 final,则不能被两次三番。

以下代码执行会报错:

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

   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>
$p2->say();           //方法对象
$p2->run();

调用父类构造方法

PHP
不会在子类的构造方法中自行的调用父类的构造方法。要举办父类的构造方法,需求在子类的构造方法中调用 parent::__construct()

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

实施以上程序,输出结果为:

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法

 

  

this对象的行使:

在指标的中间,让对象里的方法访问本对象的属性,
或是对象中的方法去调用本对象的其余方法。

$this->属性: $this->name; $this->age; $this->sex;

$this->方法 :$this->say(); $this->run();

实例:

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;
    }
}

// 通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄
$p1 = new Person("张三", "男", 20);
$p2 = new Person("李四", "女", 30);
$p3 = new Person("王五", "男", 40);

// 下面访问$p1对象中的说话方法
$p1->say();

// 下面访问$p2对象中的说话方法
$p2->say();

// 下面访问$p3对象中的说话方法
$p3->say();

  

结果:

4858.com 5

 

 

 

 构造方法:

     
 当先四分之一类都有一种名叫构造函数的十分措施。当创造3个对象时,它将活动调用构造函数,也正是利用new那么些重中之重字来实例化对象的时候自动调用构造方法。构
造函数的证明与其他操作的声美素佳儿(Beingmate)样,只是其名称必须是__construct(
)。这是PHP5中的变化,从前的版本中,构造函数的称号必须与类名相同,那种在PHP5中依然能够用,但明天以经很少有人用了,那样做的利益是能够使构
造函数独立于类名,当类名爆发变更时不须要改相应的构造函数名称了。为了向下包容,如若一个类中向来不名为__construct(
)的方法,PHP将寻找2个php4中的写法,与类名相同名的构造方法。

 格式:function __construct ( [参数] )
{ … … }

function __construct($name, $sex, $age)
    {
        // 通过构造方法传进来的$name给成员属性$this->name赋初使值
        $this->name = $name;

        // 通过构造方法传进来的$sex给成员属性$this->sex赋初使值
        $this->sex = $sex;

        // 通过构造方法传进来的$age给成员属性$this->age赋初使值
        $this->age = $age;
    }

  

     

4858.com,析构函数:

与构造函数相对的正是析构函数。析构函数是PHP5新拉长的内容,在PHP4中没有析构函数。
析构函数允许在销毁2个类从前实施的部分操作或形成部分职能,比如说关闭文件,
释放结果集等,析构函数会在到有个别对象的装有引用都被去除或然当指标被显式销毁时实施,也正是指标在内部存款和储蓄器中被灭绝前调用析构函数。与构造函数的名目类似,
1个类的析构函数名称必须是__destruct( )。析构函数不可能带有其它参数。

格式:function __destruct ( ) { … …
}

// 这是一个析构函数,在对象销毁前调用
    function __destruct()
    {
        echo "再见" . $this->name;
    }

  

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有