类与对象基础

类的声明和实例化对象

• 声明类

// class 类名 { }
例:
class demo {
}

• 类中成员

// 类成员:属性&方法
例:
class demo {
    // 属性
    public $a = '这是类属性';
    // 方法
    public function test() {
        return '这是类方法';
    }
}

• 将类实例化得到对象

例:
class demo {
    // 属性
    public $a = '这是类属性';
    // 方法
    public function test() {
        return '这是类方法';
    }
}
// 实例化对象:将实例化出的对象以一个变量来承接 = new 要实例化的类名();
$demo = new demo();
// instanceof用于确定一个 PHP 变量是否属于某一类 class 的实例是返回true否则返回false
// 检测$demo变量名是否是属于demo类的实例化对象
var_dump($demo instanceof demo);

• 调用类中的属性和方法

例:
class demo {
    // 属性
    public $a = '这是类属性';
    // 数组属性
    public $option = [1,2,3];
    // 方法
    public function test() {
        return '这是类方法';
    }
}
// 实例化类得到对象
$demo = new demo();
// 调用类中的属性
// 对象名->属性名
echo $demo->a; // 输出"这是类属性"
// 访问调用类中的数组属性 // 根据索引来访问数组中的指定元素
echo $demo->option[0]; // 输出 1;
// 调用类中的方法
// 对象名->方法名();
echo $demo->test(); // 输出 "这是类方法"

• 类方法中的构造方法

__construct() 构造方法:在本类实例化时自动调用

例:
class demo {
    // 构造方法
    public function __construct {
        return '这是构造方法';
    }
}
// 类只要一实例化就自动调用构造方法
$demo = new demo();
// 打印输出对象
var_dump($demo); // 输出 "这是构造方法";

• 动态类:将类名设置为变量值

例:
class demo {
    // 属性
    public $a = '这是类属性';
    // 方法
    public function test() {
        return '这是类方法';
    }
}
$className = 'demo'; // demo是上面的类名
// 实例化对象
$obj = new $className();
// get_class(对象名); 返回对象所属类名
echo get_class($obj);

类中的静态属性和静态方法的定义及访问

• 静态属性和静态方法的定义

静态属性/静态方法:如果这个属性/方法仅使用一次，可以不创建类实例，而直接通过类来调用

// 静态属性定义:static 属性名 = 属性值;
// 静态方法定义:static 方法名(){}
例:
class demo {
    //静态属性
    public static $a = '这是静态属性';
    // 静态方法
    public static $test() {
        return '这是静态方法';
    }
}

• 类中静态属性和静态方法的调用

例:
class demo {
    //静态属性
    public static $a = '这是静态属性';
    // 静态方法
    public static $test() {
        return '这是静态方法';
    }
}
// 调用静态属性:当前类名::属性名;
demo::$a;
// 调用类中的静态方法:当前类名::方法名();
demo::test();

类中的抽象属性

例:
class demo {
    //定义抽象属性;抽象属性:没被初始化的属性, 默认赋NULL:
    public $salary;
}
// 实例化类
$demo = new demo();
// 检测抽象属性是否是一个空值 
var_dump(is_null($demo->salary));// 返回值true,

访问属性和方法

• 本类中的方法中访问类的属性

例:
class demo {
    // 定义属性
    public $name = '大娃';
    public $age = 100;
    // 定义方法
    public function test() {
        // 实例化当前类
        $demo = new demo();
        // 访问当前类中的类成员
        return "姓名:$demo->name,年龄:$demo->age";
    }
}
// 实例化对象
$demo = new demo();
// 调用类方法
echo $demo->test();  // 输出 "姓名:大娃,年龄:100"

• self和$this

解决类的名称被限定,使用self可以引用当前的类名称:self可以引用当前的类名称

$this会自动创建, $this是只读的，不能被更新 相当于:$this = new self;

类方法中声明的变量,不是属性是类方法的私有变量

例:
class demo {
    // 定义属性
    public $name = '大娃';
    public $age = 100;
    // 定义方法
    public function test2() { 
        // 声明一个变量, 声明在方法中的变量，不是属性，是私有变量/局部变量
        $salary = 8000;
        // 1.解决类的名称被限定,使用self可以引用当前的类名称
        $demo = new self; // 等同于 $demo = new demo();
        // 2.使用$this代替实例化出来的对象名称
        // $this会自动创建, $this是只读的，不能被更新 相当于:$this = new self;
        return "姓名:$this->name,年龄:$this->age,工资:$salary";
    }
}
// 实例化对象
$demo = new demo();
// 调用列中的test2方法
echo $demo->test2(); // 输出 "姓名:大娃,年龄:100,工资:8000"

• 类中的方法访问类外部的成员:变量和函数

class demo {
    public function test3() {
        // 调用外部函数
        $str = hello();
        // 外部变量
        // 通过超全局数组访问外部变量
        return $str.$GLOBALS['username'];
    }
}
// 外部函数
function hello(){
    return 'Hello ';
}
// 外部变量
$username = '葫芦娃';
// 实例化对象
$demo = new demo();
// 调用类中的test3方法
echo $demo->test3();  // 输出 "hello葫芦娃"

• 依赖注入:类中的方法访问类外部的成员:变量和函数

例:
class demo {
    public function test4($hello,$username) {
        return $hello() . $username;
    }
}
// 外部函数传入类中的方法中的两种方法
// 外部函数
function hello()
{
    return 'Hello ';
}
// 方法1:通过动态函数把函数传入类中的方法中
$hello = 'hello';
// 方法2:匿名函数[使用匿名函数把外部的函数传入类中方法中]
$hello = function()
{
    return 'Hello111';
};
// 外部变量
$username = '葫芦娃';
// 实例化对象
$demo = new demo();
//调用类中的test4方法
echo $demo->test4($hello,$username); // 输出 "hell0葫芦娃"

• 使用static声明静态方法:不依赖实例访问类的属性

class demo {
    // 定义属性
    $nation = 'CHINA';
    // 声明方法
    public static function test5() {
        return "葫芦娃的国籍:".self::$nation;
    }
}
// 实例化对象
$demo = new dmeo();
// 调用类中的test5方法
echo $demo->test5(); // 输出 "葫芦娃的国籍:CHINA"

• 普通方法中可以访问静态成员

例:
class demo {
    // 定义属性
    $nation = 'CHINA';
    // 声明方法
    public function test6() {
        return "国籍: " . self::$nation;
    }
}
// 实例化对象
$demo = new dmeo();
// 调用类中的test6方法
echo $demo->test6(); // 输出 "国籍:CHINA"

类的继承

子类继承父类方法:class 子类名 extends 继承的父类名 { }

子类继承了父类可用父类中的除了private关键字定义的属性和方法

例:
// 父类
class demo {
    public function test {
        return "这是父类的方法";
    }
}
// 继承类
class demo1 extends demo {
}
// 实例化子类调用继承父类中的方法
$demo1 = new demo1();
echo $demo1->test(); //输出 "这是父类方法"

类成员的访问控制[成员的作用域]

public[公共的]关键字的属性和方法:在类中和子类中及外部中使用

protected[受保护的]:类内部和子类中可以调用但类外部不可调用

private[私有的]:只可在类的内部中调用,不可再类的外部和子类中调用

例:
class demo {
    // public 公共成员,类外部和内部及子类中均可调用
    public $name = '金刚葫芦娃';
    // private 受保护的 类内部和子类中可以调用但类外部不可调用
    protected $age = 30;
    // 私有的 只可在类的内部中调用,不可再类的外部和子类中调用
    private $wife = '金刚葫芦媳';
    // 类内部方位
    public function test() {
        return "姓名: {$this->name},年龄 : {$this->age}, 媳妇: {$this->wife}";
    }
}
// 实例化对象
$dem0 new demo();
// 调用test方法查看三种关键字是否能正常使用
echo $demo->test(); // 输出 "姓名:金刚葫芦娃,年龄:30,媳妇:金刚葫芦媳" 都可以使用

• 子类中调用三种关键字定义的属性

例:
class demo {
    // public 公共成员,类外部和内部及子类中均可调用
    public $name = '金刚葫芦娃';
    // private 受保护的 类内部和子类中可以调用但类外部不可调用
    protected $age = 30;
    // 私有的 只可在类的内部中调用,不可再类的外部和子类中调用
    private $wife = '金刚葫芦媳';
    }
}
class demo1 extends demo {
    public function test() {
        // 子类中: 只有public 和 protected可见
        return "姓名: {$this->name}, 工资: {$this->age}";
    }
}
// 实例化对象
$demo1 new demo1();
echo $demo1->test(); // 输出 "姓名:金刚葫芦娃,年龄:30"

• 类外部方位三种关键字定义的属性

例:
class demo {
    // public 公共成员,类外部和内部及子类中均可调用
    public $name = '金刚葫芦娃';
    // private 受保护的 类内部和子类中可以调用但类外部不可调用
    protected $age = 30;
    // 私有的 只可在类的内部中调用,不可再类的外部和子类中调用
    private $wife = '金刚葫芦媳';
    }
}
// 实例化对象
$demo1 new demo1();
//调用public关键字的属性
echo $demo->name; // 输出"金刚葫芦娃"
// 调用protected关键字的属性
echo $demo->age; // 输出直接报错,不能访问protectred关键字定义的属性
// 调用private关键字的属性
echo $demo->wife;  // 输出直接报错,不能访问private关键字定义的属性

使用final关键字定义fianl类和fianl方法及final属性

• fianl关键字定义fianl类

fianl类不能被继承

// 定义fianl类:fianl class 类名 { }
例:
fianl class demo {
    public funciton test() {
        return "final类中的方法";
    }
}

• final关键字定义fianl方法

fianl方法不能被子类重写

例:
class demo {
    fianl public function test() {
        return "这是final方法";
    }
}

• final关键字定义fianl属性

final属性也不能被重写

例:
class demo {
    final public $name = '二娃'; 
}