在实例化一个对象的时候，通常需要初始化。 对象被销毁的时候，需要有回收。所以就用到了类里面的两个内置的方法：构造方法和析构方法。

构造方法：

<?php
class Computer{
    public function __construct()   //内置的构造方法，不用调用直接就会执行
    {
        echo "cpu就绪。。";
        echo "主板就绪。。";
        echo "内存就绪。。";
     }
     public function game()
     {
         echo "---玩游戏---";
      }
}
$computer = new Computer();
$computer->game();  //结果为：cpu就绪。。主板就绪。。内存就绪。。---玩游戏---

<?php
class Computer{
    public function __construct($high = 0)   
    {
        if($high){
            echo "高配的cpu就绪。。";
            echo "高配的主板就绪。。";
            echo "高配的内存就绪。。";
         }else{
            echo "cpu就绪。。";
            echo "主板就绪。。";
            echo "内存就绪。。";
         }
     }
     public function game()
     {
         echo "---玩游戏---";
      }
}
$computer = new Computer(1);   // 1这个参数就是构造方法的参数
$computer->game();  //结果为：高配的cpu就绪。。高配的主板就绪。。高配的内存就绪。。---玩游戏---

析构方法：

<?php
class Computer{
    public function game()
    {
        echo "---玩游戏---";
     }
     public function __destruct()    //是析构方法，直接可执行
     {  
          echo "关闭电源。。。";
      }
}
$computer = new Computer();
$computer->game();   //结果为：---玩游戏---关闭电源。。。
//还可以这样 手动释放对象变量
unset($computer);
echo "good job";    //结果为：---玩游戏---关闭电源。。。good job

类常量：

<?php
class Computer
{
    const YES = ture;     //const关键字定义类常量，类常量一般是大写字母和下划线组成
    const NO = false;
    const ONE = 1;
    
    const TWO = self::ONE + 1;    //在类里用self调用类里的常量
    const THREE = self::TWO + 1;
}
var_dump(Computer::THREE);  //在类外面可直接调用类里的常量，结果为：int(3)

调用静态方法self：： 与static：：的区别

selft代表自身；static可以实现后期绑定

命名空间

例如：namespace venter;

         namespace venter\session

调用：命名空间（venter）\ 成员（Imooc()）

将类，函数，常量导入命名空间

例如：

    use venter\session\Imooc();

    use venter\Imooc as Imooc2;

    use function venter\iLIkeImooc;

    use const venter\Imooc;

命名空间需要调用全局空间定义的类需要添加“\”；而方法或者常量不需要，因为方法或者常量发现在当前命名空间没找到的话，会去全局命名空间找

子类继承父类，如果子类没有构造方法，实例化子类的时候会调用父类的构造方法。如果子类中有构造方法，会调用自身子类的构造方法。如果子类中也想调用父类的构造方法，可以用parent调用

组合和继承？

类常量使用见截图

构造函数必须是public，否则不能创建对象。但是如果设置为private，就可以实现单例模式

对象是类的实例，先有类，才有对象。就像配置单和电脑的关系。

类是一个代码模板         

//定义一个类
<?php           //类名以字母或下划线开头，后面可跟字母、数字、下划线。
class Computer {      //类名一般开头的字母大写，为了清晰。当然也可以用小写。
}
$computer = new Computer();  //这个对象赋给了这个变量，这个对象叫做Computer类的一个实例。
var_dump($computer);   //打印出：object(Computer)#1(0){}

<?php
class Computer {     
    public $cpu = 'amd 5000';     //属性     
    public $mainboard = '华硕9000x';  //属性     
    private $hd = 1024;         //属性  
            
    public function game($gameName='')    //方法     
    {                
       echo $this->hd;    //要在类里面调用属性，就用this 可以理解为这个类的一个实例（对象）     
     }                  //打印出：1024     
     public function job($work='写代码')   //方法     
     {           
           echo ($this->game());         
      }
 }
 $computer = new Computer();
 var_dump($computer);    //打印出所有的属性：object(Computer)#1 (3) { ["cpu"]=> string(8) "amd 5000"["mainboard"]=> string(11) "华硕9000x" ["hd":"Computer" :private]=>int(1024)}
 var_dump($computer->cpu);   //调用属性 打印出：string(8)"amd 5000"
 var_dump($computer->hd);  //是私有的，不能给外部对象调用  打印出错  ，只能在类的内部使用。
 ?>
 
 <?php
 class Computer {
    public $cpu = 'amd 5000';      //属性  
    public $mainboard = '华硕9000x';  //属性     
    private $hd = 512;         //属性          
    public function game($gameName='')    //方法     
    {                
        if($this->getHdSize() < 1024){      
           echo "硬盘太小玩不了游戏";  
           return false;          
         }             
         return true;        
      }              
      public function job($work='写代码')   //方法     
      {      
          echo ($this->game());  //整个的结果就是打印出：硬盘太小玩不了游戏     
       }     
       public function getHdSize()       //方法     
       {        
            return $this->hd;   //获取硬盘大小     
        }
}
$computer = new Computer();

面向对象编程 可使项目模块化

重用性：设计的每一个模块都可在项目中重复使用

灵活性：每一个模块都可以很轻松地被替换

扩展性：在现有的模块上添加新功能

    面向对象：项目由一个个对象组建而成，每个对象都是独立的，他们各司其职，最后像搭积木一样，将各种组合起来，就实现了一个项目。

类 的复用可直接用：use 类名

对象复制是浅拷贝，会改变对象值，前面加clone，这不会改变原来值。

class A {
    public static function who()
    {
        echo "A类的who方法";
    }
    public static function test()
    {
         self::who();//输出A类的who方法
         static::who();//后期绑定输出B类的who方法    }    
}
class B extends A {
    public static function who()
    {
        echo "B类的who方法";
    }
}

$this在当前方法使用

self指向当前类

parent指向父类

<?php

class Person
{
    public ststic $hand = "手";
    public ststic function work()
    {
        return "工作";
     }
}

echo (Person::$hand);
echo (Person::$work());

//当属性或方法定义为static后，输出时就不需要实例化类了，直接调用

1.

spl_autoload_register( function( $className ){

    require $className . '.php';

} )

2.

function autoload( $className ){

    require $className . '.php';

}

spl_autoload_register( 'autoload' )

3.方法是在类里面

class Momo{

    function autoload( $className ){

         require $className . '.php';

    }

}

spl_autoload_register( [new Momo, 'autoload' ] )// 第一个参数实例,第二个参数是类的方法

$imooc = new Imooc();
var_dump(#imooc);

命名空间一般对类起作用，方法会自动寻找类名。