荒芜的周六-PHP之面向对象（三），周六-php面向对象
hi
又是开森的周六了。积攒的两周的衣服，终于是差不多洗完了。大下午的才来学点东西~~
1、PHP面向对象（三）
四、OOP的高级实践
4.3 Static-静态成员
/**
* 1. 类的定义以class关键字开始，后面跟着这个类的名称。类的名称命名通常每个单词的第一个字母大写。
* 2. 定义类的属性
* 3. 定义类的方法
* 4. 实例化类的对象
* 5. 使用对象的属性和方法
*/
class Human{
public $name;
public $height;
public $weight;
public function eat($food){
echo $this->name."'s eating ".$food."
";
}
}
class Animal{
public $kind;
public $gender;
}
class NbaPlayer extends Human{
// 类的属性的定义
public $name="Jordan";// 定义属性
public $height="198cm";
public $weight="98kg";
public $team="Bull";
public $playerNumber="23";
private $age="44";
public $president="David Stern";
// 类的方法的定义
public function changePresident($newP){
$this->president=$newP;
}
public function run() {
echo "Running
";
}
public function jump(){
echo "Jumping
";
}
public function dribble(){
echo "Dribbling
";
}
public function shoot(){
echo "Shooting
";
}
public function dunk(){
echo "Dunking
";
}
public function pass(){
echo "Passing
";
}
public function getAge(){
echo $this->name."'s age is ".$this->age;
}
function __construct($name, $height, $weight, $team, $playerNumber){
print $name . ";" . $height . ";" . $weight . ";" . $team . ";" . $playerNumber."\n";
$this->name = $name; // $this是php里面的伪变量，表示对象自身
$this->height = $height; // 通过$this可以设置对象的属性值
$this->weight = $weight;
$this->team = $team;
$this->playerNumber = $playerNumber;
}
}
/**
* 1. 类实例化为对象时使用new关键字，new之后紧跟类的名称和一对括号。
* 2. 使用对象可以像使用其他值一样进行赋值操作
*/
$jordan = new NbaPlayer("Jordan", "198cm","98kg","Bull","23");echo "
";
$james=new NbaPlayer("James", "203cm", "120kg", "Heat", "6");echo "
";
// 访问对象的属性使用的语法是->符号，后面跟着属性的名称
echo $jordan->name."
";
// 调用对象的某个方法使用的语法是->符号，后面跟着方法的名称和一对括号
$jordan->run();
$jordan->pass();
//子类调用父类的方法
$jordan->eat("apple");
//试着调用private,直接以及通过内部的public函数
//$jordan->age;
$jordan->getAge();echo "
";
$jordan->changePresident("Adam Silver");
echo $jordan->president."
";
echo $james->president."
";
直接从上述例子开始吧。
这里想得到的是，把两位对象的某一个变量同时变掉。——用static
public static $president="David Stern";
// 类的方法的定义
public static function changePresident($newP){
static::$president=$newP;//这里static换成self更符合规范
}
注意这里static的位置，以及，方法内的::
调用的方法也有所变动。
echo NbaPlayer::$president;echo "
";
NbaPlayer::changePresident("Adam Silver");
echo NbaPlayer::$president;echo "
";
也就是像之前说的，静态成员就是个常量，所以不针对某个具体的对象（不受具体对象的约束）——基于此，定义&赋值&调用都不需要具体的对象参与。
内部调用要用self/static::$...
外部调用，类名::
用处就是所有的对象共用的数据。
--如果内部调用时，变量在父类中
比如说，在上述例子中，父类human中写这么一句话
public static $aaa="dafdfa";
然后在子类nbaplayer中，调用父类的静态成员时，要
echo parent::$aaa;
而外部调用，按照上面说的，类名::，所以，直接父类类名即可
echo Human::$aaa;
--其他
在静态方法中，是无法访问其他变量的，也就是说，不能用$this->
--小结
/**
* 静态成员
* 1. 静态属性用于保存类的公有数据
* 2. 静态方法里面只能访问静态属性
* 3. 静态成员不需要实例化对象就可以访问
* 4. 类内部，可以通过self或者static关键字访问自身的静态成员
* 5. 可以通过parent关键字访问父类的静态成员
* 6. 可以通过类名称在外部访问类的静态成员
*/
4.4 Final成员
--问题
不希望某个类拥有子类；
不希望子类修改父类中的某个变量（避免重写？）
--final
》=php5版本
举个例子
class BaseClass{
public function test(){
echo "BaseClass::test called
";
}
public function test1(){
echo "BaseClass::test1 called
";
}
}
class ChildClass extends BaseClass{
public function test(){
echo "ChildClass::test called
";
}
}
$obj=new ChildClass();
$obj->test();
子类中编写跟父类中完全一致的方法名（内容可以不同），会完成对父类方法的重写！
所以，不希望被重写的父类中的方法，写上final
final public function test(){
依此类推，对于不想有子类的父类，在类名那里写上final
final class BaseClass{
--小结
/**
* 重写和Final
* 1. 子类中编写跟父类完全一致的方法可以完成对父类方法的重写
* 2. 对于不想被任何类继承的类可以在class之前添加final关键字
* 3. 对于不想被子类重写（overwrite, 修改）的方法，可以在方法定义前面添加final关键字
*/
4.5 数据访问
先把final都去掉
--parent
然后再子类中的方法中写
parent::test();
运行后会发现，依然可以通过parent的关键字调用父类中，即使是被重写的数据
--self
然后在父类中的方法test中写
self::test1();
运行后，发现self可以调用同一个类中的数据（其他方法/静态变量/常量const）
--小结
/**
* 数据访问补充
* 1. parent关键字可以用于调用父类被重写的类成员
* 2. self关键字可以用于访问类自身的成员方法，也可以用于访问自身的静态成员和类常量；不能用于访问类自身的属性；访问类常量时不用在常量名称前面加$符号
* 3. static关键字用于访问类自身定义的静态成员，访问静态属性时需要在属性名前面添加$符号
*/
4.6 对象接口
非常重要！！！
--问题
不同的类，有着相同的行为，但相同的行为又有着不同的实现方法。
比如人和动物都会吃东西，但吃的方式方法又不太一样。
--定义
接口就是把不同类的共同行为进行了定义，然后在不同的类里面实现不同的功能。
--栗子
//定义一个接口
interface ICanEat{
public function eat($food);
}
可以看到，接口中并没有方法的具体实现，但必须有方法！
那么，下面是，“人类会吃”
//具体对象，连接到接口
class Human implements ICanEat{
public function eat($food){
echo "Human eating ".$food.".
";
}
}
$obj=new Human();
$obj->eat("shit");
请忽略我给出的“食物”。
注意，不再用extends，而是implements。然后，同样是方法名的完全相同。然后，对象必须/最好实现方法。
继续
interface ICanEat{
public function eat($food);
}
//具体对象，连接到接口
class Human implements ICanEat{
public function eat($food){
echo "Human eating ".$food.".
";
}
}
class Animal implements ICanEat{
public function eat($food){
echo "Animal eating ".$food.".
";
}
}
$obj=new Human();
$obj->eat("shit");
$monkey=new Animal();
$monkey->eat("banana");
让动物也吃起来！
--逆向操作
判断某个对象是否连接了某个接口。
var_dump($obj instanceof ICanEat);
会返回boolean值。
--更多的栗子
interface ICanPee extends ICanEat{
public function pee();
}
class Demon implements ICanPee{
public function pee(){
echo "Can demon pee?";
}
public function eat($food){
echo "Can demon eat ".$food;
}
}
$ghost=new Demon();
$ghost->pee();
$ghost->eat("shit");
接口本质上也是类，可以被继承/继承，但是使用继承接口的接口，所有父类、“爷类”的方法都要有具体实现。
--小结
/**
* 接口
* 1. 接口的基本概念和基本使用方法
* 2. 接口里面的方法没有具体的实现
* 3. 实现了某个接口的类必须提供接口中定义的方法
* 4. 不能用接口创建对象，但是能够判断某个对象是否实现了某个接口
* 5. 接口可以继承接口（interface extends interface）
* 6. 接口中定义的所有方法都必须是公有，这是接口的特性。
*/
aaaaaaaaaaaaaa
bu xiang xie le....................
ming tian yao ge ..............