php面向对象编程读书笔记一(hsg)

php面向对象编程读书笔记一(hsg)

资料来源:LAMP大讲堂
1.基本概念
1.1面向对象的概念
    面向对象编程（Object Oriented Programming, OOP, 面向对象程序设计）是一种计算机编程架构，OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成，OOP达到了软件工程的三个目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。面向对象一直是软件开发领域内比较热门的话题，首先，面向对象符合人类看待事物的一般规律。其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。为编程人员敞开了一扇大门，使其编程的代码更简洁、更易于维护，并且具有更强的可重用性。有人说PHP 不是一个真正的面向对象的语言，这是事实。PHP 是一个混合型语言，你可以使用OOP，也可以使用传统的过程化编程。然而，对于大型项目，你可能需要在PHP 中使用纯的OOP去声明类，而且在你的项目里只用对象和类。
1.2什么是类，什么是对象，类和对象之间的关系
    类的概念：类是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和服务两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性说明和服务说明两个主要部分。
    对象的概念：对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。从更抽象的角度来说，对象是问题域或实现域中某些事物的一个抽象，它反映该事物在系统中需要保存的信息和发挥的作用；它是一组属性和有权对这些属性进行操作的一组服务的封装体。客观世界是由对象和对象之间的联系组成的。
    类与对象的关系就如模具和铸件的关系，类的实例化结果就是对象，而对一类对象的抽象就是类。类描述了一组有相同特性（属性）和相同行为（方法）的对象。
1.3什么是面向对象编程
    就不说他的概念，如果你想建立一个电脑教室，首先要有一个房间， 房间里面要有N 台电脑，有N 张桌子， N 把椅子， 白板， 投影机等等，这些是什么，刚才咱们说了，这就是对象，能看到的一个个的实体，可以说这个电脑教室的单位就是这一个个的实体对象， 它们共同组成了这个电脑教室，那么我们是做程序，这和面向对象有什么关系呢？开发一个系统程序和建一个电脑教室类似，你把每个独立的功能模块抽象成类，形成对象，由多个对象组成这个系统，这些对象之间都能够接收信息、处理数据和向其它对象发送信息等等相互作用。就构成了面向对象的程序。
1.4如何抽象出一个类
    面向对象程序的单位就是对象，但对象又是通过类的实例化出来的，所以我们首先要做的就是如何来声明类，做出来一个类很容易，只要掌握基本的程序语法定义规则就可以做的出来，那么难点在那里呢？一个项目要用到多少个类，用多少个对象，在那要定义类，定义一个什么样的类，这个类实例化出多少个对象，类里面有多少个属性，有多少个方法等等,这就需要读者通过在实际的开发中就实际问题分析设计和总结了。
类的定义：
class 类名{
}
    使用一个关键字class 和后面加上一个你想要的类名以及加上一对大括号， 这样一个类的结构就定义出来了，只要在里面写代码就可以了，但是里面写什么？能写什么？怎样写才是一个完整的类呢？上面讲过来，使用类是为了让它实例出对象来给我们用，这就要知道你想要的是什么样的对象了，像上面我们讲的一个装机配置单上写什么，你装出来的机子就有什么。比如说，一个人就是一个对象，你怎么把一个你看好的人推荐给你们领导呢？当然是越详细越好了：
首先，你会介绍这个人姓名、性别、年龄、身高、体重、电话、家庭住址等等。
然后，你要介绍这个人能做什么，可以开车，会说英语，可以使用电脑等等。
只要你介绍多一点，别人对这个人就多一点了解，这就是我们对一个人的描述， 现在我们总结一下，所有的对象我们用类去描述都是类似的，从上面人的描述可以看到， 做出一个类来，从定义的角度分两部分，第一是从静态上描述，第二是从动态上描述， 静态上的描述就是我们所说的属性，像上面我们看到的，人的姓名、性别、年龄、身高、体重、电话、家庭住址等等。动态上也就是人的这个对象的功能，比如这个人可以开车，会说英语，可以使用电脑等等，抽象成程序时，我们把动态的写成函数或者说是方法，函数和方法是一样的。所以，所有类都是从属性和方法这两方面去写， 属性又叫做这个类的成员属性，方法叫做这个类的成员方法。
class 人{
   成员属性：姓名、性别、年龄、身高、体重、电话、家庭住址
   成员方法：可以开车， 会说英语， 可以使用电脑
}
属性：
    通过在类定义中使用关键字" var "来声明变量，即创建了类的属性,虽然在声明成员属性的时候可以给定初始值， 但是在声明类的时候给成员属性初始值是没有必要的，比如说要是把人的姓名赋上“张三”,那么用这个类实例出几十个人，这几十个人都叫张三了，所以没有必要， 我们在实例出对象后给成员属性初始值就可以了。如： var $somevar;
方法(成员函数)：
通过在类定义中声明函数，即创建了类的方法。
如： function somefun(参数列表)
{ ... ... }
<?php
class Person
{
    //下面是人的成员属性
    var $name; //人的名字
    var $sex; //人的性别
    var $age; //人的年龄
    //下面是人的成员方法
    function say() //这个人可以说话的方法
    {
       echo "这个人在说话";
   }
   function run() //这个人可以走路的方法
   {
      echo "这个人在走路";
   }
}
?>
上面就是一个类的声明，从属性和方法上声明出来的一个类，但是成员属性最好在声明的时候不要给初始的值，因为我们做的人这个类是一个描述信息，将来用它实例化对象，比如实例化出来10 个人对象，那么这10 个人， 每一个人的名字、性别、年龄都是不一样的，所以最好不要在这个地方给成员属性赋初值，而是对每个对象分别赋值的。用同样的办法可以做出你想要的类了，只要你能用属性和方法能描述出来的实体都可以定义成类，去实例化对象。为了加强你对类的理解，我们再做一个类，做一个形状的类，形状的范围广了点， 我们就做个矩形吧，先分析一下，想一想从两方面分析，矩形的属性都有什么？矩形的功能都有什么？
class 矩形
{
     //矩形的属性
     矩形的长；
     矩形的宽；
     //矩形的方法
     矩形的周长；
     矩形的面积；
}
<?php
class Rect
{
    var $kuan;
    var $gao;
    function zhouChang()
    {
       计算矩形的周长；
    }
    function mianJi()
    {
       计算矩形的面积；
    }
}
?>
如果用这个类来创建出多个矩形对象，每个矩形对象都有自己的长和宽， 都可以求出自己的周长和面积了。
类的声明我们就到这里吧！！

1.5如何实例化对象
当定义好类后，我们使用new 关键字来生成一个对象。
$对象名称= new 类名称（）；
<?php
class Person
{
     //下面是人的成员属性
     var $name; //人的名字
     var $sex; //人的性别
     var $age; //人的年龄
     //下面是人的成员方法
     function say() //这个人可以说话的方法
     {
         echo "这个人在说话";
     }
     function run() //这个人可以走路的方法
     {
         echo "这个人在走路";
     }
}
$p1=new Person();
$p2=new Person();
$p3=new Person();
?>

1.6如何去使用对象中的成员
    上面看到PHP 对象中的成员有两种一种是成员属性，一种是成员方法。对象我们以经可以声明了，$p1=new Person();怎么去使用对象的成员呢？要想访问对象中的成员就要使用一个特殊的操作符“->”来完成对象成员的访问：
对象->属性$p1->name; $p2->age; $p3->sex;
对象->方法$p1->say(); $p2->run();
如下面实例:
<?php
class Person
{
    //下面是人的成员属性
    var $name; //人的名字
    var $sex; //人的性别
    var $age; //人的年龄
    //下面是人的成员方法
    function say() //这个人可以说话的方法
    {
        echo "这个人在说话";
    }
    function run() //这个人可以走路的方法
    {
        echo "这个人在走路";
    }
}
$p1=new Person(); //创建实例对象$p1
$p2=new Person(); //创建实例对象$p2
$p3=new Person(); //创建实例对象$p3
//下面三行是给$p1对象属性赋值
$p1->name=”张三”;
$p1->sex=”男”;
$p1->age=20;
//下面三行是访问$p1对象的属性
echo “p1对象的名字是：”.$p1->name.”<br>”;
echo “p1对象的性别是：”.$p1->sex.”<br>”;
echo “p1对象的年龄是：”.$p1->age.”<br>”;
//下面两行访问$p1对象中的方法
$p1->say();
$p1->run();
//下面三行是给$p2对象属性赋值
$p2->name=”李四”;
$p2->sex=”女”;
$p2->age=30;
//下面三行是访问$p2对象的属性
echo “p2对象的名字是：”.$p2->name.”<br>”;
echo “p2对象的性别是：”.$p2->sex.”<br>”;
echo “p2对象的年龄是：”.$p2->age.”<br>”;
//下面两行访问$p2对象中的方法
$p2->say();
$p2->run();
//下面三行是给$p3对象属性赋值
$p3->name=”王五”;
$p3->sex=”男”;
$p3->age=40;
//下面三行是访问$p3对象的属性
echo “p3对象的名字是：”.$p3->name.”<br>”;
echo “p3对象的性别是：”.$p3->sex.”<br>”;
echo “p3对象的年龄是：”.$p3->age.”<br>”;
//下面两行访问$p3对象中的方法
$p3->say();
$p3->run();
?>
    从上例中可以看出只是对象里面的成员就要使用对象->属性、对象->方法形式访问，再没有第二种方法来访问对象中的成员了。
1.7特殊的引用“$this”的使用
    以在PHP 里面给我提供了一个本对象的引用$this，每个对象里面都有一个对象的引用$this 来代表这个对象，完成对象内部成员的调用, this 的本意就是“这个”的意思，上面的实例里面，我们实例化三个实例对象$P1、$P2、$P3，这三个对象里面各自存在一个$this 分别代表对象$p1、$p2、$p3 ，$this 就是对象内部代表这个对象的引用，在对象内部和调用本对象的成员和对象外部调用对象的成员所使用的方式是一样的。
$this->属性   $this->name; $this->age; $this->sex;
$this->方法   $this->say(); $this->run();
<?php
class Person
{
    //下面是人的成员属性
    var $name; //人的名字
    var $sex; //人的性别
    var $age; //人的年龄
    //下面是人的成员方法
    function say() //这个人可以说话的方法
    {
       echo "我的名字叫：".$this->name." 性别：".$this->sex." 我的年龄是：
       ".$this->age."<br>";
    }
    function run() //这个人可以走路的方法
    {
       echo "这个人在走路";
    }
}
$p1=new Person(); //创建实例对象$p1
$p2=new Person(); //创建实例对象$p2
$p3=new Person(); //创建实例对象$p3
//下面三行是给$p1对象属性赋值
$p1->name="张三";
$p1->sex="男";
$p1->age=20;
//下面访问$p1对象中的说话方法
$p1->say();
//下面三行是给$p2对象属性赋值
$p2->name="李四";
$p2->sex="女";
$p2->age=30;
//下面访问$p2对象中的说话方法
$p2->say();
//下面三行是给$p3对象属性赋值
$p3->name="王五";
$p3->sex="男";
$p3->age=40;
//下面访问$p3对象中的说话方法
$p3->say();
?>
输出结果为：
我的名字叫：张三 性别：男 我的年龄是：20
我的名字叫：李四 性别：女 我的年龄是：30
我的名字叫：王五 性别：男 我的年龄是：40
1.8构造方法与析构方法
    大多数类都有一种称为构造函数的特殊方法。当创建一个对象时，它将自动调用构造函数，也就是使用new 这个关键字来实例化对象的时候自动调用构造方法。构造函数的声明与其它操作的声明一样，只是其名称必须是__construct( )。这是PHP5 中的变化，以前的版本中，构造函数的名称必须与类名相同，这种在PHP5 中仍然可以用，但现在以经很少有人用了，这样做的好处是可以使构造函数独立于类名，当类名发生改变时不需要改相应的构造函数名称了。为了向下兼容，如果一个类中没有名为__construct( )的方法，PHP 将搜索一个php4 中的写
法,与类名相同名的构造方法。
格式：function __construct ( [参数] ) { ... ... }
<?
//创建一个人类
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 __destruct()
    {
        echo “再见”.$this->name.”<br>”;
    }
}
//通过构造方法创建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();
?>
输出结果为：
我的名字叫：张三性别：男我的年龄是：20
我的名字叫：李四性别：女我的年龄是：30
我的名字叫：王五性别：男我的年龄是：40
1.9封装性
    封装性是面向对象编程中的三大特性之一，封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义:
   1.把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位   （即对象）。
   2.信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外部发生联系。封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的"交叉感染"，使软件错误能够局部化，大大减少查错和排错的难度。
     使用private 这个关键字来对属性和方法进行封装：
原来的成员:
var $name; //声明人的姓名
var $sex; //声明人的性别
var $age; //声明人的年龄
function run(){… … .}
改成封装的形式：
private $name; //把人的姓名使用private 关键字进行封装
private $sex; //把人的性别使用private 关键字进行封装
private $age; //把人的年龄使用private 关键字进行封装
private function run(){… … } //把人的走路方法使用private 关键字进行封装
注意：只要是成员属性前面有其它的关键字就要去掉原有的关键字“var”。
通过private 就可以把人的成员（成员属性和成员方法）封装上了。封装上的成员就不能被类外面直接访问了，只有对象内部自己可以访问；
    因为构造方法是默认的公有方法（构造方法不要设置成私有的），所以在类的外面可以访问到，这样就可以使用构造方法创建对象， 另外构造方法也是类里面的函数，所以可以用构造方法给私有的属性赋初值。Say()的方法是默认公有的， 所以在外面也可以访问的到， 说出他自己的私有属性。

1.10 __set() __get() __isset() __unset()四个方法的应用
    一般来说，总是把类的属性定义为private，这更符合现实的逻辑。但是，对属性的读取和赋值操作是非常频繁的，因此在PHP5 中，预定义了两个函数“__get()”和“__set()”来获取和赋值其属性,以及检查属性的“__isset()”和删除属性的方法“__unset()”
    在PHP5 中给我们提供了专门为属性设置值和获取值的方法，“__set()”和“__get()”这两个方法，这两个方法不是默认存在的，而是我们手工添加到类里面去的，像构造方法(__construct())一样, 类里面添加了才会存在，可以按下面的方式来添加这两个方法，当然也可以按个人的风格来添加
<?php
class Person
{
    //下面是人的成员属性， 都是封装的私有成员
    private $name; //人的名字
    private $sex; //人的性别
    private $age; //人的年龄
    //__get()方法用来获取私有属性
    private function __get($property_name)
    {
       echo "在直接获取私有属性值的时候，自动调用了这个__get()方法<br>";
       if(isset($this->$property_name))
       {
          return($this->$property_name);
       }
       else
       {
          return(NULL);
       }
   }//__set()方法用来设置私有属性
   private function __set($property_name, $value)
   {
          echo "在直接设置私有属性值的时候，自动调用了这个__set()方法为私有属  性赋值<br>";
          $this->$property_name = $value;
   }
   private function __isset($nm)
   {
       echo "当在类外部使用isset()函数测定私有成员$nm时，自动调用<br>";
       return isset($this->$nm);
   }
   private function __unset($nm)
   {
      echo "当在类外部使用unset()函数来删除私有成员时自动调用的<br>";
      unset($this->$nm);
  }
}
$p1=new Person();
//直接为私有属性赋值的操作， 会自动调用__set()方法进行赋值
$p1->name="张三";
$p1->sex="男";
$p1->age=20;
//直接获取私有属性的值， 会自动调用__get()方法，返回成员属性的值
echo "姓名：".$p1->name."<br>";
echo "性别：".$p1->sex."<br>";
echo "年龄：".$p1->age."<br>";
//在使用isset()函数测定私有成员时，自动调用__isset()方法帮我们完成，返回结果为true
echo var_dump(isset($p1->name))."<br>";
echo $p1->name."<br>";
//在使用unset()函数删除私有成员时，自动调用__unset()方法帮我们完成，删除name私有属性
unset($p1->name);
//已经被删除了， 所这行不会有输出
echo $p1->name;
?>
1.11 类的继承
    继承是PHP5 面向对象程序设计的重要特性之一，它是指建立一个新的派生类，从一个或多个先前定义的类中继承数据和函数，而且可以重新定义或加进新
数据和函数，从而建立了类的层次或等级。说的简单点就是，继承性是子类自动共享父类的数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
    通过继承机制，可以利用已有的数据类型来定义新的数据类型。所定义的新的数据类型不仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类以及超类。由已存在的类派生出的新类称为派生类，又称为子类。在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。
    在C++语言中，一个派生类可以从一个基类派生，也可以从多个基类派生。从一个基类派生的继承称为单继承；从多个基类派生的继承称为多继承。
    但是在PHP 和Java,C#语言里面没有多继承，只有单继承，也就是说，一个类只能直接从一个类中继承数据，这就是我们所说的单继承。
//定义一个子类“学生类“使用”extends”关键字来继承”人”类
class Student extends Person
{
    var $school; //学生所在学校的属性
    //这个学生学习的方法
    function study()
    {
       echo "我的名字叫：".$this->name." 我正在”.$this->school.”学习<br>";
    }
}
    通过上面“Student”类的定义，Student 类通过使用“extends”这个关键字把Person 类里的所有成员属性和成员方法都继承过来了，并扩展了一个所在学校成员属性“school”，和一个学习方法“study()”。现在子类“Student”里面和使用这个类实例出来的对象都具有如下的属性和方法：
学生类“Student”里面的成员属性有：
    姓名：name;
    年龄：age;
    性别：sex;
    学校：school;
学生类“Student”里面的成员方法有：
    说话方法：say();
    学习方法：study();
通过上面类继承的使用简化了对象、类的创建工作量，增加了代码的可重性。

1.12 重载新的方法
     在学习PHP 这种语言中你会发现，PHP 中的方法是不能重载的，所谓的方法重载就是定义相同的方法名，通过“参数的个数”不同或“参数的类型”不同，来访问我们的相同方法名的不同方法。但是因为PHP 是弱类型的语言，所以在方法的参数中本身就可以接收不同类型的数据，又因为PHP的方法可以接收不定个数的参数，所以通过传递不同个数的参数调用不相同方法名的不同方法也是不成立的。所以在PHP 里面没有方法重载。不能重载也就是在你的项目中不能定义相同方法名的方法。另外，因为PHP 没有名字空间的概念，在同一个页面和被包含的页面中不能定义相同名称的方法，也不能定义和PHP 给我提供的方法重名，当然在同一个类中也不能定义相同名称的方法。
     我们这里所指的重载新的方法所指的是什么呢？其实我们所说的重载新的方法就是子类覆盖父类的已有的方法，那为什么要这么做呢？父类的方法不是可以继承过来直接用吗？但有一些情况是我们必须要覆盖的，比如说我们前面提到过的例子里面，“Person”这个人类里面有一个“说话”的方法，所有继承“Person”类的子类都是可以“说话”的， 我们“Student”类就是“Person”类的子类，所以“Student”的实例就可以“说话”了，但是人类里面“说话”的方法里面说出的是“Person”类里面的属性，而“Student”类对“Person”类进行了扩展，又扩展出了几个新的属性，如果使用继承过来的“say()”说话方法的话，只能说出从“Person”类继承过来的那些属性，那么新扩展的那些属性使用这个继承过来的“say()”的方法就说不出来了，那有的人就问了，我在“Student”这个子类中再定义一个新的方法用于说话，说出子类里面所有的属性不就行了吗？一定不要这么做，从抽象的角度来讲， 一个“学生”不能有两种“说话”的方法，就算你定义了两个不同的说话的方法，可以实现你想要的功能，被继承过来的那个“说话”方法可能没有机会用到了，而且是继承过来的你也删不掉。这个时候我们就要用到覆盖了。虽然说在PHP 里面不能定义同名的方法， 但是在父子关系的两个类中，我们可以在子类中定义和父类同名的方法，这样就把父类中继承过来的方法覆盖掉了。
class Student extends Person
{
    var $school; //学生所在学校的属性
    //这个学生学习的方法
    function study()
    {
       echo "我的名字叫：".$this->name." 我正在”.$this->school.”学习<br>";
    }
    //这个学性可以说话的方法， 说出自己所有的属性，覆盖了父类的同名方法
    //重写基类的say()方法
    function say()
    {
       echo "我的名字叫：".$this->name." 性别：".$this->sex." 我的年龄是：        ".$this->age."我在".$this->school."上学.<br>";
    }
}
可以通过两种方法实现在子类的方法中调用父类被覆盖的方法：
一种是使用父类的“类名：：”来调用父类中被覆盖的方法；
一种是使用“parent：：”的方试来调用父类中被覆盖的方法；
<?php
class Student extends Person
{
    var $school; //学生所在学校的属性
    //这个学生学习的方法
    function study()
    {
       echo "我的名字叫：".$this->name." 我正在”.$this->school.”学习<br>";
    }
    //这个学性可以说话的方法， 说出自己所有的属性，覆盖了父类的同名方法
    function say()
    {
       //使用父类的“类名：：“来调用父类中被覆盖的方法；
       // Person::say();
       //或者使用“parent：：”的方试来调用父类中被覆盖的方法；
       parent::say();
       //加上一点自己的功能
       echo “我的年龄是：".$this->age."我在".$this->school."上学.<br>";
    }
}
?>
1.13 访问类型
    类型的访问修饰符允许开发人员对类成员的访问进行限制，这是PHP5 的新特性，但却是OOP语言的一个好的特性。而且大多数OOP 语言都已支持此特性。PHP5 支持如下3 种访问修饰符：
public(公有的、默认的)，
private(私有的) 
protected(受保护的)三种。
//
public 公有修饰符，类中的成员将没有访问限制，所有的外部成员都可以访问（读和写）这个类成员(包括成员属性和成员方法)，在PHP5 之前的所有版本中，PHP 中类的成员都是public 的，而且在PHP5 中如果类的成员没有指定成员访问修饰符，将被视为public 。
    例：public $name;
        public function say(){};
private 私有修改符，被定义为private 的成员，对于同一个类里的所有成员是可见的，即是没有访问限制；但对于该类的外部代码是不允许改变甚至读操作，对于该类的子类，也不能访问
private 修饰的成员。
    例: private $var1 = ‘A’; //属性
        private function getValue(){} //函数
protected 保护成员修饰符，被修饰为protected 的成员不能被该类的外部代码访问。但是对于该类的子类有访问权限，可以进行属性、方法的读及写操作，该子类的外部代码包括其的子类都不具有访问其属性和方法的权限。
    例：protected $name;
        protected function say(){};

1.14 final 关键字的应用
     这个关键字只能用来定义类和定义方法，不能使用final 这个关键字来定义成员属性，因为final 是常量的意思，我们在PHP 里定义常量使用的是define()函数，所以不能使用final 来定义成员属性。
使用final 关键标记的类不能被继承；使用final 关键标记的方法不能被子类覆盖，是最终版本；

1.15 static 和const 关键字的使用
    Static 关键字是在类中描述成员属性和成员方法是静态的, ，static 成员能够限制外部的访问，因为static 的成员是属于类的，是不属于任何对象实例，是在类第一次被加载的时候分配的空间，其他类是无法访问的，只对类的实例共享，能一定程度对类该成员形成保护。
    类的静态变量，非常类似全局变量，能够被所有类的实例共享，
    类的静态方法也是一样的，类似于全局函数。
<?php
class Person
{
    //下面是人的静态成员属性
    public static $myCountry="中国";
    // var $name; //人的名字
    //这是人的静态成员方法
    public static function say()
    {
       echo "我是中国人<br>";
    }
}/
/输出静态属性
echo Person::$myCountry;
//访问静态方法
Person::say();
//重新给静态属性赋值
Person::$myCountry="美国";
echo Person::$myCountry;
?>
    类里面的静态方法只能访问类的静态的属性，在类里面的静态方法是不能访问类的非静态成员的，原因很简单，我们要想在本类的方法中访问本类的其它成员，我们需要使用$this 这个引用，而$this 这个引用指针是代表调用此方法的对象，我们说了静态的方法是不用对象调用的，而是使用类名来访问，所以根本就没有对象存在，也就没有$this 这个引用了，没有了$this 这个引用就不能访问类里面的非静态成员，又因为类里面的静态成员是可以不用对象来访问的，所以类里面的静态方法只能访问类的静态的属性，既然$this 不存在，在静态方法中访其它静态成员我们使用的是一个特殊的类“self”；self 和$this 相似，只不过self 是代表这个静态方法所在的类。所以在静态方法里，可以使用这个方法所在的类的“类名”，也可以使用“self”来访问其它静态成员，如果没有特殊情况的话，我们通常使用后者，即“self::成员属性”的方式。
<?php
class Person
{
    //下面是人的静态成员属性
    public static $myCountry="中国";
    //这是人的静态成员方法， 通过self访问其它静态成员
    public static function say()
    {
       echo "我是".self::$myCountry."<br>";
    }
}
//访问静态方法
Person::say();
?>
在非静态方法里可不可以访问静态成员呢，当然也是可以的了，但是也不能使用“$this”引用也要使用类名或是“self::成员属性的形式”。
//
const 是一个定义常量的关键字，在PHP 中定义常量使用的是“define()”这个函数，但是在类里面定义常量使用的是“const”这个关键字，类似于C 中的#define 如果在程序中改变了它的值，那么会出现错误，用“const”修饰的成员属性的访问方式和“static”修饰的成员访问的方式差不多，也是使用“类名”，在方法里面使用“self”关键字。但是不用使用“$”符号，也不能使用对象来访问。
<?php
class MyClass
{
     //定义一个常量constant
     const constant = 'constant value';
     function showConstant() {
        echo self::constant . "\n"; //使用self 访问，不要加”$”
     }
}
echo MyClass::constant . "\n"; //使用类名来访问，也不加”$”
$class = new MyClass();
$class->showConstant();
// echo $class::constant; 是不允许的
?>
//1.16 __toString()方法