PHP的面向对象

SPIRT00

已于 2023-01-12 17:08:26 修改

阅读量772

点赞数 1

分类专栏： PHP语言文章标签： php 开发语言

于 2023-01-09 23:46:50 首次发布

本文链接：https://blog.csdn.net/weixin_51884452/article/details/128597822

版权

PHP语言专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

一、PHP
总结

一、PHP

1.面向对象的历史

机器语言
汇编语言
高级计算机语言
步骤拆分，模块封装
代码复用

2.面向对象的编程思想

一切皆对象
面向过程，比如购物顺序执行。顺序不能乱
面向对象，相当于多加入卖家和买家。谁来做这件事情。
面向对象是一种思想。
增加了数据和功能的操作实体。即对象
数字和功能由对象来操作。

3.面向对象基础

面向对象的语法格式实现的功能才属于面向对象编程（opp）

1.面向过程的方式实现一个功能：购买商品

#定义函数购买商品
function buy($goods_id,$num=1){
	echo '商品：'.$goods_id.'购买：'.$num.'个';
	return;
}
#调用解决
buy(1,10);#输出商品1购买10个

2.面向对象的方式实现一个功能：购买商品

#确定是消费者购买（类）
class Buyer{
	#拥有购买功能（方法）
	function buy($id,$num=1){
	echo '商品：'.$goods_id.'购买：'.$num.'个';
	return;
	}
}
#确定具体买家购买
$b=new Buyer();  #产生具体买家（对象），new是实例化对象。
$->buy(1,10); #输出：商品：1购买10个

3.面向对象的关键字说明

类：class,面向对象主体的最外层，包含主体数据和功能。类是一个共性事件。
对象：object，某类事务的具体代表，也是实际数据和功能的具体单元。
实例化：new,从抽象到具体的过程。
类成员：member，指类class结构中创建的内容
方法：method，类class中创建的函数
属性：property,创建的变量
类常量：const，创建的常量

4.面向对象的简单技术实现

类：通用结构
class关键字声明类

class 类名{
}

5.实例化

new 类名；
new 类名（）；

6.对象，根据类产生的某个具体存在的实体，对象一般使用变量保存

$object=new 类名（);
步骤
1.根据产生类结构
分析类的数据
行为

#定义一个空类
class Nothing{}
#类实例化产生对象：new
$n=new Nothing();
var_dump($n);
#打印结果分析
object(Nothing)#1 (0) {}
#1:对象编号，（0）成员变量个数，{}：具体成员信息键值对

4.类成员

1.定义

类成员：直接定义在类结构{}内部的一级成员，即直接依赖{}的成员
类成员分类
成员变量（属性）：给对象存储数据的变量
成员函数（方法）：解决问题的函数
类常量：属于类内部的常量，使用const关键字定义
属性和方法需要使用访问修饰限定符，如public

class 类名{
 #类常量可以多个
 const 常量名=值；
 #属性
 public $属性名=[=值];#可以赋值也可以不赋值
 #方法
 public function{}
 }

成员访问：属性和方法属于对象访问，类常量属于类访问。
对象访问属性和方法，使用**->**

#实例化
$object =new 类名（）;
#属性访问
$object->属性名;#不带$
#方法访问
$object->方法名;

2.声明类结构

#定义买家类：买家姓名和钱
class Buyer{
	#属性说明
	$name;
	public $name;
	public $money=0;
	#方法说明
	function display(){
		echo _CLASS_;#魔术常量，输出类名
		}
		#类常量声明
		const BIG_NAME='BUYER';

成员变量访问（属性和方法）：成员通过对象访问，实例化，对成员操作

$b =new Buyer();
echo $b->money;
#删除属性
unset($b->name)
#访问方法
$b-display();

注意：类成员：属性，方法，类常量。除了三个类成员，不能在类结构{}中直接写其它任何代码

5.访问修饰限定符

1.访问修饰限定符

public:公有，类内类外都可以访问。
protected:受保护，只允许相关类内部访问。
private：私有，只允许定义类内部访问。

2.步骤

声明类结构
确定类成员
确定类成员的访问位置限定，使用对应访问修饰限定符。
在对应位置访问被修饰的成员

6.类内部对象

1.内部对象

$this，方法内部设置的一个对象，自动调用方法的对象。
$t hi s 存在方法的内部，可以访问任意修饰限定符的成员私有成员可以通过公有方法来实现访问（公有方法可以在类外部访问）类内部必须通过$ this内部对象访问类成员

2.使用内置对象$this访问

class Saler{
	#属性
	public $count=100;
	protected $discount=0.8;
	private $money=100;
	
	public function getALL(){
	var_dump($this);
		echo $this->count,$this->discount,$this->money;
		}
	}
$s=new Saler();
$s->getALL();

注： $t hi s 代表的是对象，$ this在方法的内部，所以$this对象在类内部访问，因此可以访问所有的属性和方法，不受访问修饰限定符的限制。

7.面向对象开发规范

1.开发规范

访问的权限public,protected,private依次变小。
设置好的类成员不会被外部用到，使用private,protected。

2.属性初始化

class saler{
	#属性
	public $count;
	#某个买家拥有的商品数量，买家拥有的可能不一样，所以没必要初始化。
	protected $discount;
	#买家对销售的折扣，没有统一价值
	private $money=0;
	#买家的账户余额

	#业务初始化属性
	public function setDiscount($discount=1){
		#可以进行逻辑控制
		$this->discount=$discount;
		}
	}
	#实例化对象，初始化属性
	
$s=new saler();
$->count=100;
#打折促销，业务初始化。
$s->setDiscount(0.8);

3.访问修饰限定符选择

class saler{
	#属性
	public $count;
	private $money=0;
	
	#增加方法操作私有属性money
	public function getMoney(){
		return $this->money;
		}
	public function setMoney($money){
		#可逻辑修改，对数据进行安全判定
		$this->money=$money;
		$this->money是属性，$money是外部传入的参数，二者同名但性质不同。
		}
	}

属性在类中定义时通常不会初始化
尽可能增加类的控制

8.构造方法

1.概念

__construct(),系统定义自动调用
受访问限定符控制
构造的方法可以设置形参：如new 类名（实参）

2.例子

#构造方法实现：在类中增加一个方法__construct()
class saler{
	public function __construct(){
		echo __CLASS__;
		}
	}
#类实例化后马上自动调用
#实例化
new saler(); #输出saler

class saler{
	#属性
	public $count;
	private $money;
	#构造方法，初始化属性
	public function __construct($count,$money){
		$this->count=$count;
		$this->money=$money;
		}
	}
#实例化对象
$s1=new saler(100,100);
$s->__construct(100,100);#允许手动调用

构造方法__construct()是一种系统内置方法，实例化后自动调用
目的时初始化资源
且构造方法自带参数，那只能使用new 类名（参数列表）

9.析构方法和对象传值

1.析构方法

__destruct(),对象被销毁时调用

2.对象传值

对象传值：将一个对象的变量赋值给另一个变量
两个变量指向同一个对象的内存地址。

#对象传值是保存对象的变量赋值给另一个变量
class saler(){}
$s1=new saler();
$s2=$s1;

#对象传值是引用传递，不管对象赋值给多少个变量，内存中只有一个对象
var_dump($1,$2);#同一个对象
$s1->name='saler'; #更改一个变量所保存对象的属性
echo $s2->name; #输出saler

10.范围解析操作符（类常量访问）

1.概念

由两个冒号组成"::",用类成员的操作，可直接实现类直接访问类成员
格式：类名：：类成员
不建议使用: $对象名：：类成员
注：类常量只能被类访问

class saler(){
	const PI=3.14;
	}
$s1=new saler();
echo $s1->PI;#不能访问
echo saler::PI;#输出 3.14

类本身是通过对同类对象的操作而形成，所以属性和方法本身都是由对象来访问
类也需要自身的数据和操作，这些由类进行访问。

11.静态成员

1.概念

使用static关键字修饰类成员，表示该成员属于类访问
php静态成员两种
静态属性和静态方法
确定有些成员（属性，方法）不需要对象访问，直接通过类访问
静态成员应该让类进行访问

#静态属性
class saler{
	public $money=0;
	public static $count=0;#静态属性
	}
	#静态成员可以直接使用类访问，不需要实例化对象
echo saler::$count;
  
#静态方法
class saler{
	public static function showClass(){
		echo __CLASS__;
		}
	}
	#类直接访问
	saler::showClass();


#在类的内部也可以访问静态成员
class saler{
	#属性
	private static $count=0;#私有不允许外部直接访问
	#方法
	public static function showClass(){
			echo saler::$count;
			}
	}
	#类直接访问
	saler::showClass();
	  

#静态方法本质给类访问的，不允许静态方法内部使用$this对象
class saler{
	public static function testStaticThis(){
			var_dump($this);#错误
			}
	}

12.self关键字’

1.概念

在类的内部使用，代替类名
self同$this代表内部对象一样，能够在方法内部代替当前类名
self关键字是代替类名，需配合范围解析操作符::

class saler{
#静态属性
private static $count=0;
public static function showClass(){
		echo saler::$count;
		echo self::$count;
		}
}
#self也可以在类的内部实例化对象：如构造方法被私有化之后，就没有在类外部实例化，此时可在类内部进行实例化
class saler{
	private static $count=0;
	private function __construct(){
	public static function getInstance(){
		return new saler();
		return new self();#用self代替类名进行内部实例化
		}
	}
	$s=saler::getInstance();

self可以在类内部访问静态成员
self可以在类内部用来实例化对象

13.类的加载

1.概念

类的访问必须保证类在内存中已经存在
类的加载分类：手动和自动加载
手动加载：通过include将包含类的文件引入内存中。
自动加载：提前定义好类结构和位置，写好引入类文件代码
自动加载两种方式

魔术函数__autoload():系统自动调用，需要传入类名

function __autoload($calssname){
#找到对应文件路径和命名规范，手动加载
}

自定义函数

#自定义类加载函数
function 自定义函数($classname){
}
#注册自动加载
sql_autoload_register('自定义函数名字');

2.手动加载

#类文佳：saler.php
<?php
class saler{}
?>


#应用文件：usesaler.php
#使用saler类需要先包含saler类所在的文件
include_once 'saler.php';#include_once，类允许重名
$s=new saler();

#加载类文件是一种比较消耗资源的方式，有时不确定类是否在内存中存在，可以事先使用class_exists()函数
#来判定是否存在
#使用saler类，
if(!class_exists('saler')){
#不存在，加载
include_once 'saler.php';
}
$s=new saler();

3.自动加载

#自动加载：利用系统提供的__autoload()函数
function __autoload($classname){  #参数为类名：当前需要访问类的名字
  #需要人为定义去哪加载，怎么加载
  include_once $classname .'.php';  #假定为当前目录下
 }
 #使用类：内存目前并没有
 $s=new saler();  #系统发现内存没有saler,所以调用__autoload()去加载

function __autoload($classname){
	#组织文件路径，假设当前路径下
	$c_file='c/'.$classname.'.php';

14.对象克隆

1.概念

将已有的对象复制一个新的同样的对象，但两者之间并非同一个对象

<?php
class saler{
	public $count;
	private $money;
	#克隆魔术方法
	public function __clone(){
		#var_dump($this);
		echo __METHOD__;
		#修改对象
		$this->money=10;
}
$s1=new saler();
$s1->count=1;
#克隆
$s2=clone $s1;
var_dump($s1,$s2);