php面向对象编程（oop）基础

php面向对象编程（英语：Object-oriented programming，缩写：OOP），对象是一个由信息及对信息进行处理的描述所组成的整体，是对现实世界的抽象。

个人理解，万物皆对象，通过定义类然后为这个类添加属性方法，再将其实例化的过程为面向对象编程，抽象是抽象了点，但是实质上对象无处不在，看个人如何去定义，有这样一句话“佛说：要有光，于是就有了光”，对象也是如此，你可以成为这个佛，但是编程也是为大众服务的，所以对象也要贴近现实。

本文包含内容：
类的构成、依赖注入、final, self, $this关键字的使用、oop封装与继承。

一.类的构成
1.每个类的定义都以关键字 class 开头，后面跟着类名，后面跟着一对花括号，里面包含有类的属性与方法的定义,类名可以是任何非 PHP 保留字的合法标签。

一个合法类名以字母或下划线开头，后面跟着若干字母，数字或下划线。以正则表达式表示为：[a-zA-Z\x7f-\xff][a-zA-Z0-9\x7f-\xff]*。

2.类属性：一定要有关键词修饰，public（公有的）、private（私有的）、protected（受保护的）、static（静态的）；

3.类方法：一个类可以包含有属于自己的常量，变量（称为“属性”）以及函数（称为“方法”）

4.类实例化：对象引用名 = new 类名([参数列表]) or 对象引用名 = new 类名；

上代码：

<?php
class apple{
    // 类属性 ,一定要有关键词修饰 public private protected static 
   public $ipad = "max";// 默认值
   public $mac;
   public $iphong;
// 类构构造方法/器,创造对象时对对象属性进行初始化辅助，每创建一个对象，__construct()自动会被调用一次
public function __construct($ipad=""){
    $this->ipad = $ipad; //$this 特殊的对象引用 ，代表本对象,专门完成对象内部成员的访问
}
// 类方法
   public function style(){
       echo "There are three";
   }
   public function price(){
       echo "$900";
   }
   public function  size(){
       echo "12 inches";
   }
}
// 类实例化
// 对象引用名 = new 类名([参数列表]) 对象引用名 = new 类名
 $apl = new apple;
// 访问对象属性，对象方法 ->
 echo $apl->style();
 // 将对象重新赋值 在类的外部
 $apl->ipad = 'ipadmini';
 echo $apl->price();

二、依赖注入

class Users{
     public $name = '老胡';
     public function action(Closure $act,string $name1){
         // 在类方法中访问类外部成员：变量，函数
         //$str = act();// 局部变量，非类属性
        //global $name1;
        //return $this->name . "和".$GLOBALS['name1'].$str;
        return $this->name ."和".$name1.$act();
     }
     // 在实际项目中，外部成员应该通过方法参数，注入到成员方法中，而不是在方法中直接调用
 }
 $act = function(){
    return '一起去搓澡';
};
$name1 ="胖子";
 // echo (new Users)->action();
 echo (new Users)->action($act,$name1);// 老胡和胖子一起去搓澡

三、final, self, $this关键字的使用

1.$this ：特殊的对象引用 ，代表本对象,专门完成对象内部成员的访问
2.self 是类内部代替类名的关键字，可以用来在类内部完成静态成员的访问(类常量)以及在类内部实例化对象
3.final :加在类前,表示该类不能被继承加在方法前,表示该方法不能被重写

$this与final上下例子都有使用与注解，这里安排一下self

//在内部实例化
 class credit{
     const CONSTANT ='con';
     private static $age = 18;
     static function getAge(){
         echo credit::$age.'<br>';//18
         echo self::$age.'<br>';//18
         echo self::CONSTANT.'<br>';//con
     }
 }
// 外部使用类名访问
 credit::getAge();

访问静态

// static 标识静态成员(方法，属性)，静态成员只能由类来调用，为所有对象共享
 class User {
     public $name = "大哥";
     public $options = [1,2,3];
     public static $nation = "china";
     public $salary;// 抽象属性
 }
 $user = new User;
 // 访问静态成员 使用:: 范围解析符
 echo User::$nation;//china
 class myClass{
     public $age = 18;
     static $name = "刘亦菲";
     static $count;
 function __construct(){
     self::$count++;
 }
 public static function getCount(){
     return self::$count;
 }
 }
// 对类中的静态属性进行初始化赋值 为0
 myClass::$count = 0;
 $myc = new myClass;
 // 访问静态成员的方法
 echo myClass::$count;
 echo myClass::getCount();
 //echo $myc->getCount(); 通过对象也可以访问静态成员方法

四、oop封装与继承

<?php
/**
 * 封装性
 */
 class User{
     //public 公共成员 , 类外部和内部都能访问
    public $name = '胡八一';
    //private 私有成员,仅限于本类中使用,外部和子类中是访问不到
    private $age = 30;
    //protected 受保护成员,除了外部不可见,内部和子类均可见
    protected $salary = 8000;
    public function write()
    {
        return "姓名{$this->name},年龄{$this->age},工资:{$this->salary}";
    }
 }
 //echo (new User)->age;//Cannot access private property User::$age
 //echo (new User)->salary;//Cannot access protected property User::$salary
 echo (new User)->name;
 echo (new User) -> write();
//子类
echo '<hr>';
class Rob extends User
{
    public function write()
    {
        return "姓名{$this->name},工资:{$this->salary}";
    }
}

<?php
/**
 * 对象的继承与扩展
 * 
 * final:加在类前,表示该类不能被继承
 * final :加在方法前,表示该方法不能被重写
 */
  class User{
    protected $salary = 8000;
      public function write()
    {
        return "工资:{$this->salary}";
    }
 }
//子类
class Rob extends User
{
    //1.扩展
    //属性扩展
    protected $name = "胡歌";
    protected $age= 45;
    //方法扩展
    // public function write()
    // {
    //     return parent::write(). ",age:{$this->age}";
    // }
    //2. 重写
    //属性重写
    protected $salary = 10000;
    //方法重写
    public function write()
    {
        return parent::write(). ",age:{$this->age}";
    }
}
echo (new Rob) -> write();

拓展：
__construct() 构造函数
1.构造函数实例化类的时候会自动调用，
2.子类没有构造函数，会直接调用父类的构造涵数， 继承父类的属性和方法
3.子类和父类都有构造函数，实例子类时不会自动调用父类构造函数，只会调用子类自己的构造函数。

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。