PHP面向对象的小总结

 面向对象特性：

*重用性 （每个模块都可以在项目中重复使用）

*灵活性 （每个模块都很轻松被替换更改的）

*拓展性（在模块上添加新功能是很方便的）

类和对象的关系（类生成对象）
在类里面只能有 成员属性 和 成员方法！！！！不能有其他，在一个脚本中不能有两个同名类,实例化类可以有多个对象

class Computer{
    public $text = "用关键字new实例化一个类";
    public function output(){
    echo $this->text;
    }
}
$computer = new Computer();

$computer->output();

类的属性和方法

访问控制：
public 公有 都可以访问
private 私有  只有类本身内部可以访问
protected  受保护 继承的子类和类本身内部可以访问，外部访问不了，如: $computer->output();如果output()方法设了protected，则报错。

类里面的方法：

方法里面调用一个属性，需要实例化类才能访问属性，而$this可以理解为是这个类的一个实例

class Computer{
    public $text = "用$this调用我";
    public function output(){
    echo $this->text;
    }
}

构造方法与析构方法（实例化时执行和销毁时执行）

class Computer{
   public function __construct($high){
　　echo "我是构造方法，会自动执行"
　　}
}
new Computer();

构造方法的参数是在实例化一个类时传入：new computer(1)

析构方法：不能有参数
public function __destruct(){

}
手动释放 unset($computer);
类常量： 内部访问 self:: 外部访问不需要实例化：类名::常量名
const yh = 1;
const yh2 = self::yh +1;

$this 和self 的区别，一个是对象$this 相当于实例化后，可以说除过静态和const常量，基本上其他都可以使用this联络 ；self则是类本身 self可以访问本类中的静态属性和静态方法，可以访问父类中的静态属性和静态方法。用self时，可以不用实例化的

类的继承：
class boy extends dad{
}
子类可以覆盖父类的方法

子类没有构造方法时，会调用父类的构造方法，有则调用自己的，
用关键字 parent:: __construct();可以调用父类的构造方法
用final关键字加在类前面就不会被继承；加到方法面前，此方法就不会被重写

命名空间：解决冲突问题
利用文件系统不用目录的原理
引入的php文件中加入 namespace 目录\子目录;
使用时调用：new 目录\子目录\类名();如 new com\session\computer();
收命名空间影响的有，类（包括抽象类，traits），接口，函数，常量（是const定义的常量，define的是全局的）
由于每次调用都要写上路径，教麻烦，所以出现use的用法（use引入必须带类名或者函数名）
在调用时先用use引入，use 目录\子目录\类;还可以起个别名区别 as
use venter\session\computer;
use venter\computer as computer2;
new computer();
new computer2();

函数的话记得带上function
use function venter\session\computer;
computer();

常量记得带上const
use const venter\session\computer;
var_dump(computer);

重点：在命名空间里面调用全局的类，函数，常量的区别，
页面a定义了命名空间 namespace venter;引入b页面后，此时想调用b页面的类，必须：
New \venter() 加个\代表全局空间下的
但是调用函数和常量时，就不需要加，因为他会自动寻找，向全局寻找。

类自动加载：
当你实例化一个类时，这个类不存在，就会自动执行我们写的 function __autoload($className){},在这个自动函数的内部去执行我们想要操作的代码，参数就是我们实例化的类名，因此可以根据参数去引入php文件。
__autoload将被淘汰，使用新的函数 spl_autoload_register();参数可以传函数名或者匿名函数
spl_autoload_register(function($a){
echo $a;
}
);
new Computer();
或者
function aaa($a){
echo $a;
}

spl_autoload_register(‘aaa‘);
new Computer();
或者类的调用方法
class momo
{
function aaa($a){
echo $a;
}
}
spl_autoload_register([new momo],‘aaa‘);
new Computer();

利用命名空间和自动加载实现项目自动引用
1，文件目录就和命名空间名一样，文件名和类名一样 new models\imooc() 就是在models文件下的imooc.php文件，
2，然后利用spl_autoload_register(function($classname){
include str_replace("\\","/",$classname.".php");
});
这里的作用是models\imooc替换掉models/imooc.php 引入
而imooc.php文件中必须命名 namespace models；

static 静态
当属性和方法被定义为 static 时就变成类的属性和方法，不属于对象的，不需要实例化
class person{
public static $aa ="a";
}
echo(person::$aa);

子类用parent::调用父类的静态方法

静态方法不能调用非静态属性
//因为 $this代表实例化对象，而这里是类，不知道 $this 代表哪个对象

后期静态绑定：
class A{
public static function who(){
echo "A类的who方法";
}
public static function test(){
self::who();
// static::who();
}

}
class B extends A{
public static function who(){
echo "B类的who方法";
}
}
B::test();

如果是self::who(); 输出的是A类的who方法，说明调用的是A自身，static::who();会根据上下文作处理，类B调用就使用B里面的who()

魔术方法
__set($var,$val) 设置私有属性，当外部调用设置一个私有属性时会自动执行这个方法，
__get($var)获取私有属性，原理是外部调用一个私有属性时会自动执行这个方法
例子：
class test{
private $abc = "";
private $ccc = "";
public function __set($var,$val){
$this->$var = $val;
}
public function __get($var){
return $this->$var;
}
}
$test = new test();
$test->abc = ‘abc‘;
var_dump($test->abc);

__isset($var)方法，当外部调用isset($test-abc)访问一个不能访问的属性时，就会自动执行

__unset($var)，当外部想删除一个私用属性时，会自动执行

__call($func方法名,$arguments参数)当外部调用一个没有定义的方法时，就会调用

__callStatic($meethod,$arg)当调用一个不存在的静态方法时，会自动执行 注意在function 前也要加入 static 因为是静态方法

__invoke($rag)当实例化一个类后，把这个对象变量当成函数调用时，会自动执行
例如：$test = new test();
$test("go....");

__toString()当要打印一个对象变量时，会执行，比如 echo($test);

对象拷贝：
浅拷贝：是地址传递（对象是浅拷贝）
深拷贝：复制一份，新开辟一块内存(普通变量是深拷贝)

加clone 使对象成为深拷贝，互不影响；
$a = new A();
$b = clone $a;

__clone()当使用clone时，会自动执行
$a = new A();
$b = clone $a; 在A类中会执行__clone()
例子：
class A{
public $obj = null;
public function __clone(){
$this->obj = clone $this->obj;//开辟了新空间给克隆的对象
}
}
Class B{
public $sex = 0;
}

$a = new A();
$a->obj= new B();
$b = clone $a;
$b->obj->sex = 1;
var_dump($a->obj->sex);

类型约束
class A{
public $obj = null;
public function go(){
echo "googogogogo";
}
}
class B{
public function go(){
echo "gbbbbbb";
}
}
Function test(A $a){
$a->go();
}
test(new A());//必须是A的实例

trait 关键字 解决单继承问题 配合use 使用
trait A{
public function a(){
echo "aaaaa";
}
}
trait B{
public function b(){
echo "bbbb";
}
}

Class test{
use A,B;
public function c(){
echo "cccc";
}
}

$test = new test();
$test->a();
$test->b();
$test->c();

接口 可以理解为类的模板 不能直接被实例化
interface person {
public function eat();
public function sleep();
}
class man implements person{
public function eat(){
echo "chichi吃吃";
}
public function sleep(){
echo "shuishushi";
}
}
$aaa = new man();
$aaa->eat();
接口继承 两种方法
interface aa {
public function eat();
}
interface bb {
public function sleep();
}
interface person extends aa,bb{
//person就直接继承了两种方法
}
class man implements person{
public function eat(){
echo "chichi吃吃";
}
public function sleep(){
echo "shuishushi";
}
}
或者 直接实现两种接口
class man implements aa,bb{
public function eat(){
echo "chichi吃吃";
}
public function sleep(){
echo "shuishushi";
}
}
接口里面可以利用 const 定义一个常量
interface person {
const aa = "bbb";
public function eat();
public function sleep();
}
echo person::aa;
抽象类：内部有自己的执行方法
abstract class person {
public function holiday(){
echo ‘我是抽象类自己的方法‘
}
public function eat(){}
public function sleep(){}
}
class man implements person{
public function eat(){
$this->holiday();//直接调用即可
echo "chichi吃吃";
}
public function sleep(){

echo "shuishushi";
}

}
$aaa = new man();
$aaa->eat();

单例模式：让一个类只会被实例化一次，节省空间
先把构造函数和克隆函数变成私用属性
class test{
private static $_instance = null;//依靠属性存储实例对象判断是否已经实例过
private function __construct(){
// 私有后将不会被外部实例
}
private function __clone(){
// 私有后将不会被外部克隆
}
public static function getInstance(){
if(!(self::$_instance instanceof self)){
// instanceof判断是否是当前的实例，不是的话就实例化赋值，否则就返回
self::$_instance = new self();
}
return self::$_instance;
}
}
$test1 = test::getInstance();
$test2 = test::getInstance();
$test3 = test::getInstance();
var_dump($test1);
var_dump($test2);
var_dump($test3);
// 输出结果object(test)#1 (0) { } object(test)#1 (0) { } object(test)#1 (0) { }

工厂模式：就是在多处实例化一个类，当这个类名需要改变时，就会导致大量地方需要更改，使用工厂模式避免这种情况发生
class A{
public function a(){
echo ‘aaa‘;
}
public function c(){
echo ‘ccc‘;
}
public function b(){
echo ‘bbb‘;
}
}
class cashe{
public static function factory(){
return new A();//当业务逻辑变化时，只需要改此处
}
}
$cashe = cashe::factory();
$cashe->a();

/*--------------多态的一个应用实例 模拟USB设备的使用------------------*/

//一个USB的接口

interface USB{

function mount();//装载USB的方法

function work();//USB工作的方法

function unmount();//卸载USB的方法

}

//定义一个USB设备 U盘

class Upan implements USB{//实现USB接口

function mount(){

echo " U盘 装载成功<br/>";

}

function work(){

echo "U盘 开始工作<br/>";

}

function unmount(){

echo "U盘 卸载成功<br/>";

}

}

//定义一个USB设备 USB鼠标

class Umouse implements USB{//实现USB接口

function mount(){

echo " USB键盘 装载成功<br/>";

}

function work(){

echo "USB键盘 开始工作<br/>";

}

function unmount(){

echo "USB键盘 卸载成功<br/>";

}

}

//定义一个电脑类

class Computer{

//使用USB设备的方法

function useUSB ($usb){//$usb参数表示 使用哪种USB设备

$usb->mount();//调用设备的 装载方法

$usb->work();//调用设备的 工作方法

$usb->unmount();//调用设备的卸载方法

}

}

//定义一个电脑的使用者的类

class PcUser{

//

安装

USB的方法

function install(){

//首先拿来一台电脑

$pc=new Computer;

//拿来一些USB设备

$up=new Upan;//拿来一个U盘

$um=new Umouse;//拿来一个USB鼠标

//把USB设备插入电脑, 使用电脑中使用USB设备的方法 来调用 要插入的设备

$pc->useUSB($up);//插入U盘

$pc->useUSB($um);//插入USB鼠标

}

}

//实例化一个电脑用户

$user=new PcUser;

$user->install();//安装设备

/*-------------输出内容--------------

U盘 装载成功

U盘 开始工作

U盘 卸载成功

USB键盘 装载成功

USB键盘 开始工作

USB键盘 卸载成功

-----------------------------------*/

?>

原文地址：https://www.cnblogs.com/youthBlog/p/9796475.html

时间： 2024-08-29 11:19:18

PHP面向对象的小总结的相关文章

Java 面向对象编程小练习（曾经）

最近打算将之前学习过的小练习分享出来,算是巩固知识.虽然是小练习,但是越看越觉得有趣,温故而知新. 练习:功能跳水比赛,8个评委评分.运动员成绩去掉最高和最低之后的平均分 代码实例: 1.导包 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; 2.测试类 public class Demo6 { /** * @param args */ public stati

OC面向对象和小知识点

oc小知识点: 在c语言中汉子占三个字节 oc中汉子和字符都是一个字节 #include 和 #import 区别w import 可以防止重复包含 Foundation 把oc的库文件都包含过来 @autoreleasepool 自动释放池 NSLog 会自动换行 NSLog 会自动输出时间项目信息 NSLog 传递的函数参数是NSString对象 printf传递的是字符串常量指针 NSLog 也可以进行格式化输出 NSlog(@"------>%s", str); //不可

面向对象的小demo

两个类如下 package cao.com.duixiang; import java.util.Arrays; public class OtherTest { //求max public int getMax(int[] arr) { int max = arr[0]; for(int i=1;i<arr.length;i++){ if(max<arr[i]){ max = arr[i]; } } return max; } //求min public int getMin(int[] a

Python 面向对象的小例子

1 #!/usr/bin/python 2 # -*- coding: UTF-8 -*- 3 # added by kangye python27 4 5 class Person: 6 "人的基本类型" 7 # 申明类属性 8 name = "" 9 age = 0 10 # 私有属性 11 __sex = "man" 12 13 # 构造方法 14 def __init__(self, name, age , sex="man&q

java String的比较，BOX装箱拆箱，以及面向对象的小代码

package cn.hncu.day2; public class StringDemo { public static void main(String[] args) { String str1 = "abc";//直接赋值,放在栈中,数据共享 String str2 = "abc"; System.out.println("str1==str2: "+(str1==str2));//true String str3 = new Strin

面向对象方法小练习

定义MySQL类 1.对象有id.host.port三个属性 2.定义工具create_id,在实例化时为每个对象随机生成id,保证id唯一 3.提供两种实例化方式,方式一:用户传入host和port 方式二:从配置文件中读取host和port进行实例化 4.为对象定制方法,save和get_obj_by_id,save能自动将对象序列化到文件中,文件路径为配置文件中DB_PATH,文件名为id号,保存之前验证对象是否已经存在,若存在则抛出异常,;get_obj_by_id方法用来从文件中反序列

python 学习 ［day7］面向对象

编程模式概念 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发“更快更好更强...” 面向对象的三大特性 一.封装 第一步:将内容封装到某处 class Teacher: #定义了一个Teacher对象 #__init__ 构造方法,在创建对象时会自动执行类中的构造方法 def __init__(self, favor, name, age): #self类中的所有方法必须包含self参数,sel

python 面向对象简单理解

面向对象: 是一种程序设计范型 作用: 提高软件的重用性和灵活性,扩展性 世界万物一切皆为对象,对象即是指由特定状态,特征,行为的实体 知识点一: 代码的重用 举个栗子 比如小月月有了一个女朋友1,因为一些其他原因,这个女朋友1离开了,不久以后,小月月又 找到了一个女朋友2,那么这个女朋友2和女朋友1肯定是有一些基本的共性的 ,比如走路, 是个女性,都有自己的名字,这时候,如果小月月是个富二代,他想找个小三,小三也具有 这些基本的共性,所以他就可以很快的new出来一个小三,只需要在此基础上添加额

php面向对象实现简单的用户注册登陆

工作几个月了用框架开发过网站,也用混编写过程序,但是对于面向对象我一直很吃力,总感觉无从下手,于是开始在网上找一些基础的面向对象的视频来学习.昨天我在网上找到了一个关于会员注册登陆的用面向对象来实现的一个简短的视频,老师讲的很快,总共不到一个小时的视频,听得我也是云里雾里的,所以又听了一遍,顺便写下这个博客,希望和我一样的新手可以逐渐的理解面向对象,当然大家页可以直接去51cto直接看原装的视频. 首先上图:这是我自己画的一个图,主要用来将页面与类的逻辑关系分清楚,也帮助大家理解. demo文件