有很多函数可以移动数组指针。（尝试想要改变自己的人脉或者是微信好友的时候，可以通过自己的微信，自己的通讯录，通过自己的记忆点或者是排序的方式来对这些人进行整理。自己的脑海里可以通过自己的回忆梳理并定位到某一个特定的人或者是朋友。）

next()函数返回紧接着放在当前数组指针下一个位置的数组值。其形式如下：
mixed next(array array)
以下是一个例子：
$fruits=array(“apple”,”orange”,”banana”);
$fruit=next($fruits); 这里通过next()函数将数组指针从apple移动到了orange
$fruit=next($fruits); 这里从orange返回到banana
还可以将指针前移，也可以直接移动到数组的开始和末尾位置。
prev()函数返回位于当前指针前一个位置的数组值，如果指针本来就位于数组的第一个位置，则返回FALSE。其形式如下：
mixed prev(array array)
reset()函数用于将数组指针设置回数组的开始位置。其形式如下：
mixed reset(array array)
end()函数将指针移动到数组的最后一个位置，并返回最后一个元素。其形式如下：
mixed end(array array)
$fruits=array(“apple”,”orange”,”banana”);
$fruit=current($fruits); 通过current（）函数返回当前元素apple
$fruit=end($fruits); 通过end（）函数返回数组末尾的最后一个元素banana

array_walk()函数将数组中的各个元素传递到用户自定义函数。其形式如下：
boolean array_walk(array &array, callback funtion[,mixed userdata])
<form action=submitdata.php” method=”post”>

提供最能描述所在州的6个关键词。

关键字:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字2:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字3:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字4:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字5:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

关键字6:<br/>
<input type=”text” name=”keyword[]” size=”20” maxlength=”20” value=””/>

<input type=”submit” value=”Submit!”>

<form>
以上的这个表单定义了六个关键字，大小size和最大长度都定义为了20。这个表单信息发送给submitdata.php这个脚本。通过使用array_walk()函数，就可以使用一个预定义函数轻松地过滤这些关键字：

<?php
function sanitize_data(&$value,$key){
$value=strip_tags($value); 数组中的每个值都传递给strip_tags()函数，这个函数将删除值中的所有HTML和PHP标记。
}
array_walk($_POST[‘keyword’],”sanitize_data”);将通过表单post方式提交所获得的关键字keyword数组中的所有元素传递到sanitize_data函数进行处理。
?>

顶

有些函数可以用来确定数组中的值总数以及唯一值的个数。

count()函数返回数组中值的总数。（就像统计原来我事业单位非编时候的同事们到底有多少人是一样的道理。）其形式如下：
integer count(array array[,int mode])
$garden=array(“cabbage”,”peppers”,”turnips”,”carrots”);
echo count($garden);
这将返回4，也就是数组$garden中所有蔬菜的总数。

$locations=array(“Italy”,Amsterdam”,array(“Boston”,”Des Moines”),”Miami”);
echo count($locations,1);
这将返回6，数组$location中看上去只有5个元素，但count()函数中加入了可选的mode参数，设置为1之后，数组$location中的有两个元素的小数组也被统计为一个元素，所以，最后的统计结果就为6了。就像人口办特勤里有二三十个人一个大队，也有两三人一组一个小队是一样的，用count函数统计的时候，如果加入了可选的mode参数后，大队跟小队的数量都会进行统计。

sizeof()函数是count()的别名，它们的功能是一样的。就像现实中给人起绰号是一样的道理。这两个函数的功能是一样的。

array_count_values()函数返回一个包含键/值对的数组。其形式为：
array array_count_values(array array)
$states=array(“Ohio”,”Iowa”,”Arizona”,”Iowa”,”Ohio”);
$stateFrequency=array_count_values($states);
print_r($stateFrequenccy);
这将返回:
Array([Ohio]=>2 [Iowa]=>2 [Arizona]=>1)其实非常好理解，数组$states中Ohio出现了两次，Iowa出现了两次，Arizona出现了一次。所以数组中相应的键/值对会一一出现。

array_unique()函数会删除数组中所有重复的值，返回一个由唯一值组成的数组。其形式为：
array array_unique(array array)
$states=array(“Ohio”,”Iowa”,”Arizona”,”Iowa”,”Ohio”);
$uniqueStates=array_unique($states);
print_r($uniqueStates);
这将返回:
Array([0]=>Ohio [1]=>Iowa [2]=>Arizona)原先数组$states中重复的元素都已经被array_unique函数给删除了。

array_reverse()函数将数组中元素的顺序逆置。其形式如下：

array array_reverse(array array[,boolean preserve_keys])
如果可选参数preserve_keys设置为TRUE，则保持键映射。
$states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
print_r(array_reverse($states));
这里将打印Array((0)=>New Jersey [1]=>Pennsylvania [2]=>Delaware)，顺序确实比起之前的那个数组，已经通过array_reverse函数逆置了。

可以与启用preserve_keys时得到的结果做个比较：
$states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
print_r(array_reverse($states,1));
这里将打印Array([2]=>New Jersey [1]=>Pennsylvania [0]=>Delaware)这里的这个数组中的键跟值的映射关系，跟原先数组$states中元素的键值映射关系保持关联，保留之前的那种键/值的联系。
使用关联键的数组将不受preserve_keys的影响。对于关联数组，总是会保持键映射。

顶

顶

顶

array_flip()函数将置换数组中键及其相应值的角色。其形式如下：
array array_flip(array array)
$state=array(“Delaware”,”Pennsylvania”,”New Jersey”);
$state=array_flip($state);
print_r($state);
这个例子返回以下结果:
Array([Delaware]=>0 [Pennsylvania]=>1 [New Jersey]=>2) 其实已经从这里看出，数组$state中原先的键和值已经被置换了。调换了一下位置。（当你尝试改变我的时候，其实你已经变成了我，而我也已经蜕变成了你。只不过我们都假装不知道罢了，但是你跟我其实都已经互相替换了一下身份。）

sort()函数对数组进行排序，各元素按值由低到高的顺序排列。其形式如下：
void sort(array array [,int sort_flags] )
sort()函数不返回排序后的数组。sort_flags参数可选，将根据这个参数指定的值修改该函数的默认行为。
SORT_NUMBERIC,按数组排序。对整数或浮点数排序时很有用。
SORT_REGULAR,按照相应的ASCII值对元素排序。
SORT_STRING,按接近于人所认知的正确顺序对元素排序。
$grades=array(42,98,100,100,43,12);
sort($grades);
print_r($grades);
结果如下：
Array([0]=>12 [1]=>42 [2]=>43 [3]=>98 [4]=>100 [5]=>100)其实通过sort（）函数已经排好序了，然后通过print_r函数进行打印。元素确实已经按照由低到高的顺序进行排列。就像按照年龄大小来排列病人是一样的道理。要尊老爱幼，所以，才会有sort()函数来将老人尽量排在后面甚至是最后面。

当然，值得注意的是键/值关联不再保持。
$states=array(“OH”=>”Ohio”,”CA”=>”California”,”MD”=>”Maryland”);
sort($states);
print_r($states);
这个例子的输出如下：
Array([0]=>California [1]=>Maryland [2]=>Ohio)之所以会这么排序，是因为sort（）函数已经对数组$states中的元素按照原先关联键中所对应的值的字母顺序进行了排列。我真正想要关心的是你手里到底有什么真东西，真的值，而不是你看上去那种有点虚伪的掩饰。通过sort()函数，我能够很清晰地洞悉到你对于我所认为的值的重要性。

asort()函数与sort()函数相同，以升序对数组排序，只不过它将保持键/值的关联。其形式如下：
void asort(array array [,integer sort_flags])
考虑以下数组：
$state[0]=”Delaware”;
$state[1]=”Pennsylvania”;
$state[2]=”New Jersey”;
使用sort()排序将破坏键/值的关联，使用sort()排序结果如下：
Array ([0]=>Delaware [1]=New Jersey [2]=>Pennsylvania)
但是，如果使用asort()排序将得到:
Array([0]=>Delaware [2]=>New Jersey [1]=>Pennsylvania)这里的键其实用了原先数组中的相应的键，而且没有任何改变。当然,asort()函数确实保持了键/值的关联。

rsort()函数对sort()相同，只不过它以相反的顺序（降序）对数组元素排序。其形式如下：
void rsort(array array[,int sort_flags])
$states=array(“Ohio”,”Florida”,”Massachusetts”,”Montana”);
rsort($states);
print_r($states);
这会返回以下排序结果：
Array([0]=>Ohio [1]=>Montana [2]=>Massachusetts [3]=>Florida)
与asort()一样，arsort()会保持键/值的关联，但是，它以逆序对数组排序,其形式如下：
void arsort(array array [,int sort_flags])
$states=array(“Delaware”,”Pennsylvania”,”New Jersey”);
arsort($states);
print_r($states);
这会返回以下结果：
Array([1]=>Pennsylvania [2]=>New Jersey [0]=>Delaware)这里键/值的关联确实在使用了arsort()函数之后还是保持下来了。

natsort()函数提供了一种相当于人们平常使用的排序机制。其形式如下：
void natsort(array array)
函数natcasesort()在功能上与natsort()相同，只是它不区分大小写:
void natcasesort(array array)
ksort()函数按键对数组排序，如果成功返回TRUE，失败将发挥FALSE。其形式如下：
integer ksort(array array[,int sort_flags])
排序并不代表你对于那些数组中的元素有多么陌生，很多时候，只是想要记住更多的排序的函数而已，当然，通过学习这些函数，我们开始让自己变得越来越充实，同时也越来越充分地尝试想要提高并提升自己对于PHP中更多函数的理解。其实，我们都能够做到，并做得更好。

顶

krsort()函数的操作与ksort()相同，也按键排序，只不过它将以逆序（降序）排序。其原型如下：
integer krsort(array array[,int sort_flags])

usort()函数提供了另一种排序方法，可以使用在该函数中指定的用户自定义比较算法对数组进行排序。其形式如下：
void usort(array array,callback function_name)
<?php
$date=array(’10-10-2003’,’2-17-2002’,’2-16-2003’,’1-01-2005’,’10-10-2004’);
定义了5个日期元素，存放在数组$date内。
sort($dates); 使用了sort()函数用于对数组单元从低到高进行排序。
echo “使用sort()函数对数组进行排序:”;
print_r($dates);
natsort($dates); 使用自然排序算法对数组进行排序。
echo “使用natsort()函数对数组排序:”;
print_r($dates);
function DateSort($a,$b){
如果日期相同，什么都不做。
if($a==$b) return 0;
list($month,$aday,$ayear)=explode(‘-‘,$a);
将$a通过explode()函数将日期通过-分隔打散为数组，并赋值给$month,$aday,$ayear。

list($month,$bday,$byear)=explode(‘-‘,$b);
$amonth=str_pad($amonth,2,”0”,STR_PAD_LEFT);使用str_pad（）函数对$amonth最前面的两位用0进行填充如果最前面的日期数字不存在的话。STR_PAD_LEFT提示填充$amonth的最左侧。

$bmonth=str_pad($bmonth,2,”0”,STR_PAD_LEFT);
$aday=str_pad($aday,2,”0”,STR_PAD_LEFT);
$bday=str_pad($bday,2,”0”,STR_PAD_LEFT);
将日期用字符串连接操作符.重新组合起来
$a=$ayear.$amonth.$aday;
$b=$byear.$bmonth.$bday;
决定日期$a是否大于日期$b
return($a>$b)?1:-1;
}
usort($dates,’DateSort’);
echo “使用用户自定义的DateSort函数对数组进行排序:”;
print_r($dates);
?>
结果如下:
使用sort()函数排序后的数组:
Array([0]=>1-1-2005 [1]=>10-10-2003 [2]=>10-10-2004 [3]=>2-16-2003 [4]=>2-17-2002)
sort()函数其实是根据1,10,10,2,2的方式从低到高来进行排序的。
使用natsort()函数排序后的数组:
Array([0]=>1-01-2005 [3]=>2-16-2003 [4]=>2-17-2002 [1]=>10-10-2003 [2]=>10-10-2004)
其实使用了natsort()函数之后，最开始的使用sort()函数之后的键还是保留了下来，通过自然排序算法，按照1,2,2,10,10的方式来进行排序。
使用用户自定义函数DateSort()对数组进行排序:
Array([0]=>2-17-2002 [1]=>2-16-2003 [2]=>10-10-2003 [3]=>10-10-2004 [4]=>1-10-2005)
使用了usort()函数，通过自定义函数DateSort()的描述之后，日期按照从过去到现在的方式进行了排序。

顶

array_merge()函数将数组合并到一起，并返回一个联合的数组。其形式为:
array array_merge_recursive(array array1,array array2 [,arrayN...])
$class1=array(“John”=>100,”James”=>85);
$class2=array(“Micky”=>78,”John”=>45);
$classScores=array_merge_recursive($class1,$class2);
print_r($classScores);
返回结果：
Array([John]=>Array([0]=>100 [1]=>45)[James]=>85 [Micky]=>78)这里其实原先数组$class1和数组$class2中的重复的键John通过array_merge_recursive函数被合并了，但值100和45还是获得了保留。该保留的时候，PHP就会给予你最为适合的保留方式。这里要提醒大家,array_merge和array_merge_recursive这两个函数的区别在于，当合并数组之后，存在重复的键时，array_merge会覆盖前面存在的键/值对，替换为当前输入数组中的键/值对，而array_merge_recursive()将把两个值合并在一起，形成一个新的数组。就像在这个例子中的一样。
array array_combine(array keys,array values)
例子如下：
$abbreviations=array(“AL”,”AK”,”AZ”,”AR”);
$states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”);
$stateMap=array_combine($abbreviations,$states);
print_r($stateMap);
这将返回如下结果:
Array([AL]=>Alabama [AK]=>Alaska [AZ]=>Arizona [AR]=>Arkansas)
通过array_combine函数，数组$abbreviations中的元素变成新数组$stateMap中的键，数组$states中的元素变成新数组$stateMap中的值。

array array_merge(array array1,array array2 [...,array arrayN])
当然，注意，两个输入数组必须大小相同，不能为空。
$face=array(“J”,”Q”,”K”,”A”);
$numbered=array(“2”,”3”,”4”,”5”,”6”,”7”,”8”,”9”);
$cards=array_merge($face,$numbered);
shuffle($cards); 通过shuffle()函数将合并后的数组$cards中的元素按随机顺序重新排列。
print_r($cards);
这会返回:
Array([0]=>8 [1]=>6 [2]=>K [3]=>Q [4]=>9 [5]=>5
[6]=>3 [7]=>2 [8]=>7 [9]=>4 [10]=>A [11]=>J)
这个数组中的元素之所以这样排列，就是因为shuffle函数在起作用，所以合并后的元素就像打乱了顺序一样，随机排列了。

array_slice()函数将返回数组中的一部分，从键offset开始，到offset+length位置结束。其形式为:
array array_slice(array array int offset [,int length])
offset为正值时，拆分从距数组开头的offset位置开始。如果offset为负值，则拆分从距数组末尾的offset位置开始。

$states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Colorado”,”Connecticut”);
$subset=array_slice($states,4);这里的4指从第5个元素，也就是从California开始取。
print_r($subset);
这将返回:
Array([0]=>California [1]=>Colorado [2]=>Connecticut)
考虑第二个例子，这个例子使用了负长度：
$states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Colorado”,”Connecticut”);
$subset=array_slice($states,2,-2);这里也就是从原来的数组$states中从第3个元素开始取，一直取到倒数第三个元素为止。
print_r($subset);
这将返回：
Array([0]=>Arizona [1]=>Arkansas [2]=>California)

顶

顶

array_splice()函数会删除数组中从offset开始到offset+length结束的所有元素，并以数组的形式返回所删除的元素。其形式为：
array array_splice(array array,int offset[,int length [,array replacement]])
$states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Connecticut”);
$subset=array_splice($states,4);
print_r($states); 这个时候数组$states保留了最前面的四个元素。
print_r($subset); 这个时候数组$subset保留了从第五个元素到之后的两个元素。
这将得到:
Array([0]=>Alabama [1]=>Alaska [2]=>Arizona [3]=>Arkansas)
Array([0]=>California [1]=>Connecticut)

$states=array(“Alabama”,”Alaska”,”Arizona”,”Arkansas”,”California”,”Connecticut”);
$subset=array_splice($states,2,-1,array(“New York”,”Florida”));这里是删除了数组$states从第二个元素之后，直到倒数第二个元素的中间的这些元素。
print_r($states);
返回如下结果:
Array([0]=>Alabama [1]=>Alaska [2]=>New York [3]=>Florida [4]=>Connecticut)
array_intersect()函数返回一个保留了键的数组，这个数组只由一个数组中出现的且在其他每个输入数组中都出现的值组成。其形式如下：
array array_intersect(array array1,array array2[,arrayN...])
下面这个例子将返回在$array1数组中出现的且在$array2和$array3也出现的所有的州：
$array1=array(“OH”,”CA”,”NY”,”HI”,”CT”);
$array2=array(“OH”,”CA”,”HI”,”NY”,”IA”);
$array3=array(“TX”,”MD”,”NE”,”OH”,”HI”);
$intersection=array_intersect($array1,$array2,$array3);
print_r($intersection);
这会返回：
Array([0]=>OH [3]=>HI)这里的键0和3是对应着$array1中的OH和HI所对应的最初始的键。下标是从0开始直到后面的。有时候你会发现，其实取交集也好，还是删除元素也好，其实都是因为相应的键和值有所对应，所以才能够实现交集同时也能够删除数据，下标要严重注意是从0开始的哦，还有一些负数的下标，其实是从最后面开始计数的。最开始的时候通过数字定位出某个元素，同时也能够在倒数的位置同样定位到某个元素。

顶

函数array_intersect_assoc()与array_intersect()基本相同，只不过它在比较时还考虑了数组的键。其形式如下：
array array_intersect_assoc(array array1,array array2 [,arrayN...])
$array1=array(“OH”=>”Ohio”,”CA”=>”California”,”HI”=>”Hawaii”);
$array2=array(“50”=>”Hawaii”,”CA”=>”California”,”OH”=>”Ohio”);
$array3=array(“TX”=>”Texas”,”MD”=>”Maryland”,”OH”=>”Ohio”);
$intersection=array_intersect_assoc($array1,$array2,$array3);
print_r($intersection);
通过调用array_intersect_assoc函数，这会返回这三个数组的公共部分的元素并组成数组。
Array([OH]=>Ohio)
函数array_diff()返回出现在第一个数组中但其他输入数组中没有的值。形式如下：
array array_diff(array array1,array array2[,arrayN...])
$array1=array(“OH”,”CA”,”NY”,”HI”,”CT”);
$array2=array(“OH”,”CA”,”HI”,”NY”,”IA”);
$array3=array(“TX”,”MD”,”NE,”OH”,”HI”);
$diff=array_diff($array1,$array2,$array3);
print_r(intersection);
通过array_diff函数，发现第一个数组$array1跟第二个数组$array2比较时，CT这个元素在第二个数组$array2中是没有的，然后再跟第三个数组$array3做比较，发现CT还是没有。所以，这将返回Array([0]=>CT)
函数array_diff_assoc()与array_diff()基本相同，只是它在比较时还考虑了数组的键。因此，只在第一个数组中出现而不在其他输入数组中出现的键/值对才会返回到结果数组中。其形式如下：
array array_diff_assoc(array array1,array array2[,arrayN...])
$array1=array(“OH”=>”Ohio”,”CA”=>”California”,”HI”=>”Hawaii”);
$array2=array(“50”=>”Hawaii”,”CA”=>”California”,”OH”=>”Ohio”);
$array3=array(“TX”=>”Texas”,”MD”=>”Maryland”,”KS”=>”Kansas”);
$diff=array_diff_assoc($array1,$array2,$array3);
print_r($diff);
这个例子调用了array_diff_assoc函数之后，只返回了”HI”=>”Hawaii”,因为这个键/值对确实在$array1中很特殊，在$array2和$array3中都不存在。
这将返回Array([HI]=>Hawaii)

array_rand()函数将返回数组中的一个或多个键。其形式为：
mixed array_rand(array array[,int num_entries])
$states=array(“Ohio”=>”Columbus”,”Towa”=>”Des Moines”,”Arizona”=>”Phoenix”);
$randomStates=array_rand($states,2); 通过调用array_rand函数随机取得$states数组中的随机两个元素。
print_r($randomStates);
这会返回Array([0]=>Arizona [1]=>Ohio)这里的Arizona和Ohio就是数组$states中的随机两个键。

shuffle()函数随机地对数组中的元素重新排序。其形式为：
void shuffle(array input_array)
考虑一个数组，其中包含表示扑克牌的值：
$cards=array(“jh”,”js”,”jd”,”jc”,”qh”,”qs”,”qd”,”qc”,”kh”,”ks”,”kd”,”kc”,”ah”,”as”,”ad”,”ac”);
对数组$cards中的扑克牌重新排序
shuffle($cards);
print_r($cards);这将返回类似于下面的结果，因为随机洗牌，每个人的结果都有可能不同。
Array([0]=>js [1]=>ks [2]=>kh [3]=>jd [4]=>ad [5]=>qd [6]=>qc [7]=>ah [8]=>kc [9]=>qh [10]=>kd
[11]=>as [12]=>ac [13]=>jc [14]=>jh [15]=>qs)这样一来原来数组$cards中的元素变成了新数组Array中的值。函数这种东西，功能确实是非常强大，其实你改变不了原来数组中的元素，但是你能够改变你所能够改变的那个数组中的那个小你，或者是小他，小她都是一样的。排序也好，取交集也好，都只是为了让自己觉得舒服，让程序员的你开始愿意痴迷在程序员们都愿意痴迷的那个世界中和代码堆里。

顶

array_sum()函数将input_array中的所有值加在一起，返回最终的和。其形式如下：
mixed array_sum(array array)
<?php
$grades=array(42,”hello”,42);
$total=array_sum($grades);
print $total;
?>
这将返回:84 数组$grades中有hello这个字符串的元素，在使用array_sum函数时这个字符串值会被忽略，所以，最后array_sum将42跟42加在一起，最后打印的就是84了。

array_chunk()函数将input_array分解为一个多维数组，它由多个包含size个元素的数组所组成。其形式如下：
array array_chunk(array array,int size [,boolean preserve_keys])
$cards=array(“jh”,”js”,”jd”,”jc”,”qh”,”qs”,”qd”,”qc”,”kh”,”ks”,”kd”,”kc”,”ah”,”as”,”ad”,”ac”);
shuffle($cards); 调用shuffle函数随机排列数组$cards
$hands=array_chunk($cards,4);
使用array_chunk函数将数组$cards分解为四段相同的一维数组，并合并在多维数组中。
print_r($hands);
结果如下（由于随机洗牌，每个人的结果可能有所不同）：
Array([0]=>Array([0]=>jc [1]=>ks [2]=>js [3]=>qd)
[1]=>Array([0]=>kh [1]=>qh [2]=>jd [3]=>kd)
[2]=>Array([0]=>jh [1]=>kc [2]=>ac [3]=>as)
[3]=>Array([0]=>ad [1]=>ah [2]=>qc [3]=>qs))

在PHP的OOP中，有三个基本概念，封装，继承和多态。有时候并不一定要了解事物的内部工作原理，使用计算机，但是并不是每个人都了解计算机的内部工作原理。通过使用接口就能够忽略其内部结构。接口隐藏了这些细节，通过众所周知的接口将用户与实际应用程序的内部工作原理分离，这种方向称为封装。其实更加简单一点，在编写程序时将很多框架的代码封装在一起，只要知道该怎么调用就用非常简单的代码段调用其实也就是封装在PHP编程中的实际意义。

继承，就比如各种职员可以继承一般员工所拥有的共同性质，例如姓名，员工号和工资。还有职员类型可以被白班职员和夜班职员继承。还可以创建一个人类，让员工类可以继承人类，并成为人类的一个子类。面向对象开发方法建立在继承概念的基础之上，通过继承，可以提高代码的可重用性。这样，就可以使我们在多个应用程序中可以使用设计良好的类。设计良好的类，其实也就是这些类足够抽象，从而可以重用。更简单地来说，子女继承了父母的良好的基因，也可能继承不好的基因，但是，通过这种血缘关系的继承性，让人这个最大的类变得越来越有共性，同时也越来越有每个人自己的个性。想要继承的时候，就能够继承一些东西，共性和个性都能够实现，同时也能够互相适应。

多态，其实也就是有多种形态。假设在员工类的定义中有一个“签到”的行为，这个行为对于职员员工来说，可能具体为使用时钟来打卡，而有些其他类型的员工，可能通过网络来签到。虽然职员员工类和其他类型的员工类从员工类继承到这个行为，但具体该怎么实现“签到”就要依赖于实现“签到”的上下文，这就是多态之所以这么强大的原因。

顶

在OOP术语中，实体的性质和行为的具体定义称为类。每个实体都由一组性质和行为来定义。日常环境由无数实体组成：所喜欢的人，所喜欢的事，朋友们，朋友们的兴趣爱好，好像因为这些实体的累积之后，人开始有了自己前进的方向和动力，同时，也不断向前，不断开拓创新，并能够创造出一点什么。类用于表示要在应用程序中处理的实际事物。每个实体所包含的一组组性质和行为，在OOP中分别称为字段和方法，它们定义了实体的同时，也开始慢慢能够成就实体。PHP中一般的类创建语法如下：
class Class_Name
{ //字段声明
//方法声明
}
如下是一个表示员工的类。
class Employee
{
private $name;
private $title; 通过private对$name和$title进行限制，表示私有的，只有本类，也就是类Employee内部才可以使用。
protected $wage; 通过protected对$wage进行限制，表示受保护的，只有本类，也就是类Employee或这个类的子类或父类中可以访问。在子类中可以通过self::属性名（或方法名）调用protected方法或属性，通过parent::属性名（或方法名）调用父类方法。

protected function clockIn(){
echo “Member $this->name clocked in at”.date(“h:i:s”);
protected function clockOut(){
echo “Member $this->name clocked out at”.date(“h:i:s”);
}
}
这个类名为Employee,定义了3个字段name,title和wage。还定义了两个方法：clockIn(签到)和ClockOut(签离)。
类其实提供了一个基础，可以创建一些跟实体有关的特定实例，这些特定实例成为对象。例如对于员工类Employee类，所谓的特定实例就比如郎郎和赵贤等等其他的员工，如果这些员工和朋友们还在的话。根据一些已经预先定义好的类来创建对象常称为类的实例化。
对象使用new关键字创建，如下：$employee=new Employee();创建了对象之后，这个刚实例化的对象就具有了类所定义的所有性质和行为。

在声明字段的时候，可以为字段赋初值。
class Employee
{
public $name=”John”;
private $wage;
}
与变量不同，字段要使用->操作符引用。字段与给定对象之间的对应关系：
$object->field
当然，对于创建了一个名为$employee的Employee类型对象，就可以如下引用这些字段：
$employee->name
$employee->title
$employee->wage
对于$this而言，它表示要引用当前类（要访问或操作的字段所在的类）中的字段。
function setName($name)
{ $this->name=$name; $this其实就相当于引用了原先的Employee类。
}
类和对象，是不是可以这样来理解，我定义了一个抽象的类的概念来包含数据元素和相应的实现方法，我只是想要证明自己不单单只是因为特殊，因为抽象而存在，其实，都只是为了更好地对数据，对各种方法进行整理和收集。最后，代码写完之后，再重新阅读代码的时候，才会发现，类也好，对象也罢，都仅仅只是一种表现数据逻辑的手段，而不仅仅只是肤浅的理解而已。