PHP大牛成长之路：类与对象

1.类/属性/方法命名规则

建议遵循PSR-2命名规范和PSR-4自动加载规范

• 类的命名采用驼峰法（首字母大写），例如 User、UserType；
• 属性的命名使用驼峰法（首字母小写），例如 tableName、instance；
• 方法的命名使用驼峰法（首字母小写），例如 getUserName；

2.类的创建与访问：

// 1、类的声明:使用class+类名{}进行声明
class Class1
{
    //类的属性
    public $webSite = 'PHP中文网';     //类属性
    public static $hello = 'hello';   //静态属性
    public $domain;                   //抽象属性(未赋值)
    //类的方法
    function getDomain()
    {
        return $this->domain='www.php.cn';
    }
}
// 2、类的访问
// 类的访问必须先示例化(创建对象的对象)
$obj = new Class1();
//访问类中静态属性：使用双冒号: 范围解析符
echo Class1::$hello;  //输出：hello
//访问类属性：
echo $obj->webSite;   //输出：PHP中文网
//访问类中抽象属性
$obj->domain='www.php.cn';   //对象属性赋值
echo $obj->domain;    //输出：www.php.cn
//访问类中方法
echo $obj->getDomain();   //输出：www.php.cn

2.成员的访问控制:

• public: 公共成员, 类外部和内部以及子类中均可使用

• private: 私有成员，仅限于本类内部使用，外部或子类均不可见

• protected: 受保护成员, 除了外部不可见，内部和子类中均可见

2.1 public 示例

//创建父类
class Father
{
    // public: 公共成员, 类外部和内部以及子类中均可使用
    public $a='public str';
    //public：类公共方法
    public function fPublic()
    {
        return $this-> a;
    }
}
//创建子类&继承父类
class Son extends father
{
    public function sPublic()
    {
        return $this-> a;
    }
}
// 类外部
// 子类继承父类，只需要实例化子类
$objclass = new son();
// 外部访问公共属性：$a
echo $objclass -> a;  //输出结果：public str
// 父类内部访问公共属性：$a
echo $objclass -> fPublic();  //输出结果：public str
// 子类内部访问公共属性：$a
echo $objclass -> sPublic();  //输出结果：public str

2.2 private 示例

//创建父类
class Father
{
    // private: 私有成员，仅限于本类内部使用，外部或子类均不可见
    private $a='private str';
    //public：类公共方法
    public function fPublic()
    {
        return $this-> a;
    }
}
//创建子类&继承父类
class Son extends father
{
    public function sPublic()
    {
        return $this-> a;
    }
}
// 类外部
// 子类继承父类，只需要实例化子类
$objclass = new son();
// 外部访问私有属性：$a
// var_dump($objclass -> a);   //输出为NULL (不可访问)
// 父类内部访问私有属性：$a
var_dump($objclass -> fPublic()); //输出:private str (正常访问)
// 子类内部访问私有属性：$a
// var_dump($objclass -> sPublic());  //输出为NULL (不可访问)

2.3 protected 示例

//创建父类
class Father
{
    // protected: 受保护成员, 除了外部不可见，内部和子类中均可见
    protected $a='protected str';
    //public：类公共方法
    public function fPublic()
    {
        return $this-> a;
    }
}
//创建子类&继承父类
class Son extends father
{    
    public function sPublic()
    {
        return $this-> a;
    }
}
// 类外部
// 子类继承父类，只需要实例化子类
$objclass = new son();
// 外部访问保护属性：$a
// var_dump($objclass -> a);   //出错 (不可访问)
// 父类内部访问保护属性：$a
var_dump($objclass -> fPublic()); //输出:private str (正常访问)
// 子类内部访问保护属性：$a
var_dump($objclass -> sPublic());  //输出:private str (正常访问)

3.类方法访问类属性方法

class User
{
    // 类属性
    public $name = '胡八一';
    public $age = 40;
    public static $nation = 'CHINA';
    // 类方法实例化访问类属性
    public function write1()
    {
        // 1. 实例化
        $user = new User;
        // 2 访问类成员
        return "姓名:{$user->name},年龄: {$user->age},国籍:{$user::$nation}";
    }
    // 类方法使用$this和self访问类属性
    // $this:不受类名限定,使用$this引用当前类实例
    // self:不受类名限定,使用self可以引用当前的类名称
    public function write2()
    {
        //1. 实例化
        //$this相当于自动实例化：$this = new self;（不需要写） $this是只读的，不能被更新
        // 2 访问类成员
        return "姓名:{$this->name},年龄: {$this->age},国籍:".self::$nation;
    }
}
// 客户端代码
$user = new User;
// 类方法实例化访问类属性
echo $user->write1();  //输出:姓名:胡八一,年龄: 40,国籍:CHINA
// 类方法使用$this和self访问类属性
echo $user->write2();  //输出:姓名:胡八一,年龄: 40,国籍:CHINA

4.类方法中访问(类)外部成员: 变量和函数

方法1：GLOBALS 引用外部变量，不推荐使用

// 类方法中访问(类)外部成员: 变量和函数
class User
{
    public function write()
    {
        // 调用外部函数
        $str = hello();
        // 外部变量
        return $str . $GLOBALS['username'];
    }
}
//外部变量
$username='胡八一';
//外部函数
function hello()
{
    return 'Hello ';
}
// 客户端代码
$user = new User;
echo $user->write();  //输出：Hello 胡八一

方法2：依赖注入方式：推荐使用

// 类方法中访问(类)外部成员: 变量和函数
class User
{
    // 实际项目中，外部成员应该通过方法参数注入到方法，而不是在方法中直接调用
    // 依赖注入
    public function write(Closure $hello, string $username)
    {
        return $hello() . $username;
    }
}
//外部变量
$username='胡八一';
//外部函数(匿名函数)
$hello = function()
{
    return 'Hello ';
};
// 客户端代码
$user = new User;
echo $user->write($hello, $username);//输出：Hello 胡八一

4.类的继承

4.1 继承

// 类的继承/扩展
// 变量是数据复用,函数是代码复用, 继承就是类的复用
class Father
{
    // 属性
    protected $name = '胡八一';
    // 方法
     public function write()
    {
        return "姓名: {$this->name}";
    }
}
// 扩展类/子类
class Son extends Father
{
    // 属性扩展
    protected $age = 30;
    // 方法扩展
    public function write()
    {
        return parent::write() . ", 年龄: {$this->age}";
    }
}
// 调用 
$rob = new Son;
echo $rob->write();  //输出：姓名: 胡八一, 年龄: 30

4.2 继承重写

class Father
{
    // 属性
    protected $name = '胡八一';
    // 方法
     public function write()
    {
        return "姓名: {$this->name}";
    }
}
// 扩展类/子类
class Son extends Father
{
    // 属性扩展
    protected $age = 30;
    // 属性重写
    protected $name = '王胖子';
    // 方法重写
    public function write()
    {
        return "{$this->name} : {$this->age} 岁";
    }
}
// 调用 
$rob = new Son;
echo $rob->write();  //输出：王胖子 : 30 岁

可以使用关键字：final 禁止重写 （在类或方法前面加表示禁止类或方法重写）

总结：

1、了解了类的创建与访问；
2、了解了类成员的访问控制；public private protected
3、了解了类方法中访问类属性方法；
4、了解了类的继承与重写。