网络安全入门学习第十六课——PHP面向对象

---

一、定义类（class）

通用语法格式：

class phpClass {
	var $var1;  //跟js差不多
	var $var2 = "constant string";
 
	function myfunc ($arg1, $arg2) {
		[..]
	}
	[..]
}
?>

解析如下：
• 类使用 class 关键字后加上类名定义。
• 类名后的一对大括号({})内可以定义变量和方法。
• 类的变量使用 var 来声明, 变量也可以初始化值。
• 函数定义类似 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;
	}
}
?>

---

二、创建对象（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->getTitle();
$taobao->getTitle();
$google->getTitle();

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

---

三、构造函数（ 初始化变量，__construct() ）

构造函数是系统开始前会自动执行的初始化函数。
语法格式：

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

在上面的例子中我们就可以通过构造方法来初始化 $url 和 $title 变量

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

再来一个例子：

class Student{
	var $age; 	//成员变量
	var $name;
	function study(){ //成员函数
		echo 'student'.$age.'开始学习';
	}
}
$s1 = new Student; //创建一个对象，默认的构造函数（构造函数就是创建对象的函数）
//$s1 = Student(18,'张三');
$s1->study();     *这里不是 s·study()而是采用-> 调用方式
?>
//执行结果：student开始学习
//没有说谁开始学习new Student;没有传名字过去

完善上面例子：

header("Content-type:text/html;charset=utf-8");

class Student{
	var $age;
	var $name;
	var $class;
	function study(){
		echo 'student'.$this -> name.'开始学习';
	}
	function __construct( $age, $name ) {
		echo 'construct called';
		$this->age = $age; //这里是this表示 当前对象，引用成员通过-> 不是.(python和java都是.)
		$this->name = $name;
	}
}
//$s1 = new Student; //默认的构造函数（构造函数就是创建对象的函数）
$s1 = new Student(18,'张三'); //自动会调用对应的构造函数 __construct( $age, $name ) 
$s1->study();  
?>

---

四、析构函数（ __destruct() ）

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

PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，其语法格式如下：

void __destruct ( void )

举例：

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

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

$obj = new MyDestructableClass();
?>

---

五、继承（extends）

PHP 使用关键字extends来继承一个类，PHP 不支持多继承，格式如下：

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

举例：

 
// 子类扩展站点类别
class Child_Site extends Site {
	var $category;
	function setCate($par){
		$this->category = $par;
	}
 
	function getCate(){
		echo $this->category . PHP_EOL;
	}
}

---

六、方法重写（子类直接同名覆盖）

一个例子：

header("Content-type:text/html;charset=utf-8");

class Student{
	var $age;
	var $name;
	var $classname;
	function study(){
		echo 'student'.$this -> name.'开始学习';
	}

	function __construct( $age, $name ) {
		echo 'construct called';
		$this->age = $age; //这里是this表示 当前对象，引用成员通过-> 不是.(python和java都是.)
		$this->name = $name;
	}
}

class Employee extends Student{
	var $company;
	//$age, $name,$classname 是从Student继承过来
	function __construct( $age, $name,$classname,$company ){
		$this->age = $age;
		$this->name = $name;
		$this->classname = $classname;
		$this->company = $company;
	}
}

$obj = new Employee(18,'张三','一班','百度');
$obj->study();//study方法继承自Student
?>

如果重写：

header("Content-type:text/html;charset=utf-8");

class Student{
	var $age;
	var $name;
	var $classname;
	function study(){
		echo 'student'.$this -> name.'开始学习';
	}

	function __construct( $age, $name ) {
		echo 'construct called';
		$this->age = $age; //这里是this表示 当前对象，引用成员通过-> 不是.(python和java都是.)
		$this->name = $name;
	}
}

class Employee extends Student{
	var $company;
	function __construct( $age, $name,$classname,$company ){
		$this->age = $age;
		$this->name = $name;
		$this->classname = $classname;
		$this->company = $company;
	}

	//重新写了一个（覆盖，以前的父类方法不满足要求了）
	function study(){
		echo 'student'.$this -> name.'开始学习'.'在'.$this->company.'上班';
	}
}

$obj = new Employee(18,'张三','一班','深信服');
$obj->study();
?>

---

七、访问控制

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。

• public（公有）：公有的类成员可以在任何地方被访问。
• protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
• private（私有）：私有的类成员则只能被其定义所在的类访问。

---

八、属性的访问控制

类属性必须定义为公有，受保护，私有之一。如果用var定义，则被视为公有。

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

	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

?>

---

九、方法的访问控制

类中的方法可以被定义为公有，私有或受保护。

如果没有设置这些关键字，则该方法默认为公有。

/**
* 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();			*公有的和受保护的都可执行，但私有的不行
?>

---

十、接口（interface和implements）

使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容(没有{})。

接口是通过interface关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

// 声明一个'iTemplate'接口 接口其实就是特殊的类
interface iTemplate {
	public function setVariable($name, $var); //方法没有{}就表示没有方法体
	//可以new iTempalte()嘛
	public function getHtml($template); 
	//也是抽象方法 abstract public function getHtml($template);
	//接口方法默认抽象方法为了简单把abstract关键字给去掉了
}


// 实现接口
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;
	}
}
?>

---

十一、类中常量（const）

可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号（普通常量也没有）。

常量使用const定义，只能被定义一次，值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。

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

举例：

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 起
?>

---

十二、抽象类（abstract）

任何一个类，如果它里面至少有一个方法是被声明为抽象的(方法是抽象的意思是里面没有实现)，那么这个类就必须被声明为抽象的。

抽象类使用关键字abstract来定义。

定义为抽象的类不能被实例化。

被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

abstract class AbstractClass { //new 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;
?>

例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则也是可以正常运行的。

abstract class AbstractClass {
	// 我们的抽象方法仅需要定义需要的参数
	abstract protected function prefixName($name);
}

class ConcreteClass extends AbstractClass {
	// 我们的子类可以定义父类签名中不存在的可选参数
	public function prefixName($name, $separator = ".") {
		if ($name == "Pacman") {
			$prefix = "Mr";
		} elseif ($name == "Pacwoman") {
			$prefix = "Mrs";
		} else {
			$prefix = "";
		}
		return "{$prefix}{$separator} {$name}";
	}
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>

---

十三、Static 关键字

明类属性或方法为 static(静态)，就可以不实例化类而直接访问。

静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

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

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

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

---

十四、Final 关键字

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

以下代码执行会报错：

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()

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

// 调用 BaseClass 构造方法 
$obj = new BaseClass();
输出：
BaseClass 类中构造方法

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
输出：
BaseClass 类中构造方法 SubClass 类中构造方法

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
输出：
BaseClass 类中构造方法
?>

---