5月6日学习

关键词

1. 类：class，是定义面向对象主体的最外层结构，用来包裹主体的数据和功能（函数）。类是一类具有共性事务的代表，代表的是事务的共性。
2. 对象：object，是某类事务的具体代表，也是实际数据和功能操作的具体单元，也被称之为实例（instance）
3. 实例化：new，从一个抽象的概念(类)得到一个符合抽象概念的具体实例(对象)的过程
4. 类成员：member，指类class结构中的所有内容，类成员里有三种

• 方法：method，本质是在类class结构中创建的函数，也称之为成员方法或者成员函数
• 属性：property，本质是在类class结构中创建的变量，也称之为成员变量
• 类常量：constant，本质是在类class结构中创建的常量

总结：面向对象基础中没有本质多出很多东西，基本只是将原来面向过程的内容进行一层包裹而已。

简单技术实现

定义：面向对象思维的实现，就是利用面向对象提供的关键字和代码规范来进行编程，而这里面最核心的两个部分就是类class和对象object

1. 定义类基本语法：class 类名{}

<?php  
//定义一个空类
class Nothing{
}

1. 类class是一种结构，如果写好没有语法错误的情况下，代码不会执行（与函数定义一样），也无法打印输出

<?php
class Nothing{}
var_dump(Nothing);        //错误，提示未定义的常量

1. 类的命名规范：类的命名规范与函数类似，区别在于人为的通常会将类名的首字母大写

<?php
//有效类名
class My1{}
class My_1{}
class _My1{}
//无效类名
class 1My{}
class 1_my{}

1. 如果碰到多单词组成的类名，通常使用驼峰法

<?php
class MyClass{}

1. 类无法直接访问，需要得到类的具体对象才能访问，可以通过实例化new来实现对象的创建：new 类名[()]

<?php
class My{}
new My;            //创建一个My类的对象
new My();        //创建一个My类的对象

1. 对象创建后可以直接使用或者打印，但是为了方便后续使用，通常使用变量保存实例化的对象

<?php
class My{}; 
var_dump(new My);    //直接打印输出实例化产生的对象
$object = new My;        //保存对象
var_dump($object);
//打印结果
object(My)#1 (0) { } object(My)#2 (0) { }
object：对象
(My)：类名 
#1：编号
(0)：成员变量（属性）个数   
{}：具体成员变量信息（键值对）

总结

1. 通过class关键字 + 类名 +{}创建类
2. 类是一种结构，不会自动运行，也不能输出
3. 通过new 类名实例化对象得到类的具体对象（具象）
4. 可以通过new实例化无限个对象

类成员

定义：类成员，指直接定义在类结构{}内部的一级成员，即直接依赖{}的成员。在PHP中类成员有三种：成员变量（属性），成员方法（成员函数）和类常量

1. 成员变量：就是在类结构{}下直接定义的变量，但是定义的方式与普通变量稍微有点不同，需要在变量名字前使用一个关键字public，定义语法：public 变量名字 [= 值];，成员变量可以赋值也可以不赋值。

<?php
//定义买家类：买家有姓名，有钱
class Buyer{
    //$name;            //错误
    public $name;         //正确：没有赋值
    public $money = 0;     //正确：有赋值
}

1. 成员变量访问：成员变量必须通过对象才能进行访问，也就是需要先通过实例化得到对象，然后通过对象实现对成员变量的增删改查：访问语法：$对象名->属性名;

<?php
#定义买家类
class Buyer{
    public $name;    
    public $money = 0;     
}
$b = new Buyer();
//访问属性
echo $b->money;
//修改属性
$b->money = 1000;
//删除属性
unset($b->name);
//新增属性
$b->age = 20;

注意：删除属性和新增属性通常使用较少，更多的属性操作是访问和修改

1. 成员方法：就是在类结构{}下定义的函数，函数内部的内容与原来函数结构一样，可以有分支、循环结构等

<?php
//定义买家类
class Buyer{
    //定义方法
    function display(){
        echo __CLASS__;    
    }
}

1. 成员方法访问：成员方法也是需要通过对象进行访问的，访问语法为：$对象名->方法名字();

<?php
//定义买家类
class Buyer{
    //定义方法
    function display(){
        echo __CLASS__; //__CLASS__魔术常量指当前的类名
    }
}
//实例化
$b = new Buyer();
$b->display();

1. 类常量：类常量是在类结构{}下定义的常量，类常量的定义只能使用一种方式：const 常量名 = 值;

<?php
//定义买家类
class Buyer{
    //定义类常量
    const PI = 3.14;
}

注意：类常量不是由对象来进行访问，所以暂时不做访问讲解，到后面知识再讲。

1. 类成员中：属性、类常量和方法都可以无限定义，但是定义的原则是相关性。除了以上三个类成员，不能在类结构{}中直接写其他任何代码

<?php
class Buyer{
    echo __CLASS__;                    //错误
    define('PI',3.14);                 //错误
    if(true){ echo 'hello world'}     //错误
}

总结

1. PHP类结构中有三种成员：属性、方法和类常量
2. 类结构中只能有三种成员，不限数量，其他代码需要写到方法里面，否则报错
3. 类中属性和方法的访问方式都是通过对象来调用：%EF%BC%9B%E6%B3%A8%E6%84%8F%E5%B1%9E%E6%80%A7%E5%90%8D%E4%B8%8D%E5%B8%A6#card=math&code=%E5%AF%B9%E8%B1%A1-%3E%E5%B1%9E%E6%80%A7%E5%90%8D%2F%E6%96%B9%E6%B3%95%E5%90%8D%28%29%EF%BC%9B%E6%B3%A8%E6%84%8F%E5%B1%9E%E6%80%A7%E5%90%8D%E4%B8%8D%E5%B8%A6)符号
4. 类中定义属性不能直接使用属性名，需要使用符号public修饰

访问修饰限定符

定义：访问修饰限定符，是一种用在属性或者方法前的修饰关键字，是用来控制属性或者方法的访问位置的。在PHP中访问修饰限定符分为三种：public、protected和private

1. 首先需要明白一组概念类的内部和外部

• 类内部：是指类定义的内容内部，即类名后{}内部
• 类外部：是指类定义的外部内容，即类名后{}之外的所有地方
• 类成员的访问权限控制是内部访问（私有）、链内部访问（受保护）和全部访问（公有）

1. public：公有，即表示所修饰的内容（属性或者方法）可以在当前类的内部访问，也可以在类的外部访问

<?php
class Saler{
  //公有属性
  public $count = 100;
}
$s = new Saler();
echo $s->count;                //正常输出100

1. protected：受保护，即表示所修饰的内容只能在类的内部访问（在学习继承时再讲）

<?php
class Saler{
  //受保护属性
  protected $discount = 0.8;
}
$s = new Saler();
echo $s->discount;                //错误：受保护属性不允许在类外访问

1. private：私有，即表示所修饰的内容只能在当前类的内部访问

<?php
class Saler{
  //私有属性
  private $money = 100;
}
$s = new Saler();
echo $s->money;                //错误：私有属性不允许在类外访问

1. 访问修饰限定符不只是限定属性，也用来限定方法

<?php
class Saler{
  //属性
  public $count = 100;
  protected $discount = 0.8;
  private $money = 100;
  public function getCount(){}    
  protected function getDiscount(){}
  private function getMoney(){}
  function getAll(){}                    #如果没有指定访问修饰限定符，默认public
}

总结

1. 访问修饰限定符分为三种：public、protected和private，访问权限依次降低
2. 访问修饰限定符限定的是成员到底在哪里能被访问，私有和受保护都只能在类内部访问，公有可以在任何地方访问（但都必须是对象去访问）
3. 属性必须写清楚访问修饰限定符，方法可以省去（不建议），因为系统默认是public

类内部对象

定义：面向对象规范是指我们在开发时，在技术没有强制规定的情况下，应该采用什么样的方式来协助我们进行代码的书写。

1. 属性的初始化：属性是类对于同类事务所抽离出来的共性数据，本身在类结构中没有价值，是当具体对象产生之后，属于对象本身的。因此在进行类中定义属性的时候，通常不会对属性进行初始化，除非属性本身的值也具有共性

<?php
class Saler{
      //属性
      public $count;                
    //某个卖家拥有的商品数量，每位具体卖家对象拥有的不可能一样，所以没必要初始化
      protected $discount;
    //某个卖家针对销售的折扣，同样没有统一的价值
      private $money = 0;
    //某个卖家的账户余额，任何一位卖家一开始做生意的时候，账户余额都为0，所以可以初始化
?>

1. 属性的初始化：属性在类中初始化的基本判定就是数据是否初始化的时候统一，如果数据统一（即初始化），那么所有对象在生成之后，就拥有对应的值；如果不初始化，意味着所有对象在生成后，应该对属性进行赋值。

<?php
class Saler{
      //属性
      public $count;                
      private $money = 0;
}  
//实例化
$s1 = new Saler();
$s2 = new Saler();    //所有对象都有两个属性，其中$count都没有数据，而$money都为0
//生成对象后，对象对自己的属性进行初始化
$s1->count = 100;    
$s2->count = 1000;
?>

1. 访问修饰限定符选择：访问修饰限定符是用来限制类成员被对象访问时对象所处位置的。访问的权限从public、protected到private依次变小。使用规则如下：

• 设定好的类成员本身不会被外部用到，那么应该使用private或者protected
• 设定好的类成员一定会给外部访问，使用public
• 属性通常private居多，如果需要外部访问属性，通常会定义相关方法来实现属性的查看和修改，因为可以在方法内对数据逻辑进行代码控制，安全
• 总之一句话：尽可能增加类对成员的控制（尽可能多使用private，少使用public）

<?php
class Saler{
      //属性
      public $count;                
      private $money = 0;
    //增加方法操作私有属性money
    public function getMoney(){
        return $this->money;
    }
    public function setMoney($money){
        //可以对逻辑进行修改，对数据进行安全判定，保证数据的安全性
        $this->money = $money;
        //$this->money是属性，$money是外部传入的参数，二者同名但是性质完全不同
    }
}

总结

1. 属性在类中定义的时候，通常不会初始化值，除非所有类实例化得到的对象的某个属性需要是统一值
2. 应该尽可能增加类对成员的控制，即使用范围较小的访问修饰限定符优先
3. 属性通常是私有化的，一般是通过设定方法来实现属性的访问和修改