一、类

类是一种具有统一的特征和行为的声明
特征：是属性
行为：方法或者函数

属性有三个标识，1、public:公共的，2、protected:受保护的，3、private：私有的
1、protected和private的属性：不能在外部通过对象的属性直接调用，一般是在类的内部直接使用

//第一步：创建一个people类
class People(){
    public $name = "张三";
     protected $sex = "男";
    private $age = "19";
    //内部才能直接使用对象的protected和private属性
   // $age += 90;  //类内部不能运算，需要在一个函数里面去运算
   // 第三步：函数
    public function setAge($age){
          //$this指当前对象
          $this->age+=1;
          echo $this->age;
    } 
    
}
//第二步：对象化实例
$p1 = new People();
echo $p1->name;   //获得对象对应的属性
echo "<br/>";
//外部直接调用对象的protected和private的属性会报错
//echo $p1->sex;报错    //sex是protected受保护的
//echo $age->age;报错    //age是private私有的

第四步：外部调用public函数
$p1->setAge(10);

提供protected和private两种是为了保证数据的安全

二、格式化输出属性

<?php
    class  People{
        public $name;
        public $age;
        public $sex;
        //格式化输出属性
        public function desc(){
              return "姓名：".$this->name." 年龄".$this->age." 性别".$this->sex."id:".$this->id;
        }
    }
    $p1 = new People();
    $p1 ->name = "李四";
    $p1 ->age = 19;
    $p1 ->sex = "男";
    $p1 ->id = 1001; //人为添加的属性也能在类内部打印
    //不能用echo $p1打印对象，echo只能打印字符串
    echo $p1->$age;  //通过逐一打印对象属性
    //调用public函数打印对象
    echo $p1->desc();   //姓名：李四 年龄：19 性别：男
    $p2 = new People();
    $p2 ->name = "王五";
    $p2 ->age = 15;
    $p2->sex = "不知道";
     echo $p1->desc();   //姓名：王五 年龄：15 性别：不知道
?>

三、构造函数

<?php
    class People{
         public $name;
         public $age;
         public $sex;
         public function desc(){
              return "姓名：".$this->name." 年龄".$this->age." 性别".$this->sex."id:".$this->id;
        }

        //构造函数:系统提供的函数，在new一个对象的时候会自动调用，形参可以给默认值，如果传入实参，就用实参，不然就用形参的值
        public function __construct($name,$age,$sex=”男“){
              $this->name = $name;  //形参$name赋值给属性name
              $this->age = $age;
              $this ->sex = $sex;
        }
    }
    $p1 = new People("张三",19);
  //通过这种方法给对象属性赋值时，需要写一个构造函数，传对应的形参，再讲形参赋给属性
    echo $p1->desc();
  一旦写了构造函数，在创建对象时一定要传入参数
?>

四、析构函数

在对象生命周期结束的时候自动调用

<?php
    class People{
         public $name;
         public $age;
         public $sex;
         public function desc(){
              return "姓名：".$this->name." 年龄".$this->age." 性别".$this->sex."id:".$this->id;
        }
        public function __construct($name,$age,$sex=”男“){
              $this->name = $name;  //形参$name赋值给属性name
              $this->age = $age;
              $this ->sex = $sex;
        }
        //析构函数   在对象使用完（释放）之后调用
        public function __destruct(){
               echo "析构函数";
        }
    }
    $p1 = new People("张三",19);
    echo $p1->desc();
    //到此，对象已经使用完毕，这里会自动调用析构函数
?>

五、面向对象的继承

把一些重复的属性和方法封装到一个类里面，称之为继承

<?php
    class Student{
         public $name;
         public $age;
         public $sex;
         public function move(){
              echo "跑";
         }
         public function __construct($name,$sex,$age){
               $this->name = $name;
                $this->age = $age;
                $this->sex = $sex;
          }
     }
//需要让当前的类继承于对应的类
     class BigStudent extends Student{
          public $score;
          public function __construct($name,$sex,$age,$score){
                parent::__contruct($name,$sex,$age);
                $this->score=$score;
          }
     }
      $s1 = new BigStudent("张三","男",19,80);
      $s1->move();
      echo $s1->name.$s1->sex.$s1->age.$s1->score;
?>

<?php 
    class Zombie{
          public $blood;
          public $speed;
          public function move(){
          
          }
          public function diaoxue(){
          
          }
          public function dead(){
          
          } 
          public function __construct($blood,$speed){
                    $this->blood = $blood;
                    $this->speed = $speed;
          } 
          public function description(){
              return "血量："$this->blood."速度：".$this->speed;
          }
     }
      class   TieTongZombie extends Zombie{
          parent::__construct($blood,$speed);
          public color;
          public function description(){
                 //写法一：
                 //return "血量："$this->blood."速度：".$this->speed."颜色".$this->color;
                //写法二：调用父类函数，再拼接
                 $value = parent::description();
                  return $value."颜色：".$this->color;
          }
      }

      $z1 = new TieTongZombie(100,10,"yellow");  //color属性是子类属性，父类没有
      echo  $z1->description();
?>

注：若一个子类对象属性，子类没有该属性，就在父类里面去找，如果子类有，就调用子类本身，如果子类和父类都有，就调用当前对象

六、private和protected在继承里面的区别

<?php
     class People{
         protected $name;
         function __contruct($name){
               $this->name = $name; 
         } 
     }
     class   Student extends People{
          function __construct($name){
              parent::__construct($name);
          }
          public function my(){
              echo $this->name;  //在子类函数可以调用父类受保护的属性
          }
      }
      $s1 = new Student("张三");
      echo $s1->name;
      $s1 -> my();
?>

1、protected ：子类继承父类属性，只能在类内部使用
2、private：子类不能从父类中继承private所标注的属性