php面向对象编程(oop)基础知识示例解释

面向对象并不是一种技术,而是一种思想,是一种解决问题的最基本的思维方式！如何理解使用?OOP：面向对象编程

(直接代码说明)

1.面向对象的基本概念 示例demo:

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //如何类的实例化?   例如: $newA= new a();  利用类得到对象,过程是类的实例化.关键字new完成.
 //如何定义一个类?   例如: class a{} 类
 //如何声明定义属性? 例如: public $age 属性  声明的控制修饰符:1.public 2.protected 3.private
 //如何声明定义方法? 例如: public function user(){} 方法   对象成员(属性,方法)的访问符：->
 //如何定义类常量?   例如: const  WORK = 'php'; 类常量     访问形式: 类名::常量名
 //小结: 一个类中只有三个成员:1.属性(变量) 2.方法(函数) 3.类常量(常量)
 class a{//类
     public  $name;//属性
     public  $age;
     const   WORK = 'php';//类常量
     public function user($object){//方法
         echo '名字:'.$object->name.'年龄:'.$object->age.'工作'.self::WORK;//在一个类的内部,使用关键字self代替"当前类名"
     }
 }
 $newA = new a();//实例化对象 ==> class a{}
 $newA->name='admin_a';
 $newA->age = 100;
 $newA->user($newA);

 //如何使用$this? 例如: $this代表当前所属类的"当前对象" ,当前谁调用,谁就是"当前对象"
 //小结: 属性不能在方法内直接访问,需要先找到其对象才能访问,典型的做法就是在方法内使用$this关键字来代替当前对象.
 class b{
     public  $name;
     public  $age;
     const   WORK = 'html';
     public function user(){
         echo '名字:'.$this->name.'年龄:'.$this->age.'工作'.self::WORK;//$this当前对象
     }
 }
 echo "<pre>";
 $newB = new b();
 $newB->name='admin_b';
 $newB->age = 200;
 $newB->user($newB);

运行结果如下图:

 $this 和 self 的区别?

 一个是对象$this 相当于实例化后，可以说除了静态和const常量，基本上都可以使用this联络

 self则是类本身 self可以访问本类中的静态属性和静态方法，可以访问父类中的静态属性和静态方法。用self时，可以不用实例化.

2.面向对象中的魔术方法,__construct():构造方法 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //PHP提供__开头的函数,这些函数无需自己手动调用,会在合适的时机自动调用,这类函数称为魔术函数。
 //__construct():构造方法  new对象时自动调用
 class a{
     public $name;
     public $age;
     const  WORK = 'php';
     public function __construct($user_name,$user_age){//构造方法
         $this->name=$user_name;
         $this->age=$user_age;
     }

     public function user(){
         echo '使用构造方法: 名字:'.$this->name.'年龄:'.$this->age.'工作:'.self::WORK;
     }
 }

 $userA= new a('admin_a',100);//对象的属性进行初始化
 $userA->user();

 $userB= new a('admin_b',200);//对象的属性进行初始化
 echo '<pre>';
 var_dump($userA,$userB);

运行结果如下图:

3.面向对象中的魔术方法,__destruct():析构方法 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //PHP提供__开头的函数,这些函数无需自己手动调用,会在合适的时机自动调用,这类函数称为魔术函数。
 //__destruct():析构方法  当删除一个对象或一个对象操作结束时被自动调用.(当一个对象被销毁前自动调用)
 class a{
     public $name;
     public $age;
     const  WORK = 'php';
     public function __construct($user_name,$user_age){//构造方法
         $this->name=$user_name;
         $this->age=$user_age;
     }

     public function __destruct(){//析构方法
         echo '<pre>'.'销毁前自动调用:'.$this->name;
     }

     public function user(){
         echo '使用构造方法: 名字:'.$this->name.'年龄:'.$this->age.'工作:'.self::WORK;
     }
 }

 $userA= new a('admin_a',100);//对象的属性进行初始化
 $userA->user();
 $userA= NULL;

 $userB = new a('admin_b',200);
 echo '<pre>';
 var_dump($userA,$userB);

运行结果如下图:

4.面向对象中的魔术方法,__clone() 示例demo

 <?php
 //__clone():当使用clone关键字,克隆一个对象时自动调用,作用是为新克隆的对象初始化赋值
 class a{
     public $name;
     public $age;
     public function __construct($user_name,$user_age){
         $this->name=$user_name;
         $this->age=$user_age;
     }

     public function __clone(){
         $this->name='admin_b';
         $this->age=200;
     }
 }

 $userA= new a('admin_a',100);
 $userB = clone $userA;//克隆新对象
 echo '<pre>';
 var_dump($userA,$userB);

运行结果如下图:

5.静态成员(包含静态属性和静态方法) 示例demo

类中的所有成员:1.非静态属性 2.静态属性 3.非静态方法 4.静态方法 5.类常量

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //静态成员的定义,名字前面加上关键字static.  静态成员包含1.静态属性 2.静态方法
 //静态属性类内,类外是如何方法?
 class a{
     public $name;
     public static $age =100;
     const  WORK = 'php';
     public function __construct($user_name){
         $this->name=$user_name;
     }

     public function user(){
                                                              //静态属性访问       //常量访问
         echo  '名字:'.$this->name.' (静态属性类内访问) 年龄:'.self::$age.' 工作:'.self::WORK;
     }
 }

 $userA= new a('admin_a');
 $userA->user();
 echo '<pre>(静态属性类外访问) 年龄:'.a::$age;

 //静态方法类内,类外如何访问?
 class b{
     public function f1(){
         echo '非静态方法f1()';
     }

     public static function f2(){
         echo '静态方法f2()';
     }

     public static function f3(){
         self::f2();
     }
 }
 echo '<pre>';
 $newB=new b();
 $newB->f1();
 echo '<pre>(静态方法类外访问) ';
 echo b::f2();
 echo '<pre>(静态方法类内访问)';
 echo b::f3();

运行结果如下图:

6. 类文件的自动 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //类文件的自动加载:自动调用__autoload()函数,该函数传递一个参数是当前类的类名
 //简单实现自动加载
 function __autoload($class_name){
     if(file_exists($class_name.'.class.php')){
         //加载类文件
         include $class_name.'.class.php';
     }else{
         return false;
     }
 }
 //实例化自动加载__autoload()函数
 $newA= new a('admin_a',100);
 $newA->user();

a.class.php文件

 <?php
 class a{
     public $name;
     public $age;
     const  WORK = 'php';
     public function __construct($user_name,$user_age){
         $this->name=$user_name;
         $this->age=$user_age;
     }
     public function user(){
         echo '自动加载类文件获取: 名字:'.$this->name.'年龄:'.$this->age.'工作:'.self::WORK;
     }
 }

运行结果如下图:

7.类的继承 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //类的继承: 一个类从另一个已有的类获得其成员的相关特性.  实现继承关键字:extends
 //派生: 一个已有的类产生一个新的类,称为派生.(比如:B类继承自A类,反过来A类派生出B类)
 //父类: 也叫作基类,就是指已有被继承的类
 //子类: 也叫作派生类或扩展类
 //扩展：在子类中增加一些自己特有的特性,就叫作扩展
 //单继承: 一个类只能继承自一个其他的类,不能继承多个类.(重点)
 //面向对象有三大特性:1.继承性 2.多态性 3.封装性
 class goods{
     public $goods_id;
     public $goods_name;
 }

 class book extends goods{
     public $area;
     public $type;
 }

 class manga extends book{
     public $author;
     public $title;
     public function __construct($goods_id,$goods_name,$type,$area,$author,$title){
         $this->goods_id=$goods_id;
         $this->goods_name=$goods_name;
         $this->type=$type;
         $this->area=$area;
         $this->author=$author;
         $this->title=$title;
     }
 }
 echo '<pre>';
 $manga =new manga('1000','书籍类','中国地区','漫画','米二','一人之下');
 print_r($manga);

运行结果如下图:

8.重写 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //重写(覆盖):当子类成员与父类成员名字相同,从父类继承下来的成员会重新定义.(真正作用是子类中定义的成员!)
 //语法: 父类名::父类的构造方法    关键字parent: 代表的是其父类 (常用写法)
 class Goods{
     public $goods_name;
     //构造方法   继承类都使用构造方法,如何解决重写(覆盖)问题?
     public function __construct($g_name){
         $this->goods_name=$g_name;
     }
     public function getName(){
         echo $this->goods_name;
     }
 }

 class Book extends Goods{
     public $type;
 }

 class Manga extends Book{
     public $title;
     //先执行子类构造方法,后执行父类构造方法
     public function __construct($g_name,$m_title){
         //调用父类的构造方法并传递变量
         parent::__construct($g_name);
         $this->title=$m_title;
     }
     public function getName(){
         echo 'Goods父类:';
         //调用父类getName()方法
         Goods::getName();
         echo '<hr>';
         echo 'Manga子类:';
         echo $this->title;
     }
 }

 $manga = new Manga('商品名称','一人之下');
 $manga->getName();

运行结果如下图:

9.最终类和抽象类 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //final类：最终类，不能被继承，只能实例化对象的类！ 使用关键字:final
 //abstract类：抽象类，只能被继承，不能实例化对象的类！ 使用关键字:abstract
 //final类  示例demo
 class commodity{
     public $commodity_id;
     public $commodity_name;
 }

 final class book extends commodity{//实际开发过程中的规范
     public $area;
     public $type;
 }
 $book = new book();
 echo '<pre>';
 print_r($book);

 //abstract类 示例demo
 abstract class goods{
     public $goods_id;
     public $goods_name;
     abstract function type($data);
     abstract function area();
 }

 class manga extends goods{
     public $author;
     public $title;
     function type($data){
         echo $data;
     }
     function area(){}
 }
 $manga= new manga();
 $manga->type('实现type()方法');

运行结果如下图:

10.interface接口 示例demo

 <?php
 header("Content-Type: text/html;charset=utf-8");
 //接口: 如果一个类中,所有的方法都是抽象方法,且成员属性必须是常量,这类被称为接口.  关键字:interface
 //接口的作用：虽然PHP的类是单继承，但可以通过接口来实现多继承。
 interface User{
     //接口的属性必须是常量
     const VIP = 'vip用户';
     public function getDiscount();
 }

 class VipUser implements User{
     //vip折扣系数
     private $discount = 0.6;
     public function getDiscount() {
         return $this->discount;
     }
 }

 class Goods{
     private $price = 200;
     private $objectUser;
     //获取User接口VipUser类实现
     public function getUserData($User){
         $this->objectUser = $User;
         $discount = $this->objectUser->getDiscount();
         $usertype = User::VIP;
         echo $usertype."=>商品价格：".$this->price*$discount;
     }
 }

 $display = new Goods();
 $display ->getUserData(new VipUser);

运行结果如下图:

11.魔术方法和魔术常量概念小结

 语法较多就不一一举例,更多信息可以去查php手册用法.

 魔术方法
 PHP中把以两个下划线__开头的方法称为魔术方法包括：
 __construct()  :类的构造函数 (常用)

 __destruct()   :类的析构函数

 __call()       :在对象中调用一个不可访问方法时调用

 __callStatic() :用静态方式中调用一个不可访问方法时调用

 __get()        :获得一个类的成员变量时调用

 __set()        :设置一个类的成员变量时调用

 __isset()      :当对不可访问属性调用isset()或empty()时调用

 __unset()      :当对不可访问属性调用unset()时被调用

 __sleep()      :执行serialize()时，先会调用这个函数

 __wakeup()     :执行unserialize()时，先会调用这个函数

 __toString()   :类被当成字符串时的回应方法

 __invoke()     :调用函数的方式调用一个对象时的回应方法

 __set_state()  :调用var_export()导出类时，此静态方法会被调用

 __clone()      :当对象复制完成时调用

 魔术常量
 魔术常量常被用于获得当前环境信息或者记录日志等.魔术常量包括:

 __LINE__      :文件中的当前行号

 __FILE__      :文件的完整路径和文件名

 __DIR__       :文件所在的目录

 __FUNCTION__  :函数名称

 __CLASS__     :类的名称

 __TRAIT__     :Trait的名字

 __METHOD__    :类的方法名

 __NAMESPACE__ :当前命名空间的名称

12.命名空间的概念和使用 示例demo:

 <?php
 //命名空间:一个脚本的开始需要定义命名空间,必须在脚本的最开始处定义.  关键字：namespace
 //空间成员包含:1.常量 2.函数 3.类
 //定义命名空间One
 namespace One;
 header("Content-Type: text/html;charset=utf-8");
 function getName(){//函数
     echo  '空间:'.__NAMESPACE__;
 }
 const AGE=100;//常量
 class User{//类
     public $name='admin_a';
 }
 getName();
 echo '年龄:'.AGE;
 var_dump(new User);
 echo "<hr/>";

 //定义命名空间Two
 namespace Two;
 function getName(){
     echo '空间:'.__NAMESPACE__;
 }
 const AGE=200;
 class User{
     public $name='admin_b';
 }
 getName();
 echo '年龄:'.AGE;
 var_dump(new \Two\User);//注意:完全限定名称访问

运行结果如下图:

空间成员的访问 示例demo:

 <?php
 //三种访问空间成员的方式：1.非限定名称访问 2.限定名称访问 3.完全限定名称访问   "\":代表根空间
 //(1)非限定名称访问:在访问空间成员的时候,没有指定具体的空间的名字.
 namespace A\B\C\D;
 header("Content-Type: text/html;charset=utf-8");
 function getName(){
     echo  '空间:'.__NAMESPACE__;
 }
 const AGE=100;
 class User{
     public $name='admin_a';
 }
 echo '空间A\B\C\D 非限定名称访问: ';
 getName();
 echo '年龄:'.AGE;
 var_dump(new User);
 echo "<hr/>";

 //(2)限定名称访问:就是从当前空间开始访问其子空间的成员.   语法：子空间名\空间成员名
 namespace A\B\C;
 function getName(){
     echo  '空间:'.__NAMESPACE__;
 }
 const AGE=200;
 echo '空间A\B\C 非限定名称访问: ';
 getName();
 echo '年龄:'.AGE.'<br>';

 echo '空间A\B\C 限定名称访问: ';
 D\getName();//限定名称访问
 echo '年龄:'.D\AGE;//限定名称访问
 var_dump(new D\User);//限定名称访问
 echo "<hr/>";

 //(3)完全限定名称访问:直接从根空间开始对绝对路径访问.    语法：\空间1\空间2\...\空间成员
 //注意:完全限定名称访问的最大好处是可以在任意的空间访问其他任意空间的成员.
 //空间类的引入语法: use 空间名\类名
 namespace A;
 function getName(){
     echo  '空间:'.__NAMESPACE__;
 }
 const AGE=300;
 echo '空间A 非限定名称访问: ';
 getName();
 echo '年龄:'.AGE.'<br>';

 echo '空间A 完全限定名称访问: ';
 \A\B\C\D\getName();//完全限定名称访问
 echo '年龄:'.\A\B\C\D\AGE;//完全限定名称访问
 use A\B\C\D\User;//空间类的引入
 var_dump(new User);

运行结果如下图:

空间类的引入 示例demo:

 文件One.php

 <?php
 namespace One;
 header("Content-Type: text/html;charset=utf-8");
 function getName(){
     echo  '空间:'.__NAMESPACE__;
 }
 class User{
     public $name='admin_a';
 }
 class Book{
     public $manga='一人之下漫画';
 }

文件Two.php

 <?php
 //空间类的引入:就是把其他空间的类,引入到当前空间.  语法：use 空间名\类名
 namespace Two;
 header("Content-Type: text/html;charset=utf-8");
 function getName(){
     echo  '空间:'.__NAMESPACE__;
 }
 class User{
     public $name='admin_b';
 }
 //引入文件
 include 'One.php';
 getName();//打印结果:空间:Two
 echo '<pre>';

 //将One空间里面Book类引入到当前空间
 use \One\Book;
 //将One空间里面User类引入到当前空间(注意使用别名:oneUser)
 use \One\User as oneUser;
 $oneBook= new Book();
 $oneUser= new oneUser();
 //使用当前空间类
 $twoUser= new User();
 var_dump($oneBook,$oneUser,$twoUser);

 运行结果如下图: