PHP 面向对象
创建类和对象及基本操作
// 定义类：首字母大写，大驼峰命名
class Humanity{
// 定义变量
public $name;
public $sex;
public $age = 22;
// 定义常量
const HOME = 'earth';
// 定义方法：首字母小写，小驼峰命名
// 类方法就是一段等待执行的代码，相对于该类所有的实例都是一样的，
// 方法里面本身并不保存数据，在该类所有的实例中方法的代码其实是共享的
public function eat($food){
// $this：表示当前类的对象，一般用在类的方法内
// 调用类变量
echo "{$this->name}正在吃{$food}
";
// 调用类方法
$this->say($food);
}
public function say($content){
echo "还说{$content}真好吃";
}
}
// 创建对象
$kuse = new Humanity();
// 设置对象属性
$kuse->name = "苦涩";
$kuse->sex = "男";
// 调用对象属性
var_dump($kuse->name);
var_dump($kuse->sex);
var_dump($kuse->age);
// 添加属性，只存在于当前对象，其他对象没有该属性
$kuse->id = 12;
var_dump($kuse->id);
// 调用对象方法
$kuse->eat("苹果");
?>
对象的遍历、复制、比较、序列化等
// 定义类：首字母大写，大驼峰命名
class Humanity{
// 定义变量
public $name;
public $sex;
public $age = 22;
// 定义常量
const HOME = 'earth';
// 定义方法：首字母小写，小驼峰命名
// 类方法就是一段等待执行的代码，相对于该类所有的实例都是一样的，
// 方法里面本身并不保存数据，在该类所有的实例中方法的代码其实是共享的
public function eat($food){
// $this：表示当前类的对象，一般用在类的方法内
// 调用类变量
echo "{$this->name}正在吃{$food}
";
// 调用类方法
$this->say($food);
}
public function say($content){
echo "还说{$content}真好吃";
}
}
// 创建对象
$kuse = new Humanity();
// 设置对象属性
$kuse->name = "苦涩";
$kuse->sex = "男";
// 遍历对象
echo '---------------遍历对象---------------';
foreach ($kuse as $key=>$val){
var_dump($key);
var_dump($val);
}
// 判断一个对象是不是属于一种特定的类型
echo '---------------判断对象类名---------------';
var_dump($kuse instanceof Humanity);
// 获取某个对象是由哪个类创建出来的
echo '---------------获取对象的类名---------------';
var_dump(get_class($kuse));
// 对象的引用：默认按引用传递（地址传递）
echo '---------------对象的引用---------------';
$tongKu = $kuse;
var_dump($tongKu);
$kuse->name = "痛苦";
var_dump($tongKu);
// 对象的复制
echo '---------------对象的复制---------------';
$clone_kuse = clone $kuse;
var_dump($clone_kuse);
$kuse->age = 24;
$clone_kuse->name = "克隆苦涩";
var_dump($clone_kuse);
// var_dump($kuse);
// 对象的比较
echo '---------------对象的比较---------------';
$A = new Humanity();
$A->name = "A";
$A->sex = "女";
$B = new Humanity();
$B->name = "A";
$B->sex = "女";
// ==：属性和属性值都相等，且为同一个类的实例
var_dump($A==$B);//true
// ===：两个对象变量一定要指向某个类的同一个实例（同一个对象）
var_dump($A===$B);//false
$AA = $A;//同一个实例
var_dump($AA === $A);//true
$clone_A = clone $A;//克隆A
var_dump($clone_A === $A);//false
// 对象序列化：将对象转换成字符串
// 序列化一个对象将会保存其所有变量及类名，但是不会保存对象的方法
echo "---------------对象序列化-------------";
$str = serialize($kuse);
var_dump($str);
// 反序列化
// 能够重新把字符串变回PHP原来的值
$unstr = unserialize($str);
var_dump($unstr);
// $unstr->eat('苹果');
echo "---------------销毁对象-------------";
unset($kuse);
// var_dump($kuse);
?>
构造函数和析构函数
// 定义类：首字母大写，大驼峰命名
class Humanity{
// 定义变量
public $name;
public $sex;
public $age = 22;
// 定义常量
const HOME = 'earth';
// 定义构造函数
public function __construct($name, $age){
$this->name = $name;
$this->age = $age;
}
// 定义析构函数
// 在该类的实例被销毁时自动调用
public function __destruct(){
echo "啊~~~，{$this->name} 被销毁了！！！
";
}
// 定义方法：首字母小写，小驼峰命名
public function eat($food){
echo "{$this->name}正在吃{$food}
";
}
}
// 创建对象
$kuse = new Humanity("苦涩", '男');
echo $kuse->name;
?>
继承
// 定义类：首字母大写，大驼峰命名
class Humanity{
// 定义变量
public $name;
public $sex;
public $age = 22;
// 定义常量
const HOME = 'earth';
// 定义构造函数
public function __construct($name, $age){
$this->name = $name;
$this->age = $age;
}
// 定义析构函数
// 在该类的实例被销毁时自动调用
public function __destruct(){
echo "啊~~~，{$this->name} 被销毁了！！！
";
}
// 定义方法：首字母小写，小驼峰命名
// 在方法前面加上final，就不能再被子类重写，属性不能定义为final
public function eat($food){
echo "{$this->name} 正在吃 {$food}
";
}
}
// 继承
// Student类继承了Humanity类
// 子类继承了父类的属性和方法，并且还可以定义自己的属性和方法
class Student extends Humanity {
public $stuId;
public function test($subject){
echo "{$this->name} 正在考 {$subject}
";
}
// 方法重写，参数的个数要和父类一致，构造函数的参数个数无需和父类里面的构造函数的参数个数一致
public function eat($food){
echo "{$this->name} 正在快速吃 {$food}
";
}
}
// 创建子类对象
$kuse = new Student("苦涩", '男');
$kuse->stuId = "123";
echo $kuse->stuId;
$kuse->test("数学");
$kuse->eat("菠萝", 3);
// 获取父类的类名
var_dump(get_parent_class($kuse));
?>
可见性
可见性分为：public（公共的）、protected（受保护的）、private（私有的）
本类里面
- 可以 访问可见性为public的属性
- 可以 访问可见性为protected的属性
- 可以 访问可见性为private的属性
子类里面
- 可以 访问可见性为public的属性
- 可以 访问可见性为protected的属性
- 不能访问可见性为private的属性
类的外面
- 可以 访问可见性为public的属性
- 不能访问可见性为protected的属性
- 不能访问可见性为private的属性
范围解析操作符、静态成员
class Humanity{
public $name;
public $sex;
public $age = 22;
// 类常量
const HOME = "地球";
// 静态属性
static public $counter = 0;
// 定义构造函数
public function __construct($name, $age){
$this->name = $name;
$this->age = $age;
}
public function eat($food){
echo "{$this->name} 正在吃 {$food}
";
}
public function hello(){
echo "父类：你好，我是来自"
.self::HOME."的外星人";
}
}
class Student extends Humanity {
public $stuId;
// 类常量
const HOME = "火星";
public function test($subject){
echo "{$this->name} 正在考 {$subject}
";
}
public function eat($food){
echo "{$this->name} 正在快速吃 {$food}
";
}
public function hello(){
echo "子类：你好，我是来自"
.self::HOME."的外星学生";
echo "子类：你好，我是来自"
.parent::HOME."的外星学生";
// 在子类里面访问父类中的方法（被重写了的方法）
parent::hello();
}
static public function say(){
echo "子类中的静态方法：你好，我是来自"
.self::HOME."的外星学生";
}
}
// 范围解析操作符
// 作用：
// 一：访问类里面的静态成员----------------------------------------------
// *****怎样定义？*****
// 在定义类属性或者方法的时候，在可见性的前面或者后面加上static即可
// static 可见性 $属性名；
// 访问这些静态属性的时候和类常量一样！不同的地方在于：类常量不能修改其值，静态属性可以修改值！
// 每一次修改都会记录
// 注意：需要写上$
echo Humanity::$counter;
// static 可见性 function 方法名称(){}
// 注意：静态方法里面不可以使用$this
Student::say();
// *****作用：********
// 静态成员和具体的实例没有关系！我们在使用这些成员的时候无需通过具体的实例！
// 静态方法，访问的时候无需通过具体的实例
// 二：访问类里面的常量--------------------------------------------------
// ******类内部如何访问？**************
// self::类常量名
// parent::类常量名（访问父类中的常量名）
$a = new Humanity("苦涩", '男');
$a->hello();
$b = new Student("痛苦", '男');
$b->hello();
// *****类外部如何访问？*****************
// 类名称::类常量名
echo Humanity::HOME.'
';
// 三：在子类里面访问父类中的方法（被重写了的方法）--------------------------
// parent::方法名();
?>
抽象类和抽象方法
// 抽象类
// 抽象类的使命就是用来被其他类继承拓展的，直接实例化抽象类没有意义
abstract class Humanity{
public $name;
public $sex;
// 定义构造函数
public function __construct($name, $age){
$this->name = $name;
$this->age = $age;
}
// 抽象方法
// 不需要定义方法的具体功能，具体功能由子类来完成
abstract public function eat($food);
}
class Student extends Humanity {
// 继承父类抽象方法，并重写
public function eat($food){
echo "{$this->name} 正在快速吃 {$food}
";
}
}
// -----------------------抽象类------------------------------------
// 从语法上去限制某个类不能够被直接实例化（限制一个父类不能够被直接实例化）
// -----------------------抽象方法------------------------------------
// 不需要定义方法的具体功能，具体功能由子类来完成
// 注意：在子类里面具体实现抽象方法的时候，可见性要等于高于父类里面的可见性
// 参数个数要一致
// 在子类里面必须要去实现抽象类里面的抽象方法
// 只有抽象方法里面才可以有抽象方法，抽象类里面不一定要有抽象方法
new Student('苦涩', '女');
?>
接口
interface iA{
public function aa();
public function bb();
}
interface iB{
public function cc();
}
class A implements iA, iB{
public function aa(){
}
public function bb(){
}
public function cc(){
}
}
// -----------------------接口------------------------------------
// 接口是用来规定一个类应该怎么去写、规定一个类必须要去实现哪些方法
?>
traits
// ------------------------traits-----------------------
// 使得类里面的代码（主要指属性和方法）更加灵活的被复用
// traits和include有点相似
// 通过include技术可以引入文件
// 通过traits技术可以引入代码
trait tA{
public function aa(){
echo "traits: aa....
";
}
public function bb(){
echo "bb....
";
}
}
abstract class Dog {
public function aa(){
echo "父类：aa....
";
}
use tA;
}
class Huskies extends Dog{
public function aa(){
echo "子类：aa....
";
}
// use tA;
}
$a = new Huskies();
// 优先级：父类 < traits < 子类
$a->aa();
$a->bb();
?>
魔术方法
// ------------------------魔术方法-----------------------
// 在特定时机自动执行
// 魔术方法以 __ 开头
// 注意：自己定义方法时，不要以 __ 开头
// 1. __construct()
// 2. __destruct()
// 3. __set($name, $value)
// 在给不可访问(不存在或可见性不够)的属性“赋值”时会自动执行
class Human {
public function __set($name, $value){
echo "{$name}:{$value}
";
}
public function __get($name){
echo "{$name}
";
}
public function __call($funName, $arr){
var_dump($funName);//方法名
var_dump($arr);//方法参数
}
}
$ren = new Human();
$ren->hhh = '哈哈哈';
// 4. __get($name)
// 在读取不可访问的属性时，自动自行
var_dump($ren->hihi);
// 5. __call($name, $arr)
// 在对象中调用一个不可访问的方法时，自动调用
$ren->hello('hhh', 'hihihi');
?>