php面向对象编程(英语:Object-oriented programming,缩写:OOP),对象是一个由信息及对信息进行处理的描述所组成的整体,是对现实世界的抽象。
个人理解,万物皆对象,通过定义类然后为这个类添加属性方法,再将其实例化的过程为面向对象编程,抽象是抽象了点,但是实质上对象无处不在,看个人如何去定义,有这样一句话“佛说:要有光,于是就有了光”,对象也是如此,你可以成为这个佛,但是编程也是为大众服务的,所以对象也要贴近现实。
本文包含内容:
类的构成、依赖注入、final, self, $this关键字的使用、oop封装与继承。
一.类的构成
1.每个类的定义都以关键字 class 开头,后面跟着类名,后面跟着一对花括号,里面包含有类的属性与方法的定义,类名可以是任何非 PHP 保留字的合法标签。
一个合法类名以字母或下划线开头,后面跟着若干字母,数字或下划线。以正则表达式表示为:[a-zA-Z\x7f-\xff][a-zA-Z0-9\x7f-\xff]*。
2.类属性:一定要有关键词修饰,public(公有的)、private(私有的)、protected(受保护的)、static(静态的);
3.类方法:一个类可以包含有属于自己的常量,变量(称为“属性”)以及函数(称为“方法”)
4.类实例化:对象引用名 = new 类名([参数列表]) or 对象引用名 = new 类名;
上代码:
classapple{
// 类属性 ,一定要有关键词修饰 public private protected static
public$ipad="max";// 默认值
public$mac;
public$iphong;
// 类构构造方法/器,创造对象时对对象属性进行初始化辅助,每创建一个对象,__construct()自动会被调用一次
publicfunction__construct($ipad=""){
$this->ipad=$ipad;//$this 特殊的对象引用 ,代表本对象,专门完成对象内部成员的访问
}
// 类方法
publicfunctionstyle(){
echo"There are three";
}
publicfunctionprice(){
echo"$900";
}
publicfunctionsize(){
echo"12 inches";
}
}
// 类实例化
// 对象引用名 = new 类名([参数列表]) 对象引用名 = new 类名
$apl=newapple;
// 访问对象属性,对象方法 ->
echo $apl->style();
// 将对象重新赋值 在类的外部
$apl->ipad='ipadmini';
echo $apl->price();
二、依赖注入
classUsers{
public$name='老胡';
publicfunctionaction(Closure$act,string$name1){
// 在类方法中访问类外部成员:变量,函数
//$str = act();// 局部变量,非类属性
//global $name1;
//return $this->name . "和".$GLOBALS['name1'].$str;
return$this->name."和".$name1.$act();
}
// 在实际项目中,外部成员应该通过方法参数,注入到成员方法中,而不是在方法中直接调用
}
$act=function(){
return'一起去搓澡';
};
$name1="胖子";
// echo (new Users)->action();
echo(newUsers)->action($act,$name1);// 老胡和胖子一起去搓澡
三、final, self, $this关键字的使用
1.$this :特殊的对象引用 ,代表本对象,专门完成对象内部成员的访问
2.self 是类内部代替类名的关键字,可以用来在类内部完成静态成员的访问(类常量)以及在类内部实例化对象
3.final :加在类前,表示该类不能被继承加在方法前,表示该方法不能被重写
$this与final上下例子都有使用与注解,这里安排一下self
//在内部实例化
classcredit{
constCONSTANT='con';
privatestatic$age=18;
staticfunctiongetAge(){
echo credit::$age.'
';//18
echoself::$age.'
';//18
echoself::CONSTANT.'
';//con
}
}
// 外部使用类名访问
credit::getAge();
访问静态
// static 标识静态成员(方法,属性),静态成员只能由类来调用,为所有对象共享
classUser{
public$name="大哥";
public$options=[1,2,3];
publicstatic$nation="china";
public$salary;// 抽象属性
}
$user=newUser;
// 访问静态成员 使用:: 范围解析符
echoUser::$nation;//china
classmyClass{
public$age=18;
static$name="刘亦菲";
static$count;
function__construct(){
self::$count++;
}
publicstaticfunctiongetCount(){
returnself::$count;
}
}
// 对类中的静态属性进行初始化赋值 为0
myClass::$count=0;
$myc=newmyClass;
// 访问静态成员的方法
echo myClass::$count;
echo myClass::getCount();
//echo $myc->getCount(); 通过对象也可以访问静态成员方法
四、oop封装与继承
/**
* 封装性
*/
classUser{
//public 公共成员 , 类外部和内部都能访问
public$name='胡八一';
//private 私有成员,仅限于本类中使用,外部和子类中是访问不到
private$age=30;
//protected 受保护成员,除了外部不可见,内部和子类均可见
protected$salary=8000;
publicfunctionwrite()
{
return"姓名{$this->name},年龄{$this->age},工资:{$this->salary}";
}
}
//echo (new User)->age;//Cannot access private property User::$age
//echo (new User)->salary;//Cannot access protected property User::$salary
echo(newUser)->name;
echo(newUser)->write();
//子类
echo'
';
classRobextendsUser
{
publicfunctionwrite()
{
return"姓名{$this->name},工资:{$this->salary}";
}
}<?php
/**
* 对象的继承与扩展
*
* final:加在类前,表示该类不能被继承
* final :加在方法前,表示该方法不能被重写
*/
classUser{
protected$salary=8000;
publicfunctionwrite()
{
return"工资:{$this->salary}";
}
}
//子类
classRobextendsUser
{
//1.扩展
//属性扩展
protected$name="胡歌";
protected$age=45;
//方法扩展
// public function write()
// {
// return parent::write(). ",age:{$this->age}";
// }
//2. 重写
//属性重写
protected$salary=10000;
//方法重写
publicfunctionwrite()
{
returnparent::write().",age:{$this->age}";
}
}
echo(newRob)->write();
拓展:
__construct() 构造函数
1.构造函数实例化类的时候会自动调用,
2.子类没有构造函数,会直接调用父类的构造涵数, 继承父类的属性和方法
3.子类和父类都有构造函数,实例子类时不会自动调用父类构造函数,只会调用子类自己的构造函数。
耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立性)。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。