PHP的类与对象
- 类 ? 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
- 对象 ? 是类的实例。
- 成员变量 ? 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可称为对象的属性。
- 成员函数 ? 定义在类的内部，可用于访问对象的数据。
- 继承 ? 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
- 父类 ? 一个类被其他类继承，可将该类称为父类，或基类，或超类。
- 子类 ? 一个类继承其他类称为子类，也可称为派生类。
- 多态 ? 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
- 重载 ? 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
- 抽象性 ? 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
- 封装 ? 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
- 构造函数 ? 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
- 析构函数 ? 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做"清理善后" 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。
- 跟C++里的面向对象有点像
类定义和实例化：PHP类中self和$this的区别
$self代表类，$this代表对象;能用 $this 的地方一定使用$self，能用self的地方不一定能用 $this静态的方法中不能使用$this，静态方法给类访问的。今天在使用静态方法的时候，使用了$this去调用对象的属性，导致曝出错误信息，
在网上查询了手册和百度，发现大部分回答只是说明了在静态方法中不允许使用$this，只能使用self，较为靠谱的回答说明是$this是实例化对象的指针，self是对象的指针。
<?php
// 定义类
class Site {
// 属性(成员变量)
var $url;
var $title;
// 方法(成员函数)
function setUrl($par) {
// 给成员变量赋值
$this->url = $par;
}
function setTitle($par) {
// 给成员变量赋值
$this->title = $par; // 变量 $this 代表对象本身, 就是python里的self的功能
}
// 输出成员变量赋值后的值
function printValue(){
echo $this->title . ‘的url是：‘;
echo $this->url . ‘<br>‘;
}
}
// 实例化对象：用 new 运算符来实例化该类的对象
$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->printValue();
$taobao->printValue();
$google->printValue();
?>
>>>
菜鸟教程的url是：www.runoob.com
淘宝的url是：www.taobao.com
Google搜索的url是：www.google.com
构造函数__construct()
上面成员变量的赋值用专门的函数去写，然而构造函数恰巧就是负责这个对象成员变量赋初始值的功能，所以以后都交给构造函数
<?php
// 定义类
class Site {
// 属性(成员变量)
var $url;
var $title;
// 构造函数：在创建实例化对象时可以同时对成员变量进行初始化
// 在创建对象的语句中与 new 运算符一起使用。
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}
// 输出成员变量赋值后的值
function printValue(){
echo $this->title . ‘的url是：‘;
echo $this->url . ‘<br>‘;
}
}
// 实例化对象：用 new 运算符和构造函数来实例化该类的对象
$runoob = new Site(‘www.runoob.com‘, ‘菜鸟教程‘);
$taobao = new Site(‘www.taobao.com‘, ‘淘宝‘);
$google = new Site(‘www.google.com‘, ‘Google 搜索‘);
// 调用输出函数，获取标题和URL
$runoob->printValue();
$taobao->printValue();
$google->printValue();
?>
>>>
菜鸟教程的url是：www.runoob.com
淘宝的url是：www.taobao.com
Google搜索的url是：www.google.com
析构函数
析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言的
void __destruct ( void )
<?php
class MyDestructableClass {
function __construct() {
print "构造函数<br>";
$this->name = "MyObjection";
}
function __destruct() {
print "销毁 " . $this->name; //
}
}
$obj = new MyDestructableClass();
?>
>>>
构造函数
销毁 MyObjection
继承
PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承，格式如下：
class Child extends Parent {
// 代码部分
}
<?php
// 子类扩展站点类别
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . ‘<br>‘;
}
}
方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
访问控制
PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。
- public（公有）：公有的类成员可以在任何地方被访问。
- protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
- private（私有）：私有的类成员则只能被其定义所在的类访问。
属性的访问控制
类属性必须定义为公有，受保护，私有三者情况之一。如果用 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，因为这个输出的函数是自己的类定义的，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,因为private不能被继承
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
?>
方法的访问控制
类中的方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。
<?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 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。接口中定义的所有方法都必须是公有，这是接口的特性。要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
<?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;
}
}
抽象类
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。定义为抽象的类不能被实例化。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。
<?php
abstract class AbstractClass
{
// 强制要求子类定义这些方法
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// 普通方法（非抽象方法）
public function printOut() {
print $this->getValue() . ‘<br>‘;
}
}
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_‘) . ‘<br>‘;
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue(‘FOO_‘) . ‘<br>‘;
?>
>>>
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
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
PHP中的 ：：是一种内置的语法解析符号，中文名叫做“范围解析操作符”。:: 符号是用来帮助PHP中的语法结构“类”来实现对其成员的访问，通常我们只允许访问静态成员，具体代码如下：
① 类正常访问静态成员
class Heima{
//静态属性
public static $heima = ‘黑马‘;
//静态方法
public static function getHeima(){
//内部使用::
echo self::$heima; //self代表Heima类，同Heima::$heima
}
}
//外部访问
echo Heima::$heima; //访问静态属性，输出黑马
Heima::getHeima(); //访问静态方法，输出黑马
② 类访问普通方法（系统不建议，有风险，风险原因?????）
<?php
class Heima {
public function show() {
echo __CLASS__;
}
}
//正常应该是对象访问?$h?=?new?Heima();$h->show();
//静态访问
Heima::show();????????????????//系统会提示点什么，但是可以访问
?>
>>>
Deprecated: Non-static method Heima::show() should not be called statically in E:\php_enviroment\PHPTutorial\WWW\1.php on line 9
Heima
Notice: Use of undefined constant - assumed ‘ ‘ in E:\php_enviroment\PHPTutorial\WWW\1.php on line 9
<?php
class HeiMa {
public function show() {
echo __CLASS__;
}
}
//其实对象也可以利用::符号访问
$xiao = new HeiMa();
$xiao :: show();//效果也能达成，但是我们通常不建议这么使用
?>
>>>
Deprecated: Non-static method HeiMa::show() should not be called statically in E:\php_enviroment\PHPTutorial\WWW\1.php on line 9
HeiMa
Final 关键字
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()
?>
调用父类构造方法
PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。