当前位置:首页 > PHP教程 > php面向对象 > 列表

php面向对象简单概括

发布:smiling 来源: PHP粉丝网  添加日期:2022-06-17 11:11:50 浏览: 评论:0 

基本知识

类:具有相同属性或方法的一类集合体。比如雪佛兰汽车是一个雪佛兰汽车类,奔驰汽车是一个奔驰汽车类,宝马汽车是一个宝马汽车类,而这三个类又是汽车大类的子类。

对象:类的一个具体实现,比如宝马Q5就是宝马汽车类的一个具体实现。对象地使用是放在内存中的。一下让我们了解一下对象在内存中的分配。

5.pn

使用面向对象,就是灵活地使用以上两个知识点。让我们来创建和使用类与对象

  1. <?php 
  2.  
  3.     /** 
  4.  
  5.     *新建一个类 
  6.  
  7.     */ 
  8.  
  9.     class newClass{        public $a;        public $b;        public function funA(){            echo "I am function A"
  10.  
  11.         }        public function funB(){            echo "I am function B"
  12.  
  13.         } 
  14.  
  15.     }    /** 
  16.  
  17.     *使用类创建对象 
  18.  
  19.     */ 
  20.  
  21.     $opt=new newClass(); 
  22.  
  23.     $opt->a="opt";//将opt对象中的a属性赋值为opt 
  24.  
  25.     $opt->funA();//打印出"I am function A"?> 

修饰符:在定义类与类中的属性时,我们可以使用如下三个修饰符,若不加,则默认为public

public:权限最大

protected:权限范围在其本身与其子类

private:权限范围仅在其本身

构造函数与析构函数:在我们对类实例化创建对象时,往往需要对对象进行初始化,这时,我们就需要在类中定义一个构造方法。当我们使用完对象时,就需要释放对象,以减少内存的使用,这时我们就需要使用析构方法。

在php中我们使用__construct()方法与__destruct(),如下代码:

  1. <?php 
  2.  
  3. class newClass{ 
  4.  
  5.     public $a
  6.  
  7.     public $b
  8.  
  9.     public function __construct($a,$b){ 
  10.  
  11.         $this->a=$a
  12.  
  13.         $this->b=$b
  14.  
  15.         echo "我是构造函数"
  16.  
  17.     } 
  18.  
  19.     public function __destruct(){ 
  20.  
  21.         echo "我是析构函数"
  22.  
  23.     } 
  24.  
  25.  
  26. ?> 

封装性

当我们开发一些重要的程序模块时,常常不希望别人能轻易访问这些程序模块的数据,因此需要对这些数据进行封装。这时我们要进行数据的访问控制,常常使用<font color="red">private</font>关键字来对这些属性与方法进行封装。

如下:

  1. <?php 
  2.  
  3. class privateClass 
  4.  
  5.  
  6.     private $a
  7.  
  8.     private $b
  9.  
  10.     private function privateFun() 
  11.  
  12.     { 
  13.  
  14.         echo "我是封装的方法"
  15.  
  16.     } 
  17.  
  18. } ?> 

这样,当我们创建对象时就不能调用私有的属性与方法。但是我们可以通过使用魔术方法来对这些私有属性与方法进行访问。

__set()与__get()的使用

通过__set()方法我们可以通过对象直接设置成员属性值

通过__get()方法我们可以通过对象直接获取成员属性值

  1. <?php 
  2.  
  3. class setClass 
  4.  
  5. {         
  6.  
  7.      private $a;         
  8.  
  9.     private $b="ww";         
  10.  
  11.     public function __set($oldValue,$newvalue){  
  12.  
  13.         $this->$oldValue=$newvalue
  14.  
  15.     }         
  16.  
  17.     public function __get($newvalue){             
  18.  
  19.         return $newvalue
  20.  
  21.     } 
  22.  
  23.  
  24.     $optnew setClass(); 
  25.  
  26.     $opt->a="sss";//直接设置私有属性值 
  27.  
  28.     echo $opt->b;//直接读取私有属性值 
  29.  
  30. ?> 

__isset()与__unset()的使用

通过__isset()直接查看对象中私有属性是否存在

通过__unset()直接删除对象中的私有属性

  1. <?php 
  2.  
  3. class issetClass 
  4.  
  5.  
  6.     private $a
  7.  
  8.     private $b = 'www'
  9.  
  10.     function __isset($privateName
  11.  
  12.     { 
  13.  
  14.         if (isset($privateName)) { 
  15.  
  16.             return 1; 
  17.  
  18.         } else { 
  19.  
  20.             return 0; 
  21.  
  22.         } 
  23.  
  24.     } 
  25.  
  26.     function __unset($privateName
  27.  
  28.     { 
  29.  
  30.         echo "销毁" . $privateName
  31.  
  32.     } 
  33.  
  34.  
  35. $opt = new issetClass(); 
  36.  
  37. echo isset($opt->$b); 
  38.  
  39. var_dump(unset($opt->$b));?> 

继承性

当我们编写多个类时,常常多个类具有相同的属性与方法,为了简化代码我们引入了继承的概念,子类可以继承父类的一些属性与方法,减少了冗余代码地编写。

如何编写继承类

我们使用关键字extends来编写子类

  1. <?php 
  2.  
  3.     class parentClass{ 
  4.  
  5.     }     
  6.  
  7.     class childClass extends parentClass{ 
  8.  
  9.     }     
  10.  
  11. ?> 

如上,childClass是parentClass的子类,php仅支持单继承,即一个子类只有一个父类,但父类可以有多个子类。

重写父类方法

当父类中的方法不能满足子类的使用时我们可以重写父类方法。但当我们又想在子类使用父类的方法时,我们可以使用如下语法:parent::方法名几个重要的关键字

3.1 final

final可以修饰类与方法,不能修饰成员属性;

被final修饰的类不能继承,而用final修饰的方法在子类中不能被重写

3.2 static

static可以修饰成员属性与成员方法,不能修饰类;

使用static修饰的成员与方法可以通过类直接使用,使用如下语法:类名::\$属性名或方法名();

在类中使用时通过如下语法:self::\$属性名或方法名.

3.3 const

在类中声明常量使用const,而不是使用define();

比如 const TT=90当使用常量时直接使用如下语法self::常量名

3.4 instanceof

使用该关键字可以检测某个实例是否是某个类的实例。

3.5 trait

php只能进行单继承,但它同时提供了另类方式来进行代码复用,解决单继承问题。

如下:

  1. <?php 
  2.  
  3. trait testA 
  4.  
  5.  
  6.     function a() 
  7.  
  8.     { 
  9.  
  10.     } 
  11.  
  12.  
  13.  
  14.  
  15. trait testB 
  16.  
  17.  
  18.     function b() 
  19.  
  20.     { 
  21.  
  22.     } 
  23.  
  24.  
  25.  
  26.  
  27. class testC 
  28.  
  29.  
  30.     use testA, testB; 
  31.  
  32.  
  33.  
  34.     function c() 
  35.  
  36.     { 
  37.  
  38.     } 
  39.  
  40. } ?> 

抽象技术

用abstract关键字修饰的方法与类称为抽象方法或抽象类。

声明抽象类与抽象方法

  1. <?php 
  2.  
  3. abstract class testClass 
  4.  
  5.  
  6. $a
  7.  
  8. $b
  9.  
  10.     abstract function testFun(); 
  11.  
  12.     abstract function testFun1(); 
  13.  
  14.     public function optFun() 
  15.  
  16.     { 
  17.  
  18.         echo "抽象类中的抽象方法"
  19.  
  20.     }//抽象类可以有非抽象方法 
  21.  
  22.  
  23. class childClass extends testClass 
  24.  
  25.  
  26.     function testFun() 
  27.  
  28.     { 
  29.  
  30.         echo "子类中实现抽象方法"
  31.  
  32.     } 
  33.  
  34.     function testFun1() 
  35.  
  36.     { 
  37.  
  38.         echo "子类实现抽象方法"
  39.  
  40.     } 
  41.  
  42.  
  43. abstract child1Class extends testClass 
  44.  
  45.  
  46. }//子类是抽象方法可以不实现父类的抽象方法?> 

抽象技术为子类的声明提供了一种规范,限制了类的实例化(抽象类不能实例化)。

接口技术

接口是一种特殊的抽象类,接口中只能声明抽象类与常量

声明接口使用interface,实现接口使用implements,修饰符只能是默认的public;

一个子类可以继承多个接口,同时继承一个父类

  1. <?php 
  2.  
  3. interface newInterface 
  4.  
  5.  
  6.     const V = 12; 
  7.  
  8.     abstract function fun1(); 
  9.  
  10.     abstract function fun2(); 
  11.  
  12.  
  13. interface newInterface1 
  14.  
  15.  
  16.     abstract function fun3(); 
  17.  
  18.     abstract function fun4(); 
  19.  
  20.  
  21. class parentClass 
  22.  
  23.  
  24.     function fun5() 
  25.  
  26.     { 
  27.  
  28.         echo "fun5"
  29.  
  30.     } 
  31.  
  32.  
  33. class optClass extends parentClass implements newInterface, newINterface1 
  34.  
  35.  
  36.     function fun1() 
  37.  
  38.     { 
  39.  
  40.         echo "fun1"
  41.  
  42.     } 
  43.  
  44.     function fun2() 
  45.  
  46.     { 
  47.  
  48.         echo "fun2"
  49.  
  50.     } 
  51.  
  52.     function fun3() 
  53.  
  54.     { 
  55.  
  56.         echo "fun3"
  57.  
  58.     } 
  59.  
  60.     function fun4() 
  61.  
  62.     { 
  63.  
  64.         echo "fun4"
  65.  
  66.     } 
  67.  
  68. } ?> 

多态

在php中多态地实现需要一个类通过多个子类地继承实现,如果一个类的方法在多个子类中重写并实现不同的功能,我们称之为多态。

Tags: php面向对象

分享到: