day1

1.类的基本定义

定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。

<?php
class Demo 
{
    public $var1; //变量
    public $var2 = false;  // 变量初始化值

    //构造方法
    public function __construct($var1) 
    {
        $this->var1 = $var1;
    }

    //定义方法
    public function func ($var2) 
    {
        $this->var2 = true;
    }
}

$demo = new Demo('Function parameter'); //使用 new 运算符来实例化该类的对象
$demo->func(); //调用成员函数
var_dump($demo);

结果：

object(Demo)#1 (2) {
      ["var1"]=>
      string(18) "Function parameter"
      ["var2"]=>
      bool(true)
}

• 类使用 class 关键字后加上类名定义。
• 类名后的一对大括号({})内可以定义变量和方法。
• 类的变量使用 var来声明, 变量也可以初始化值（var定义变量视为公有），也可用 public（公有），protected（受保护）或 private（私有）来设置变量的访问控制。
• 函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。
• 变量 $this 代表自身的对象。

day2

2.Getter 和 Setter使用

在面向对象编程思想当中，getter和setter是两个比较有用和重要的概念，掌握他们的应用场景对我们学习面向对象有非常大的帮助，带来安全性和代码业务逻辑控制。

setter的使用

<?php

class Person
{
    public $name;
    public $age;

    public function __construct($name)
    {
        $this->name = $name;
    }

    //比如某网站限制未满18岁不可访问
    public function setAge($age)
    {
        //实现代码逻辑或者业务控制
        if($age < 18){
            throw new Exception('Under age');
        }
        $this->age = $age;
    }

}

$somessii = new Person('somessii');
$somessii->setAge('16');

var_dump($somessii);

结果：抛出异常

Fatal error: Uncaught Exception: Under age in D:\Laravel\php-oop\Person.php:17
Stack trace:
#0 D:\Laravel\php-oop\Person.php(25): Person->setAge('16')
#1 {main}
  thrown in D:\Laravel\php-oop\Person.php on line 17

getter的使用

<?php

class Person
{
    public $name;
    public $age;

    public function __construct($name)
    {
        $this->name = $name;
    }

    //比如某网站限制未满18岁不可访问
    public function setAge($age)
    {
        //实现代码逻辑或者业务控制
        if($age < 18){
            throw new Exception('Under age');
        }
        $this->age = $age;
    }

    public function getAge()
    {
        return $this->age;
    }
}

$somessii = new Person('somessii');
$somessii->setAge('20');

var_dump($somessii->getAge());   //结果：string(2) "20"

• getter和setter方法命名规则：以get或者set开始，采用驼峰式方式命名。比如：setAge()、setUserName()、getUserName()等。

3. 理解封装用法和目的

简单的说，封装就是对客户端代码隐藏数据和功能，更好的隐藏信息。要实现封装，最简单的方法是将属性定义为private或protected。

举例：比如现实生活中的灯开关问题，设置开方法on()和关方法off()，on()和off()相当于类LampSwitch对外的接口，再设置一个连接电源的方法connect()。开关盒子就相当于封装，用户不知道盒子里面的东西，也不知道connect()具体是怎么实现的，只需按开关就能控制灯。

<?php

class LampSwitch
{
    //开方法 调用connect方法，不需知道connect()具体实现逻辑
    public function on()
    {
        $this->connect();
    }

    //关方法
    public function off()
    {

    }

    //设置方法属性为private或protected，这个方法就只能在类里面访问，在类外面访问就会报错
    private function connect()
    {
        var_dump('connect');
    }
}

$lampSwitch = new LampSwitch();
$lampSwitch->on();  //结果:string(7) "connect"

$lampSwitch->connect(); //结果抛出错误：Fatal error: Uncaught Error: Call to private method LampSwitch::connect() from context '' in D:\Laravel\php-oop\lampSwitch.php:24。

• public（公有）：公有的类成员可以在任何地方被访问。
• protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问，主要用于继承。
• private（私有）：私有的类成员则只能被其定义所在的类访问。

4.类的继承和应用场景

定义：继承是从一个基类得到一个或多个派生类的机制。

• 父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
• 子类 − 一个类继承其他类称为子类，也可称为派生类。

作用：类的继承在代码重用起到了非常关键的作用，我们如果能够充分利用类的继承相关知识，就可以避免重复去写一些代码。

<?php

class  Father
{
    public  function  say()
    {
        return  'hello';
    }

    //当方法属性设置为protected或private时，子类不能访问父类的该方法
    protected  function  walk()
    {
        return  'walk';
    }
}

//Daughter类继承Father类，同时继承Father的属性和方法，重用父类方法
class  Daughter  extends  Father
{

}

//重写父类方法
class  Son  extends  Father
{
    public  function  say()
    {
        return  "hello father";
    }
}

$daughter = new Daughter();
$son = new Son();

var_dump($daughter->say()); //结果：string(5) "father"  重用代码
var_dump($son->say());  //结果：string(12) "hello father" ，重写父类方法
var_dump($son->walk()); //结果抛出错误：Fatal error: Uncaught Error: Call to protected method Father::walk() from context '' in D:\Laravel\php-oop\Father.php:23

5.理解抽象类

抽象类的理解其实并不难，我们抓住代码唯一性的特点来理解的话，可以比较好的理解抽象类的应用场景。

抽象类不能被实例化

<?php

abstract class Shape
{

}

$shape = new Shape();
var_dump($shape); //结果报错：Fatal error: Uncaught Error: Cannot instantiate abstract class Shape in D:\Laravel\php-oop\Shape.php:13

定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。子类必须定义父类中的所有抽象方法；保持程序的完整性和唯一性。

<?php

abstract class Shape
{
    //定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现
    abstract public function getArea(); 
}

class Square extends Shape
{
    protected $length = 4;
    //子类必须定义父类中的所有抽象方法
    public function getArea()
    {
        return pow($this->length,2);
    }
}

class Circle extends Shape
{
    //子类必须定义父类中的所有抽象方法
    public function getArea()
    {

    }
}

$shape = new Square();
var_dump($shape->getArea());  //结果：int(16)

• 任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的，可以使用abstract关键字定义抽象类。
• 定义为抽象的类不能被实例化。
• 被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。
• 继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

6.接口(interface)的理解

抽象类提供了具体实现的标准，而接口则是纯碎的模板。接口只能定义功能，而不能包含实现的内容。要更好的理解oop编程可以去研究php源码。

结合应用场景，可以把接口比作契约或者协议。比如入职需要签订劳动协议，里面有很多条款，职工要遵守里面的条款；劳动协议就相当于接口，条款就是接口里面的方法，调用接口的类就要实现接口中定义的所有方法。

<?php

interface Logger 
{
    public function save($message);
}

class FileLogger implements Logger
{
    public function save($message)
    {
        var_dump("log file".$message);
    }
}

/**
 * 比如DatabaseLogger类是新添加的需求，使用接口更方便的添加DatabaseLogger类，不用修改FileLogger类。
 */
class DatabaseLogger implements Logger
{
    public function save($message)
    {
        var_dump("log database".$message);
    }
}

class UsersController
{
    protected $logger;

    /**
     * 依赖注入
     */
    public function __construct(Logger $logger)
    {
        $this->logger = $logger;
    }

    public function register()
    {
        $user = 'somessii';
        $this->logger->save($user);
    }
}

$controller = new UsersController(new DatabaseLogger());
$controller->register();  //结果：string(16) "log database somessii"

• 接口使用 implements 操作符来声明，接口可以包含属性和方法，但是方法体为空。
• 接口中定义的所有方法都必须是公有，这是接口的特性。
• 类中必须实现接口中定义的所有方法，否则会报出错误。
• 类可以实现多个接口，用逗号来分隔多个接口的名称。