面向对象的三大特性

一、封装

	<?php
	class Ren{
		public $name;
		public $sex;
		public $age;//如果不想在外界随便修改和访问这个变量，那就需要封装
	}
	$r = new Ren();
    ?>

目的：让类更加安全

类的成员变量都要封装，封装的函数前面是public

封装的方法1、成员变量变为private

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;//public----private
	}
	$r = new Ren();
    ?>

2、在类里做一个成员方法来访问 

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;//public----private
		public function setage($age){
		}//用函数做一个成员方法
	}
	$r = new Ren();
    ?>

  3、在该方法加限制条件

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;//public----private
		public function setage($age){
			if($age>=18&&$age<=50){
				$this->age = $age;
				}//限制条件
		}
	}
	$r = new Ren();
	//$r->setage(20);
	$r->setage("zhang");
	var_dump($r)
    ?>

 

上面的例子有个弊端，封装几个成员变量就要写多少成员方法，代码量比较繁冗。

4、魔术方法

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;//public----private
		public function __set($name,$value){//$name变量名$value变量值
			if($name == "age"){
				if($value>=18&&$value<=50){
					$this->$name = $value;
				}
			}
			else{
				$this->$name = $value;
				}
		}
	}
	$r = new Ren();
	$r->name = "张三";
	$r->age = 20;//自动调用__set
	var_dump($r)
    ?>

	class Ren{
		public $name;
		public $sex;
		private $age;//public----private
		public function __set($name,$value){//$name变量名$value变量值
			if($name == "age"){
				if($value>=18&&$value<=50){
					$this->$name = $value;
				}
			}
			else{
				$this->$name = $value;
				}
		}
		public function __get($name){
			return $this->$name;
		}
	}
	$r = new Ren();
	$r->name = "张三";
	$r->age = 20;//自动调用__set
	$r->age;//自动调用__get
	var_dump($r)
    ?>

 赋值语句用__set   取值语句用__get

二、继承

概念：子类可以继承父类的一切

特点：单继承（一个子类只能有一个父类，一个父类可以有多个子类）

<?php
    class Ren{
        public $name;
        public $sex;
        private $age;
        public function say(){
            echo "人在讲话";
        }
    }
    class China extends Ren{//子类继承了父类所有    
    } 
    $r = new China();
    $a = new Ren();
    $a->say();
    $r->say();
    var_dump($a);
    var_dump($r);　　
 ?>

 

 

1、重写 override

子类可以对父类的函数重写（子类可以扩展父类没有的内容）

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;
		public function say(){
			echo "人在讲话";
		}
	}
	class China extends Ren{//子类继承了父类所有
	    public function say(){
			echo "中国人在讲话";//扩展父类没有的内容，覆盖父类原来的内容（重写）
		}	
	}
	$r = new China();
	$r->say();
	var_dump($r)
    ?>

 

函数重写2

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;
		public function say(){
			echo "人在讲话";
		}
	}
	class China extends Ren{
		public function say(){
		parent::say();//调用父类里面的方法
		echo "你好";
		}
	}
	$r = new China();
	$r->say();
	var_dump($r)
    ?>

 

2、重载 overload

一般发生在强类型语言中

目的是一个方法实现多个功能

重载的条件： 方法名字相同，参数个数不同，参数个数相同类型不同。

	<?php
	class Ren{
		public $name;
		public $sex;
		private $age;
		public function say(){
			echo "人在讲话";
		}
	}
	class China extends Ren{
	   /* public function test(){
			echo "木有参数";
		}*/
		/*public function test($a){
			echo "一个参数";
		}	*/
		public function test($c,$b){
			echo "两个参数";
		}		
	}
	$r = new China();
	$r->test(1,2);
	var_dump($r)
    ?>

 

3、重写的实例

 <?php
    class Suan{
        public $a;
        public $b;
        public function yunsuan(){
        }
     }
     class Jia extends Suan{
         public function yunsuan(){
              return $this->a+$this->b;
         }
     }
     $r = new Suan();
     $r1 = new Jia();
     $r1->a=45;
     $r1->b=60;
     $r1->yunsuan();
 ?>

三、多态

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

运行多态

编译多态

编译多态就是重载

多态发生在编译的时候产生了不同就是重载