LAMP兄弟连原创视频教程(PHP笔记三--面向对象)

7.1 面向对象的概念
面对对象符合人的逻辑思维，有利于重复使用
有类才有对象，类是为了声明对象，对象是独立的
1.什么是类 电脑本配置单，桌子图纸
2.什么是对象 电脑教室（20电脑，20桌子）
3.类和对象之间的关系
4.什么是成员属性，什么是成员方法

7.2 类的声明使用
如何抽象一个类
class 类名
{

}
<?php
 class Person
 {
  //成员属性
  var $name;
  var $age;
  var $sex;
  
  function say()
  {
   echo "我在说话";
  }
  function run()
  {
   echo "我在跑步";
  }
 }
        //声明定义对象
 $p1=new Person();
 $p2=new Person();
 $p1->name="张三";
 $p2->name="李四";
 $p1->say();
 $p2->say();
?>

7.3 对象实例化及使用
对象存储在内存的堆中，通过对象的首地址存在栈内存
7.4 构造方法与析构方法
特殊的引用$this
构造方法特点：名称和类名相同；对象一产生时，自动调动;常用于初始化属性
<?php
 class Person
 {
  //成员属性
  var $name;
  var $age;
  var $sex;
  /*
  //PHP5的构造方法，比PHP4的构造方法的优先级高
  fuction __construct()
  {
 
  }
  */
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
  
  function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
  }
  function run()
  {
   echo "我在跑步";
  }
  //析造函数
  function __destruct()
  {
   echo $this->name."再见！";
  }
 }
        //声明定义对象
 $p1=new Person("张三",20,"男");
 $p2=new Person("李四",22,"男");
 $p1->say();
 $p2->say();
?>

7.5 封装性
将对象内部属性和方法封装有自己对象的内部，在对象的内部可以被使用或访问，不能在外部被访问
<?php
 class Person
 {
  //封装成员属性
  private $name;
  private $age;
  private $sex;
  
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
  function setAge($age)
  {
   if($age<0||age>200)
    return;
   $this->age=$age;
   
  }
  function getAge()
  {
   return $this_>age-10;
  }
  function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
  }
  private function run()
  {
   echo "我在跑步";
  }
  private function eat()
  {
   echo "我在吃饭";
  }
 
 }
 $p1=new Person("张三",20,"男");
 $p1->setAge(21);
 $p2=new Person("李四",22,"男");
 $p1->say();
 $p2->say();
?>

7.6 封装时所用的四个魔术方法
__set() __get() __isset() __unset() (用于清除变量)
两下划线开始的函数是在某一时刻自动调用的方法
<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
   private function __set($proName,$value)
  {
   $this->$proName=$value;
  }
  function __get($proName)
  {
   if($proName=="name")
   {   
    return $this->$proName;
   }else if($proName=="age")
   {
    return $this->age;
   }
  }
  //判断属性是否存在
  function __isset($proName)
  {
   return isset($this->$proName);
    
  }
  //删除属性
  function __unset($proName)
  {
    unset($this->$proName);
  }
 }
 $p1=new Person("张三",20,"男");
 $p2=new Person("李四",22,"男");
 $p1->age=33;
 echo $p1->age;
 echo $p2->age;
 //isset没重写时只能判断非私有的属性
 if(isset($p1->name))
 {
  echo "属性存在";
 }else
 {
  echo "属性不存在"
 }
?>
7.7 继承性(扩展性，重复性，共享性)
php的继承为单继承，不存在多继承，即一个子类只能有一个父类,父类的私有属性和方法不能在子类中被访问
<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
   function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
  }
  private function run()
  {
   echo "我在跑步";
  }
  private function eat()
  {
   echo "我在吃饭";
  }
 }
 class Student extends Person
 {
  var $school;
  function study()
  {
   
  }
 }
 $s1=new Student("张三",22,"男");
 $s1->say();
?>
7.8 方法的覆盖和访问权限
PHP的重载指的是子类对父类的重写
<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  
  function __construct($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
   function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
  }
 }
 class Student extends Person
 {
  var $school;
  function __construct($name="",$age="",$sex="",$school="")
  {
   parent::__construct($name="",$age="",$sex="")
   $this->school=$school;
   
  }
  function study()
  {
   
  }
  function say()
  {
   //echo "我的名字叫：".$this->name."我的年龄：".$this->age;
   paraent::say();
   echo "我的学校".$this->school;
  }
 }
 $s1=new Student("张三",22,"男","北大");
 $s1->say();
?>
访问类型 private protected public ,子类的访问权限必须不能低于于父类

7.9 面向对象中常见的关键字
final static const
final:只能用来定义类和方法
    作用：作用final定义的类不能被继承
              使用final定义的方法不能被重载
static:可以修饰属性和方法，有static方法中不能有this关键字和不能使用非static成员

<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  static $country="中国";
  
   function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
   echo "国家 :".sef::$country;
  }
 }
 
 echo Person::$country;
?>

const:是一个在类里面定义成员属性为常量的关键字，只能修饰属性，只能在初始化赋值
      类名::成员属性
<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  const COUNTRY="中国";
  
   function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
   echo "我的国家 :".sef::COUNTRY;
  }
 }
 
 echo Person::COUNTRY;
?>

7.10 常用的魔术方法
__toString() __clone() __call() __autoload()
<?php
 class Person
 {
  //封装成员属性
  private $name;
  private $age;
  private $sex;
  
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
  //打印对象时调用
  function __toString()
  {
   retrun $this->name.$this->age;
  }
  //克隆时调用
  function __clone()
  {
   //这里的this指的是克隆的副本
   $this->name="副本" .$that->name;
  }
  //调用不存在方法时，调用该方法
  function __call($funName,$argus)
  {
   echo "你调用的方法".$funName."不存在";

  }
 }
 $p1=new Person("张三",20,"男");
 $p2=new Person("李四",22,"男");
 echo $p1;
 $p3=clone $p1;
 $p1->fun1("one","two");
?>
<?php
 function __autoload($className)
 {
  include $className."_class.php";
 }
 $p1=new Person("张三",20,"男");
?>

7.11 对象的串行化与反串行化
对象的串行化的两个过程
串行化：就是把对象转为二进制的字符串，serialize()
反串行化，就是把二进制字符串转化为对象 unserialize()
两种情况下串行化和反串行化
第一种：对象在网络中传输时
第二种：将对象写入文件或者数据库
<?php
 class Person
 {
  private $name;
  private $age;
  private $sex;
  
  function Person($name="",$age="",$sex="")
  {
   $this->name=$name;
   $this->age=$age;
   $this->sex=$sex; 
  }
  //序列化时调用，为可选函数
  function __sleep()
  {
   $arr=array("name","age");
    return $arr;
  }
  //反序列化时调用，为可选函数
  function __wakeup()
  {
   $this->name="李四";
   $this->age=50;
  }
  function say()
  {
   echo "我的名字叫：".$this->name."我的年龄：".$this->age;
  }
 }
 $p1=new Person("张三",20,"男");
 $str=serialize($p1);
 $file=fopen("tmp.txt","w");
 fwrite($file,$str);
 fclose($file);
 
?>
<?php
 include "person.php";
 $file=fopen("tmp.txt","r");
 $str=fread($file,filesize("tmp.txt"));
 fclose($file);
 $p=unserialize($str);
 $p->say();
 fclose($file);
 unserialize($file,$str )
?>

7.12 抽象方法与抽象类
抽象方法:在类里面没有方法体的方法就是抽象方法，即没有大括号{}以及内容，在方法名后面加一个分号，另外还

要在方法声明时加上一个关键字“abstract”来修饰。
<?php
 abstract class Demo
 { 
  var $demo="hello";
  abstract function fun1();
  function fun2()
  {
   echo "hello world!"; 
  }
  abstract function fun3();
 }
 class Test extends Demo
 {
  function fun2()
  {
   echo "xxxx";
  }
 }
 $t=new Test();
 $t->fun1();
 $t->fun2();
?>
抽象类:如果一个类里面有一个方法是抽象的，这个类就是抽象类;这个类就要使用"abstract"关键字来修饰
注意：抽象类不可以实例化对象,继承抽象类的子类必须实现抽象类中的所有抽象方法
用途：抽象类就相当一个规范
7.13 接口声明与使用
作用：接口也是一种规范
注意： 同一个类可以实现多个接口
可以使用抽象类去实现一个接口的部分方法，使用类去实现接口中的
abstract clss Demo
{
 可以有成员属性
 可以有普通方法
 至少有一个抽象方法
}
interface Demo
{
 所有的成员属性必须是抽象的
 所有的方法都是抽象的
 所有成员都必须是public
}
<?php
 interface One
 {
  const TEST="hello";
  function fun1();
  function fun2();
 }
 interface Two extends One
 {
  function fun3();
  function fun4();
 }
 class Demo implements One
 {
  function fun1()
  {
   echo "111111";
  }
  function fun2()
  {
   echo "222";
  }
 }
 $d=new Demo();
 echo Demo::TEST."<br>";

 $d->fun1();
 $d->fun2();
?>

7.14 多态性

PHP的态性表现不明显，原因是PHP的变量是弱类型的。
<?php
interface PCI
{
 function start()；
 function stop();
}
class ViewCard implements PCI
{
 function start()
 {
  echo "可以看到图像";
 }
 function stop()
 {
  echo "图像消失";
 }
}
class SoundCard implements PCI
{
 function start()
 {
  echo "可以看到图像";
 }
 function stop()
 {
  echo "图像消失";
 } 
}
class MainBord
{
 function usePCI($pci)
 {
  $pci->start();
  $pci->stop();
 }
}
class Person
{
 function install()
 {
  $mb=new MainBord();
  $vc = new ViewCard();
  $sc=new SoundCard();
  $mb->usePCI($vc);
  $mb->usePCI($sc);
  /*
  $pci=$vc;
  $pci=$sc;
  $pci->start();
  $pci->stop();
  */
 }
}
$p=new Person();
$p->install();
?>