类是变量与浸染于这些变量的函数的凑集。工具：实际存在该类事物中每个实物的个体。$a =new User(); 实例化后的$a。创建工具的过程称为实例化。
例：computer.php
<?php
class Computer{ //创建一个Computer类
var $price=3000; //成员变量 定义价格变量$price为3000 属性
function getPrice(){ //成员函数 创建一个获取价格封装在getPrice方法（函数）中
echo 'price: '.$this->price; //打印价格 this是指向当前工具的指针
}
}
$mypc = new Computer(); //创建一个实例
$mypc->getPrice ();//调用getPrice方法获取价格
?>
结果：
2.定义类
利用class关键字来创建一个类，类名的首字符一样平常要大写。
类定义构造如下：
class 类名 [extends 父类名]
{
成员变量列表
成员函数列表
}
方括号中的内容为可选内容。
例：class.php
<?php
class Super{ //创建 Super类
}
class Sub extends Super { //创建Sub类，并继续父类Super
var $p1 = \"大众Hello p1!\公众;//成员变量
function show(){ //成员函数 show方法
echo $this->p1; //$this当前工具
}
}
$print = new Sub(); //实例化
$print -> show();//调用show方法打印
?>
结果：
3.创建工具与销毁工具
例：create_destroy_obj.php
<?php
class Obj{
}
$object1 = new Obj(); //创建一个新的工具，$object1的引用计数加1
$object2 = $object1; //引用复制，$object1的引用计数即是2，$object2的引用计数即是1
unset($object1); //销毁工具$object1，$object1的引用计数减1，但引用计数并不为0，$object1中成员变量内存空间并没有开释
unset($object2); //销毁工具$object2，$object2的引用计数减1，引用计数为0，此时自动开释所有内存空间
?>
4.类的成员变量与成员函数
在类中定义成员变量（属性），只要在变量名前加public(公有)、private(私有)或者proteced（保护）类型关键词润色。
在类中定义函数即成员函数（方法），它的定义方法和一样平常函数基本相同，利用function关键字声明，并在function关键字前加public(公有)、private(私有)或者proteced（保护）类型关键词润色。
例：function.php
<?php
class Super{ //创建Super类
private $p1 = 'hello p1!'; //成员变量 私有 $p1 属性
public function show(){ //成员函数 show()方法 公有
echo $this->p1; //$this指当前工具
}
}
class Sub extends Super{//创建Sub类 并继续父类Super
private $p2 = 'hello p2!'; //成员变量 私有 $p2 属性
public function show(){//成员函数 show()方法 公有
echo $this->p2;//$this指当前工具
}
}
$s = new Sub(); //创建实例
$s->show(); //调用show()方法
?>
结果：
5.类的访问掌握
浸染域
全局
同一个类
子类
public
√
√
√
private
√
protected
√
√
例：access.php
<?php
class Super { //创建一个Super类
private $p1 = \"大众Hello p1!\"大众; //成员变量 属性 私有 $p1
protected $p2 = \"大众Hello p2!\"大众; //成员变量 属性 保护 $p2
public $p3 = \"大众Hello p3!\"大众; //成员变量 属性 公有 $p3
function show () { //成员函数 show方法
echo 'super:'.$this->p1.\公众<br>\"大众; //this指当前工具 打印super:Hello p1
echo 'super:'.$this->p2.\"大众<br>\"大众; //this指当前工具 打印super:Hello p2
echo 'super:'.$this->p3.\"大众<br>\公众; //this指当前工具 打印super:Hello p3
}
}
class Sub extends Super { //创建一个Sub 父类Super
private $p4 = \"大众Hello p4!\公众;//成员变量 属性 私有 $p4
function show() { //成员函数 show方法
Super::show();//调用父类 show方法 打印super:Hello p1 super:Hello p2 super:Hello p3
echo 'sub:'.$this->p1.\公众<br>\公众; // $p1未定义 无法调用父类Super 私有成员变量 打印 sub:
echo 'sub:'.$this->p2.\"大众<br>\"大众; //打印sub:Hello p2
echo 'sub:'.$this->p3.\"大众<br>\"大众; //打印sub:Hello p3
echo 'sub:'.$this->p4.\"大众<br>\"大众;//打印sub:Hello p4
}
}
$s1 = new Super();//实例化
$s1->show (); //调用show方法
$s2 = new Sub();//实例化
$s2->show();//调用show方法
//echo 'global:'.$s1->p1.\"大众<br>\公众; //访问失落败 在类的外部，不能访问类的私有和保护类型的成员变量
//echo 'global:'.$s1->p2.\"大众<br>\公众; //访问失落败
echo 'global:'.$s1->p3.\"大众<br>\公众; // 打印 global: Hello p3
echo 'global:'.$s2->p1.\"大众<br>\"大众; //无效数据 由于类Sub中没有定义变量$p1，以是输出了空值
//echo 'global:'.$s2->p2.\"大众<br>\公众; //访问失落败
echo 'global:'.$s2->p3.\"大众<br>\"大众; //打印 global: Hello p3
//echo 'global:'.$s2->p4.\"大众<br>\"大众; //访问失落败
?>
结果：
6.类的布局函数
布局函数
void __construct ([ mixed $args [, $... ]] )
布局函数可以接管参数，能够在创建工具时赋值给工具属性
布局函数可以调用类方法或其他函数
布局函数可以调用其他类的布局函数
PHP 5 允行开拓者在一个类中定义一个方法作为布局函数。具有布局函数的类会在每次创建工具时先调用此方法，以是非常适宜在利用工具之前做一些初始化事情。
布局函数格式如下：
class 类名 [extends 父类名] {
[public/private/protected] function __construct()
{
}
}
之前已经知道类的成员变量和成员方法都可以被继续，类的布局函数也能被子类继续。
例：construct.php
<?php
class Super { //创建一个Super类
protected $p1; //成员变量 保护 $p1
public function __construct() //布局函数 公有 注：布局函数的关键词construct前面有两个下划线，如果只有一个下划线，将不会输出任何结果
{
$this->p1 = \"大众Hello p1!<br>\"大众;//$this当前工具 Hello p1!
echo $this->p1;// Hello p1!
}
}
class Sub extends Super { //创建一个Sub类 父类Super
}
$s1 = new Super();//创建实例 打印Hello p1! 布局函数在类被实例化时调用
$s2 = new Sub();//创建实例 继续父类 打印 Hello p1!
?>
结果：
例：construct2.php
这个例子中的父类和子类都定义告终构函数，当子类的工具被创建后，将调用子类的布局函数，而不会调用父类的布局函数。
<?php
class Super { //创建一个Super类
protected $p1; //成员变量 保护 $p1
public function __construct()//布局函数 公有 注：布局函数的关键词construct前面有两个下划线，如果只有一个下划线，将不会输出任何结果
{
$this->p1 = \"大众super::Hello p1!<br>\"大众;//$this当前工具 super::Hello p1!
echo $this->p1; //打印super::Hello p1!
}
}
class Sub extends Super { //创建一个Sub类 父类Super
public function __construct()//布局函数 公有
{
//parent::__construct();//调用父类布局函数 打印super::Hello p1!
$this->p1 = \公众sub::Hello p1!<br>\公众;//$this当前工具sub::Hello p1!
echo $this->p1;//打印sub::Hello p1!
}
}
$s2 = new Sub(); //实例化 只调用子类布局函数 打印sub::Hello p1!
?>
结果：
例：construct3.php
用 parent::__construct();//调用父类布局函数，而不是parent->__construct()
就可以在子类中调用父类函数。
class Super { //创建一个Super类
protected $p1; //成员变量 保护 $p1
public function __construct()//布局函数 公有 注：布局函数的关键词construct前面有两个下划线，如果只有一个下划线，将不会输出任何结果
{
$this->p1 = \公众super::Hello p1!<br>\公众;//$this当前工具 super::Hello p1!
echo $this->p1; //打印super::Hello p1!
}
}
class Sub extends Super { //创建一个Sub类 父类Super
public function __construct()//布局函数 公有
{
parent::__construct();//调用父类布局函数 打印super::Hello p1!
$this->p1 = \"大众sub::Hello p1!<br>\公众;//$this当前工具sub::Hello p1!
echo $this->p1;//打印sub::Hello p1!
}
}
$s2 = new Sub(); //实例化 打印super::Hello p1! 打印sub::Hello p1!
?>
结果：
7.类的析构函数
析构函数是类的一个分外的函数，PHP将在工具销毁前调用这个函数。析构函数用于开释类中的数据资源，在默认情形下，PHP仅仅开释工具的成员变量所占用的内存。
析构函数的格式如下：
class 类名 [extends 父类名]
{
[public/private/protected] function __destruct()
{
}
}
例：destruct.php
<?php
class Super { //创建一个Super类
protected $p1; //成员变量 保护 $p1
public function __construct()//布局函数 公有
{
$this->p1 = \"大众Hello p1!<br>\"大众;//$this当前工具 Hello p1!
echo $this->p1; //打印Hello p1!
}
public function __destruct()//析构函数 公有
{
echo 'desturct super <br>'; //打印desturct super
}
}
class Sub extends Super { ////创建一个Sub类 父类Super
public function __destruct()//析构函数 公有
{
echo 'destruct sub <br>';//打印destruct sub
}
}
$s1 = new Super();//创建实例 //打印Hello p1!
$s2 = new Sub(); //创建实例 继续父类 打印Hello p1!
//程序结尾自动调用析构函数，首先调用的是Super析构函数 打印desturct super 然后调用Sub类析构函数 打印destruct sub 上面实例化对调，析构函数在结尾处次序也对调
?>
结果：
8.类的静态成员变量
在php中，访问类的方法/变量有两种方法：
1). 创建工具$object = new Class()，然后利用”->”调用：$object->attribute/function，条件是该变量/方法可访问。
2). 直接调用类方法/变量：class::attribute/function，无论是静态/非静态都可以。但是有条件条件：
A. 如果是变量，须要该变量可访问。
B. 如果是方法，除了该方法可访问外，还须要知足：
b1) 如果是静态方法，没有分外条件；
b2) 如果是非静态方法，须要改方法中没有利用$this，即没有调用非静态的变量/方法，当然，调用静态的变量/方法没有问题。
然后我们再看一下利用$object->… 和利用class::… 都有什么差异：
1). 利用$object->… ，须要实行布局函数创建工具；
2). 利用class::… 调用静态方法/变量，不须要实行布局函数创建工具；
3). 利用class::… 调用非静态方法/变量，也不须要实行布局函数创建工具。
然后奇怪的地方就出来了，既然2和3都一样，那静态方法/变量存在还有什么意义呢？
差异还是显然存在的，如下：
1. 静态变量
静态成员只保留一个变量值，而这个变量值对所有的实例都是有效，也便是说，所有的实例共享这个成员。
2. 静态方法
静态方法可以直策应用class::… 来调用，而非静态方法须要知足一定限定条件才能利用class::.. 的方法调用，如之前所述
例：static.php
<?php
class MyStatic{ //创建一个MyStatic类
private static $result = 0; //成员变量 私有 静态变量 $result为0
public function add($x){ //成员函数 公有 add函数 形参$x
MyStatic::$result = MyStatic::$result + $x; //此处为静态成员变量的调用办法，静态变量在没有实例前就可以调用
}
public function sub($x){ //成员函数 公有 sub函数 形参$x
MyStatic::$result = MyStatic::$result - $x;
}
public function getResult()//成员函数 公有 getResult函数
{
return MyStatic::$result; //返回结果
}
}
$st = new MyStatic();//创建实例
$st->add(5); //0+5=5
$st->sub(3); //5-3=2
echo 'result: '.$st->getResult();//打印result:2
?>
结果：
9.类的静态成员函数
静态成员函数的浸染类似于静态成员变量，它为类的所有工具做事，而不是对仅有某个特定工具做事，它相称于全局函数浸染。当一个类被创建时，静态成员函数也被创建，此时类和静态成员函数是干系联的。
例：staticfunction.php
<?php
class MyStatic{ //创建一个MyStatic类
private static $i = 1; //私有 静态成员变量 $i为1
public static function add($x){ // 公有 静态成员函数 add 形参$x
echo self::$i + $x; //自引用
}
}
$st = new MyStatic();//创建实例
$st->add(2);// 1+2=3 打印3
?>
结果：
<?php
class MyStatic{ //创建一个MyStatic类
private static $i = 1; //私有 静态成员变量 $i为1
public static function add($x){ // 公有 静态成员函数 add 形参$x
echo $this->i + $x; //在静态方法中不能调用非静态的方法。静态方法只能调用静态成员变量
}
}
$st = new MyStatic();//创建实例
$st->add(2);//
?>
结果：
注：在访问PHP类中的成员变量或方法时，如果被引用的变量或者方法被声明成const（定义常量）或者static（声明静态）,那么就必须利用操作符::,反之如果被引用的变量或者方法没有被声明成const或者static,那么就必须利用操作符->。
其余，如果从类的内部访问const或者static变量或者方法,那么就必须利用自引用的self，反之如果从类的内部访问不为const或者static变量或者方法,那么就必须利用自引用的$this。
例：staticfunction2.php
<?php
class MyStatic{ //创建一个MyStatic类
private static $i = 1;//私有 静态成员变量 $i为1
private function inc(){ //私有 成员函数 inc
self::$i = self::$i + 1; //自引用 自加 1+1
}
public static function add($x){//公有 静态成员函数 add 形参$x
//$this->i; //在静态方法中不能调用非静态的方法。
self::inc();//静态函数add调用非静态函数inc时，利用self::inc格式，如果利用$this->inc()的格式，将报错不能利用$this
echo self::$i + $x; //打印 2+$x
}
}
$st = new MyStatic();//创建实例
$st->add(2);//打印 2+2 =4
?>
结果：
若$this->i; 代替self::inc();
则结果：提示不能利用$this来调用
10.类中的常量
在PHP中利用const关键字表示常量，常量一样平常要写大写，如果常量有多个单词组成，利用下划线分开。常量的调用办法和静态变量相同，利用::符号调用。
例：const.php
<?php
class MyConst{ //创建 MyConst类
const PI = 3.14; //定义常量PI为3.14
private $result = 0; //私有 成员变量 $result 为0
public function area($r){ //公有 成员函数area 形参$r
$this->result = self::PI$r$r;//如果此处表达式写为PI$r$r,返回结果为0。调用常量利用self::PI的办法，self表示当前的类名
echo 'area: '.$this->result; //打印结果
}
}
$cst = new MyConst(); //实例化
$cst->area(2);//3.1422=12.56
?>
结果：
常量只能被赋值一次，如果再给常量赋第二次的值将会出错。
例：const2.php
<?php
class MyConst{ //创建MyConst类
const I = 1; //定义常量I为1 定义常量时，不须要在常量名前加$,这是常量和变量的差异
}
echo 'I = '.MyConst::I; //打印 I=1
//MyConst::I = 2;
?>
结果：
加上MyConst::I = 2;就会报错。
请大家多多关注，感谢！
本文只供学习利用，请勿其他用场！
