面向对象三大特性之封装

面向对象（OOP）里面有三大特性：封装、继承、多态。

1、封装

class Ren
{
    private $name;
    private $sex;
    private $age;//年龄必须在18-50岁之间
    
    function __construct($n)
    {
        $this->sex = $n;
    }
    //设置age的值
    function setage($a)
    {
        if($a>=18 && $a<=50)
        {
            $this->age = $a;
        }
    }
    //获取age的值
    function getage()
    {
        return $this->age;
    }
    
    function _destruct()
    {
        echo"这是一个析构方法";
    }

}
$r = new Ren("男");

$r->setage(20);

echo $r->getage();

var_dump($r);

//封装目的：为了让类更加的安全
//封装的做法：
//1.类里面的成员变量全部做为private
//2.使用成员方法来间接访问成员变量
//3.在该方法里面加限制条件

按照上面的方法用起来很不方便，一个变量要写两个函数，如果变量较多时，要写的函数会更多。

PHP里面有个方法是function __set（）;

class Ren
{
    private $name;
    private $sex;
    private $age;//年龄必须在18-50岁之间
    
    function __construct($n)
    {
        $this->sex = $n;
    }
    function __set($n,$v)//可以给成员变量赋值,括号里面有两个参数，第一个参数是成员变量的名称，第二个是成员变量的值。
    {
        $this->$n = $v;
    }
}
$r = new Ren("男");
//$r->__set("age",20);//按照这种写法还是会比较复杂，每一个都需要写名字。按照下列写法写。
$r->age = 20;
var_dump($r);

__set方法特殊在可以自动调用，在给成员变量赋值的时候自动调用function __set($n,$v),把age传给$n，把20传给$v。

上面的只能调用这个方法赋值，没有限制条件，下面代码是封装的最终形式。

class Ren
{
    private $name;
    private $sex;
    private $age;//年龄必须在18-50岁之间
    
    function __construct($n)
    {
        $this->sex = $n;
    }
    function __set($n,$v)
    {
        if($n=="age")
        {
            if($v>=18 && $v<=50)
            {
                $this->$n = $v;
            }    
        }
        else
            {
                $this->$n = $v;
            }
    }
}
$r = new Ren("男");
$r->__set("age",20);
var_dump($r);

一个类里面一个set就够了，如果成员变量多的话可以使用switch...case。

类里面的所有的双下划线的有一个统称，叫做魔术方法。

function __get()

class Ren
{
    private $name;
    private $sex;
    private $age;//年龄必须在18-50岁之间
    
    function __construct($n)
    {
        $this->sex = $n;
    }
    function __set($n,$v)//可以给成员变量赋值,括号里面有两个参数，第一个参数是成员变量的名称，第二个是成员变量的值。
    {
        if($n=="age")
        {
            if($v>=18 && $v<=50)
            {
                $this->$n = $v;
            }    
        }
        else
            {
                $this->$n = $v;
            }
    }
    function __get($n)
    {
        return $this->$n;
    }
}
$r = new Ren("男");
$r->age = 40;
echo $r->age;//这么写会直接调用get方法。把变量名age传到get里面去

//例子：求两个圆之间的阴影面积

//面向过程的方式：

/*$maxr = 20;
$minr = 10;
$mj = 3.14*$maxr*$maxr - 3.14*$minr*$minr;

//面向对象的方式：
class Yuan//研究的是圆，类就是圆。
{
    //代表半径
    public $r;//圆的属性中有半径
    
    function __construct($n)//构造函数
    {
        $this->r = $n;//给圆的半径赋上取到的值
    }
    
    //求面积的方法
    function MJ()//方法  求圆的面积的通用公式
    {
        return 3.14*$this->r*$this->r;
    }
}

$r1 = new Yuan(20);//圆1的半径是20
$r2 = new Yuan(10);//圆2的半径是10

$mianji = $r1->MJ()-$r2->MJ();*/

//例子：计算器
面向过程的方式：
$a = 10;
$b = 5;

$jia = $a+$b;
$jian = $a-$b;
$cheng = $a*$b;
$chu = $a/$b;

面向过程的方式：
class jisuan
{
    public $a;
    public $b;
    
    function __construct($n,$m)
    {
        $this->a = $n;
        $this->b = $m;
    }
    
    function jia()
    {
        return $this->a+$this->b;
    }
    function jian()
    {
        return $this->a-$this->b;
    }
    function cheng()
    {
        return $this->a*$this->b;
    }
    function chu()
    {
        return $this->a/$this->b;
    }
    function quyu()
    {
        return $this->a%$this->b;
    }
}

$j = new jisuan(10,5);
$j->quyu();