PHP 面向对象

封装与不封装的区别：   未封装 时 外部随意更改数据   数据 不需要判定 就可以执行    外部直接操作数据

封装：  外部同样可以对数据更改，但需要 调用  类里面的  函数  外部间接操作数据  （间接调用并且 内部进行判定后方可执行）

原则上成员变量 私有  成员函数公有

类  ： 成员变量   成员属性  成员方法

面向对象的三大特性：  封装   继承  多态

封装作用：  使数据更加安全

封装的方法： 1.首先使变量私有 private  2. 类里面做方法 间接访问 成员变量  3.方法里面加控制（

在方法里面加控制（仿制外界随便用）{赋值和取值 分别为两个方法（函数）return注意}

）

------------------------------------------------------------------------------------------------------------------

例题

return   应用    封装  ： 1. 私有  private   2.  类里面构造方法   间接访问 成员变量

1.以下两个例题   注意  构造函数  的区别（两种方法）

封装：

class people
{
    private $name;
    private $sex;
    private $age;
    function __construct($a,$b,$c)
    {
        $this->name=$a;
        $this->age=$b;
        $this->sex=$c;
        }
        private function leftLeg()
        {
            return "迈左腿";
        }
    private function RightLeg()
        {
            return "迈右腿";
        }
    function run()
    {
        echo $this->name."在走路".$this->leftLeg().$this->RightLeg();

        }

    }

$paobu=new people("黄牛",19,"男");
$paobu->run()

输出结果：黄牛在走路迈左腿迈右腿

私有函数 private 应用

class people
{
    private $name;
    private $sex;
    private $age;
    function __construct($a="黄牛2",$b="19",$c="男")
    {
        $this->name=$a;
        $this->age=$b;
        $this->sex=$c;
        }
        private function leftLeg()
        {
            return "迈左腿";
        }
    private function RightLeg()
        {
            return "迈右腿";
        }
    function run()
    {
        echo $this->name."在走路".$this->leftLeg().$this->RightLeg();

        }

    }

$paobu=new people();//注意构造函数
$paobu->run()

注意构造函数和 上面例题的区别

2.封装方法1  转化为私有      2. 类里面构建方法    外部 通过方法对  变量进行 获取或者 赋值  （构建两个方法）

class ren
{
    private $name;
    private $age;
    private $nation;

    function __construct($a,$c)
    {
        $this->name=$a;

        $this->nation=$c;

        }
        //创建方法 用于修改年龄（在外界）
        function set($ll)
        {
            //加控制是否满足条件
           if( $ll>10&&$ll<50)
            {
                $this->age=$ll;
            echo "我叫".$this->name."今年".$this->age."岁".$this->nation;    

            }
        }
        //创建方法来用  于取值  获取
        function get()
        {
            return  $this->age;
            }

    }

$renmen=new ren("张","汉族");
$renmen->set(20);
echo   $renmen->get(); //获取年龄

方法1 类里面构建两个方法

封装  方法二： 常用（重要）__set($a,$b) 方法 和__get($p) 方法   详见下面例题  注意写参数  {该方法只写在类里面} 使用时 默认自动调用  其他书写和非封装书写方式一样

魔术方法内部不需要返回值     $this->name="名字"； 这里的那么需要手写不提示

class Ren
{
    public $code; //人员代号
    private $name; //人员名称
    private $sex; //人员性别
    private $age; //人员年龄,必须在18-50周岁之间

    //构造方法，用来初始化性别
    function __construct($s)
    {
        $this->sex = $s;
    }
function __set($n,$v)//前面是 名称  后面是 值
    {
        if($n=="age")
        {
            if($v>18 && $v<50)
            {
                $this->$n = $v;
            }
        }
        else
        {
            $this->$n = $v;
        }

    }

    //__get魔术方法，用来取变量值的
    function __get($n)
    {
        return $this->$n;
    }
}

//造对象
$r = new Ren("男");
$r->age = 30; //自动调用__set()方法，将变量名当做第一个参数，将等号右边的值当做第二个参数
$r->name = "张三";
echo $r->sex; //自动调用__get()方法，将变量名当做参数
var_dump($r);
----------------------------------------------结果
男
object(Ren)[1]
  public 'code' => null
  private 'name' => string '张三' (length=6)
  private 'sex' => string '男' (length=3)
  private 'age' => int 30

方法二： 调用魔术方法 写入魔术方法后 以后自动调用（代码和为封装一样使用）

3.返回 类名   连续  （说不明白直接看例题）

class Dog
{
    private $name;

    function Jiao()
    {
        echo $this->name."在叫";
    }

    function SetName($n)
    {
        $this->name = $n;
        return $this;// 注意这里
    }

}

$d = new Dog();
$d->SetName("旺财")->Jiao()//注意这里

例题（重要）

继承：

1.父类
2.子类
子类可以继承父类的一切（有的时候需要自己亲自打上  并不提示   如下面  注释处）

如果子类对父类的方法进行重写  但是  在子类中还需要 父类的方法  使用  parent ::say()  详细如下

重写：override
特点：单继承，一个子类只能有一个父类，一个父类可以派生多个子类

class Ren
{
	public $name;

	function Say()
	{
		echo $this->name."正在讲话";
	}
}

class China extends Ren// extends
{
	//子类对父类的方法进行重写
	function Say()
	{
		parent::Say();
/*子类中调用父类的成员	parent ::say();在子类中使用 父类的 say 方法*/
		echo "你好";
	}

	function Run()
	{
		echo $this->name."正在跑步";//
	}
}

class America extends Ren
{
	//子类对父类的方法进行重写
	function Say()
	{
		echo "hello";
	}
}
$c = new China();
$c->Say();    //输出 正在讲话   你好
$a = new America();
$a->Say();       //hello
var_dump($c);

　多态：

3.多态（以下是对强类型语言中讲解多态  弱类型语言  几乎看不出来）
当父类引用指向子类实例的时候，由于子类对父类的方法进行了重写，父类引用在调用该方法的时候表现出的不同，称为多态
运行多态

条件
1.要有继承
2.父类引用指向子类实例
3.要有重写
4.调重写的方法

关键词 重写：override

overload(重载)（多态的一种，编译多态）
当父类引用指向子类实例的时候， 由于子类对父类的的方法进行了重写，父类引用在调用该方法的时候表现出的不同
可以使 类里面的某个方法产生多种效果， 根据传入参数的不同， 可以执行不同的逻辑 例如： rand（） 根据传入不同值而产生不同的效果

//3.多态
//当父类引用指向子类实例的时候，由于子类对父类的方法进行了重写，父类引用在调用该方法的时候表现出的不同，称为多态
//运行多态

//条件
//1.要有继承
//2.父类引用指向子类实例
//3.要有重写
//4.调重写的方法

//父类
  /*  class Ren
    {
        public virtual string Say()
        {
            return "说话";
        }
    }

    //子类
    class China : Ren
    {
        public override string Say()
        {
            return "你好";
        }
    }
    //子类
    class America : Ren
    {
        public override string Say()
        {
            return "hello";
        }
    }

     //父类引用r指向子类实例
    Ren r = new America();
    MessageBox.Show(r.Say());

    r = new China();
    MessageBox.Show(r.Say());

    //子类的对象可以代替父类的对象
     America a = new America();
     MessageBox.Show(Eat(a));
      //怪兽吃人，需要一个人的参数
        public string Eat(Ren r)
        {
            return "这个人味道不错！";
        }

多态（强类型语言）

overload 重载
可以使类里面的某个方法产生多种效果，根据传入的参数不同，可以执行不同的逻辑
也是多态的一种，编译多态
  class Test
    {
        public string show()
        {
            return "0参";
        }
        public string show(string s)
        {
            return "1参";
        }
        public string show(string s,string a)
        {
            return "2参";
        }
    }

     Test t = new Test();

     t.show("a","b");

onload重载（强类型语言）

<?php
class ren
{
    private $name;
    private $age;
    private $nation;

    function __construct($a,$b,$c)
    {
        $this->name=$a;
        $this->age=$b;
        $this->nation=$c;

        }
        function shu()
        {

            return  "我叫".$this->name."今年".$this->age."岁".$this->nation;
        }
    }

$renmen=new ren("张",18,"汉族");
echo $renmen->shu();
?>

输出拼接字符串