Web安全学习_PHP学习_类

一、类

类的定义：

<?php
	class 类名{
		var $变量名;  //成员变量通过var定义，也可初始化
		function 函数名(参数列表){
		函数体
		}
		$this->变量名;  //$this表示自身的对象
	}
//创建类并调用类成员及方法
	$对象名=new 类名;
	$对象名->成员变量名=值;  //调用成员变量并赋值
	$对象名->方法名();  //调用成员方法
?>

构造函数：用于对成员变量进行初始化

<?php
	class Person{
		var $name;
		var $height;
//定义构造函数，函数名为__construct，括号里面为参数列表，这里定义了两个参数，在定义对象时需要传入参数
		function __construct($a,$b){
			$this->name=$a;
			$this->height=$b;
		}
	}
	$Bob=new Person("Bob",180);  //定义了一个Bob对象并传入Bob和180的参数
	echo $Bob->name;  //此时输出名字"Bob"
	echo $Bob->height;  //输出身高为180
?>

析构函数：用于对象调用完函数后，释放空间。函数名为__destruct

继承：

1. 用于继承已定义好的类，PHP不支持多继承。使用关键字extends只能继承父类的public、protected成员变量和方法，private成员变量和方法不能继承。

<?php
//定义一个父类
	class People{
	//定义三种访问权限的成员变量
		public $name="public name";
		protected $age="protected age";
		private $salary="private salary";
	//定义一个公有访问权限方法
		public function showName(){
			echo "父类public";
		}
	//定义一个保护权限的方法
		protected function showAge(){
			echo "父类protected";
		}
	//定义一个私有访问权限的方法
		private function showSalary(){
			echo "父类private";
		}
	//定义符类的构造函数
		function __construct(){
			echo "父类构造函数";
		}
	}
//创建一个子类继承父类
	class Coder extends People{
	//定义子类的构造函数
		function __construct(){
			echo "子类构造函数";
		}
		function showprotected(){
			echo $this->age;
		}
		function showprivate(){
			echo $this->salary;
		}
		function showprotectedhanshu(){
			$this->showAge();
		}
		function showprivatehanshu(){
			$this->showSalary();
		}
	}
	//创建一个子类的对象
	$Bob=new Coder();
	echo $Bob->name;//成功输出说明继承了父类的public成员属性
	//通过子类的输出protected变量方法测试是否继承父类的protected成员属性
	echo $Bob->showprotected(); //成功输出，说明继承了protected成员属性
	echo $Bob->showprivate();//报错，说明未继承父类的private属性
//---------测试继承父类的方法----------
	echo $Bob->showName();//成功输出说明继承了父类的public方法
	echo $Bob->showprotectedhanshu();//成功输出说明继承了父类的protected方法
	echo $Bob->showprivatehanshu();//报错，说明未继承父类private方法
?>

3. 子类若定义了构造方法则不会调用父类的构造方法，若子类没有定义构造方法则会调用父类的构造方法（见上例）
4. 子类中若需要调用父类中的方法，可以通过：parent::方法名();或父类名::方法名();调用。

方法重写：当继承以后可以对父类的方法进行重写，此时将覆盖之前的内容。子类重写时，访问权限不能小于父类方法的访问权限。如父类为public，子类不能为protected

<?php
//先定义一个Person类
	class Person{
		var $name;
		var $height;
		function print_name(){
			echo $this->name;
		}
	}
//定义Person2类，继承Person类
	class Person2 extends Person{
		var $weight;
		var $hobby;
//对父类的方法进行重写
		function print_name(){
			echo $this->weight;
		}
	}
//创建一个Person2类的对象
	$Alice=new Person2;
	$Alice->name="Alice";
	$Alice->weight="65kg";
	echo $Alice->name;
	echo $Alice->weight;
	$Alice->print_name();  //此时仅会输出weight
?>

类的成员变量的三种访问权限：

• public（公有）：可以在任何地方访问。 使用var关键字定义的变量为公有访问属性
• protected（保护）：可以被其自身、其父类、其子类访问。
• private（私有）：只能被其定义的所在类访问

访问private和protected成员需要通过类内public函数访问

<?php
	class A{
		private $n1;  //定义私有成员n1
		private $n2;  //定义私有成员n2
		function setN1($N1,$N2){
			$this->n1=$N1;  //通过公有方法对n1和n2赋值
			$this->n2=$N2;
		}
		function showInfo(){
			echo $this->n1;  //输出n1和n2的值
			echo $this->n2;
		}
	}
	$Bob=new A();
	//若加入此代码会报错$Bob->n1=100;
	//Cannot access private property
	$Bob->setN1(10,20);
	$Bob->showInfo();
?>

static变量
静态变量与全局变量原理相似，但静态变量只能通过类来访问，全局变量破坏了封装性
定义：

<?php
	class People{
//权限 static $变量名;
		public static $num=0;
		function addPeople(){
//※※类内访问：self::$变量名或类名::$变量名
//※※类外访问：类名::$变量名
			self::$num+=1;
		}		
	}
	$Bob=new People;  //创建一个对象Bob
	$Bob->addPeople(); 
	$Alice=new People;  //增加一个对象Alice
	$Alice->addPeople();
	echo People::$num;  //类外访问静态变量，访问静态变量的值
?>

**静态方法(类方法)**只能操作静态变量，不能操作非静态变量
普通的方法可以操作静态变量也可以操作非静态变量
定义

<?php
	class People{
		public static $num=0;  //定义一个静态变量
		public static function addPeople(){
			People::$num+=1;  //静态方法操作静态变量
		}
	}
?>

final关键字
如果一个类被声明为final类则此类不能被继承，若一个类中的成员方法被声明final则此类不能被重写，但可以被继承，不能修饰成员属性。

<?php
//定义父类People1，其中的print_Age()方法被声明为final
	class People1{
		public $name;
		public $age;
		function print_Name(){
			echo $this->name;
		}
		final function print_Age(){
			echo $this->age;
		}
	}
//定义子类People2继承父类People1，此时不能对父类中的print_Age方法进行重写，如重写则报错
	class People2 extends People1{
		public $height;
		function print_height(){
			echo $this->height;
		}
	}
	$Bob=new People2;
	$Bob->age=19;
	$Bob->name="Bob";
	$Bob->height=187;
	$Bob->print_Name();
	$Bob->print_Age();
	$Bob->print_height();
?>

抽象类

• 将一个中的方法不进行实例化，供其他类继承。
• 只要类中有一个为抽象方法则此类就必须声明为抽象类
• 抽象类被继承后，子类中必须实现抽象类中的所有抽象方法

接口

• 接口不能实例化 一个类可以实现多个接口用逗号隔开
• 接口只声明方法不实现 类实现某个接口必须将接口内的方法全部实现
• 接口中不能定义变量，可以定义常量 一个
• 接口可以继承多个接口，逗号隔开

const常量

• 定义时必须赋初值。
• 常量名为大写。
• 常量一旦定义就不能修改。
• 常量具有public的属性但不能在定义常量之前加访问权限的关键字。
• 可以被子类继承。
  类内访问常量：类名::常量名 或 self::常量名
  类外访问常量：类名::常量名