PHP面向对象(五)

一、抽象方法和抽象类
  在OOP语言中,一个类可以有一个或多个子类,而每个类都有至少一个公有方法做为外部代码访问其的接口。而抽象方法就是为了方便继承而引入的。

  抽象方法:当类中有一个方法,他没有方法体,也就是没有花括号,直接分号结束,象这种方法我们叫抽象方法,必须使用关键字abstract定义
    例如:public abstract function fun();
  抽象类:包含抽象方法的类必须是抽象类也要使用关键字abstract加以声明。(即使用关键字abstract 修饰的类为抽象类
  抽象类的特点:
    不能实例化,也就new成对象
    若想使用抽象类,就必须定义一个类去继承这个抽象类,并定义覆盖父类的抽象方法(实现抽象方法)。

  其实抽象类对于子类(实现类),有一个约束的作用。子类继承一个抽象父类必须实现父类中的所有抽象方法(除非它也是一个抽象类)
    注意:含有抽象方法的类肯定是抽象类,但是不是所有的抽象类都必须包含抽象方法。

 1 <?php
 2     //抽象类父类A
 3     abstract class A
 4     {
 5         public function fun1()
 6         {
 7             echo "fun1()...<br/>";
 8         }
 9
10         public function fun2()
11         {
12             echo "fun2()...<br/>";
13         }
14
15         public abstract function fun3();
16
17         /**
18          *求和方法
19          * @param int $a 被求和参数1
20          * @param int $b 被求和参数2
21          * @return int 返回求和结果
22          */
23         public abstract function add($a,$b);
24
25     }
26
27     class B extends A
28     {
29        public function fun3()
30         {
31             echo "fun3()...<br/>";
32         }
33
34        public function add($x,$y)    //这就是约束:函数名必须是add,参数必须有两个
35        {
36            return $x+$y;
37        }
38     }
39
40     $b = new B();
41     $b->fun1();
42     $b->fun2();
43     $b->fun3();
44     echo $b->add(10,20);
45 ?>

二、接口
  PHP与大多数面向对象编程语言一样,不支持多重继承,也就是说每个类只能继承一个父类。为了解决这个这个问题,PHP引入了接口,接口的思想是指定了一个实现了该接口的类必须实现的一系列函数。
  接口:如果在一个抽象类中包含的只有抽象方法,可以将其定义为interface(接口),用implements(实现)关键字使用它。
  定义格式:
    interface 接口名称
    {
      //常量成员 (使用const关键字定义)
      //抽象方法 (不需要使用abstract关键字)
    }
  使用格式: class 类名 implements 接口名1,接口名2{ ... ... }

  当一个类在实现了一个接口后,它必须实现即覆盖该接口的所有方法才可以实例化使用,否则即为抽象类。

 1 <?php
 2     //接口
 3     interface A
 4     {
 5         public function fun1();
 6
 7         public function fun2();
 8
 9         public function fun3();
10
11     }
12
13     //定义了类B实现接口A
14     abstract class B implements A
15     {
16        public function fun1()
17        {
18             echo "fun1()...<br/>";
19        }
20        public function fun2()
21        {
22             echo "fun2()...<br/>";
23        }
24
25     }
26     class C extends B
27     {
28        public function fun3()
29        {
30             echo "fun3()...<br/>";
31        }
32     }
33
34     $b = new C();
35     $b->fun1();
36     $b->fun2();
37     $b->fun3();
38 ?>

三、抽象类与接口的区别
  定义:
    抽象类表示该类中可能已经有一些方法的具体定义。
    接口就仅仅只能定义各个方法的界面,不能有具体的实现代码在成员方法中。
  用法:
    抽象类是子类用来继承的,当父类已有实际功能的方法时,该方法在子类中可以不必实现。
    实现一个接口,必须实现接口中所有定义的方法,不能遗漏任何一个。
  理解: 接口就像公司老板(每年定下一系列目标,不去做,只提出各种计划)
      抽象类就像公司各层级经理(配合老板定下的计划,实现一部分,分发一部分任务员工)
        最终继承的类就是普通员工(接收经理分发的任务,按照要求,毫不遗漏的完成)
四、多态
  对象的多态性是指在父类中定义的属性或行为被子类继承之后,可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或行为在父类及其各个子类中具有不同的语义。
  为什么要多态?
    多态可以使程序可扩展性更强,减少代码更改量。
  实现多态的方法:继承(重写)、抽象、接口
  例如:"几何图形"的"绘图"方法,"椭圆"和"多边形"都是"几何图"的子类,其"绘图"方法功能不同。

 1 <?php
 2     //多态
 3     //主板上的PCI插槽接口
 4     abstract class PCI
 5     {
 6         public abstract function start();
 7         public abstract function stop();
 8     }
 9
10     //主板类
11     class MainBoard
12     {
13         public function running(PCI $pci)
14         {
15             $pci->start();
16             $pci->stop();
17         }
18     }
19
20     //声卡厂家
21     class SoundCard extends PCI
22     {
23         public function start()
24         {
25             echo "声卡启动...<br/>";
26         }
27
28         public function stop()
29         {
30             echo "声卡停止...<br/>";
31         }
32     }
33
34     //网卡厂家
35     class NetWorkCard extends PCI
36     {
37         public function start()
38         {
39             echo "网卡启动...<br/>";
40         }
41
42         public function stop()
43         {
44             echo "网卡停止...<br/>";
45         }
46     }
47
48
49     //使用:主程序
50     $mb = new MainBoard();
51     $sc = new SoundCard();
52     $nc = new NetworkCard();
53
54     $mb->running($sc);
55     $mb->running($nc);
56 ?>
时间: 2024-08-13 21:40:43

PHP面向对象(五)的相关文章

Javascript学习总结-面向对象-(五)

1. 面向对象 JavaScript面向对象的脚本语言,此时开发者在开发的时候需要找对象,默认提供了内置的对象.也可以根据开发者的需求自己定义对象. 1.1.     基本数据类型包装类 为了便于操作基本类型值,ECMAScript 提供了3个特殊的引用类型:Boolean,Number,String.它们是引用类型.当读取基本数据类型时,后台就会创建一个对应的基本包装类对象,所以我们在操作基本数据类型时,可以直接调用一些方法. 1.1.1.  String //通过构造函数创建String 对

Java学习之面向对象五

###01final关键字概念 * A: 概述 继承的出现提高了代码的复用性,并方便开发.但随之也有问题,有些类在描述完之后,不想被继承, 或者有些类中的部分方法功能是固定的,不想让子类重写.可是当子类继承了这些特殊类之后, 就可以对其中的方法进行重写,那怎么解决呢? 要解决上述的这些问题,需要使用到一个关键字final,final的意思为最终,不可变. final是个修饰符,它可以用来修饰类,类的成员,以及局部变量. ###02final修饰类义 * A: final 修饰类 final修饰类

python 面向对象五 获取对象信息 type isinstance getattr setattr hasattr

一.type()函数 判断基本数据类型可以直接写int,str等: 1 >>> class Animal(object): 2 ... pass 3 ... 4 >>> type(123) 5 <class 'int'> 6 >>> type('123') 7 <class 'str'> 8 >>> type(None) 9 <class 'NoneType'> 10 >>> ty

python 面向对象(五)约束 异常处理 MD5 日志处理

###############################总结###################### 1.异常处理 raise:抛出异常 try: 可能出现错误代码 execpt 异常类 as e: 异常处理 execpt 异常类 as e: 异常处理 else: 如果上面的代码没有报错,执行这里 finally: 收尾 自定义异常: 随便写个类. 继承Exception 2. 约束 父类和子类. 在父类中声明方法. 要求子类必须重写它 1. 抛出异常. raise NotImplem

面向对象的3个要素,5个原则 和 6视点

面向对象三要素 封装(Encapsulation) 继承(Inheritance) 多态(Polymorphism) 面向对象五原则 单一职责原则(SRP) 开放-封闭原则(OCP) Liskov替换原则(LSP) 依赖倒置原则(DIP) 接口隔离原则(ISP) 面向对象六视点 复用(Reusibility) 扩展(Extensibility) 分离(Separability) 变化(Change) 简约(Simplicity) 一致(Coherance) ===================

Java沉思录之面向对象

通过相关编程语言的发展历史,探究面向对象的思想. 面向对象发展历史 从面向过程说起 自C语言出现以来,风靡一世,操作系统.各种软件.工具使用C语言开发.更甚的是尼古拉斯·沃斯喊出的那句,"算法+数据结构=程序".仿佛所有问题只要一步一步走下去就能解决.事实上,如果要使用面向过程的思想来处理当然也是没问题的.不过这时候,总有一个疑惑萦绕不去,这种方法是不是最优解?如果一个项目,使用面向过程的方法,新的需求出来了,是不是容易扩展?代码是否能够重用?是否容易维护?面向过程是计算机的思维,人毕

面向对象的三大基本特征和五大基本原则

前言 前文提到,面向对象的三个特征:封装.继承.多态.那么面向对象是怎么体现这三个特征呢? 关于五大基本原则,个人找资料的时候看得头都大了,对新手(如我)来说还是比较有理解难度的,本篇用较为简单的表述来帮助理解,想先看进阶版(完全版)的可以先移步:牢记面向对象五个基本原则 面向对象的三大基本特征 1. 封装 封装,就是将客观事物抽象为逻辑实体,实体的属性和功能相结合,形成一个有机的整体.并对实体的属性和功能实现进行访问控制,向信任的实体开放,对不信任的实体隐藏.,通过开放的外部接口即可访问,无需

[python实现设计模式]-3.简单工厂模式

预备知识: 开放封闭原则(Open-Closed Principle OCP) Software entities(classes,modules,functions etc) should open for extension ,but close for modification. 所谓开放封闭原则就是软件实体应该对扩展开放,而对修改封闭.开放封闭原则是所有面向对象原则的核心. 软件设计本身所追求的目标就是封装变化,降低耦合,而开放封闭原则正是对这一目标的最直接体现. 对扩展开放,意味着有新

(1)Single Responsibility Principle【单一职责原则】

单一职责原则 SRP:Single responsibility principle [概述]单一职责原则又称单一功能原则,面向对象五个基本原则(SOLID)之一.它规定一个类应该只有一个发生变化的原因.该原则由罗伯特·C·马丁(Robert C. Martin)于<敏捷软件开发:原则.模式和实践>一书中给出的.马丁表示此原则是基于汤姆·狄马克(Tom DeMarco)和Meilir Page-Jones的著作中的内聚性原则发展出的. 所谓职责是指类变化的原因.如果一个类有多于一个的动机被改变