1、类的声明
[修饰符] class 类名{
var 成员属性
function 成员方法
}
成员属性需要使用var来声明，前面可以加修饰符
修饰符有：
private
public
static
含义同java
2、类的实例化
$变量名=new 类名(参数列表)
$变量名=new 类名
<?php
class Person{
var $name;
var $age;
var $address;
function callname($name){
echo "my name is {$name}";
}
function gotoArmy($name,$age,$address){
echo "when he was {$age} years old,{$name} deside goto army from {$address}";
}
}
$xiaomin=new Person();
$xiaomin->name="xiaomin";
$xiaomin->age=17;
$xiaomin->address="beijing";
$xiaomin->callname($xiaomin->name);
echo "<br>";
$xiaomin->gotoArmy("zhangsan", $xiaomin->age, $xiaomin->address);
?>
3、对象类型在内存中的分配
- 栈空间段：小且快
- 堆空间段：动态变化
- 初始化数据段：存放可执行文件中已初始化的全局变量。即程序静态分配的变量
- 代码段：存放可执行文件的操作指令，是可执行程序在内存中的镜像。
- 栈空间可以直接存取，堆控件需要通过对象的引用名称访问
- new一个实例就是开辟了一块堆空间
4、对象中成员的方法
$引用名=new 类名称（参数列表）
$引用名->成员属性=属性值
$引用名->成员方法
案例见上例
5、$this
使用$this来替代当前调用对象
<?php
class Person{
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
}
$xiaomin=new Person();
$xiaomin->name="xiaomin";
$xiaomin->age=17;
$xiaomin->address="beijing";
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
?>
6、构造方法和析构方法
1、构造方法__construct
格式：
function __construct(参数列表){
}
案例：
<?php
class Person{
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
}
$xiaomin=new Person("zhangsan",45,"fujian");
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
?>
2、析构方法__destruct
function __destruct(){
}
对象销毁时执行的方法
<?php
class Person{
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
function __destruct(){
echo "good bye {$this->name}";
}
}
$xiaomin=new Person("zhangsan",45,"fujian");
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
echo "<br>";
?>
7、private修饰符设置私有成员
1、private修饰符
使用private修饰符设置，同java
可以设置属性，也可以设置方法
使用private后，成员属性的var可以省略掉
2、set，get私有成员的访问
同java
<?php
class Person{
function __construct(){
}
private $name;
private $age;
private $address;
public function setName($name){
$this->name=$name;
}
public function getName(){
return $this->name;
}
public function setAge($age){
$this->age=$age;
}
public function getAge(){
return $this->age;
}
public function setAddress($address){
$this->address=$address;
}
public function getAddress(){
return $this->address;
}
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
function __destruct(){
echo "good bye {$this->name}";
}
}
$xiaomin=new Person();
$xiaomin->setName("zhangsanfeng");
$xiaomin->setAge(12);
$xiaomin->setAddress("hebei");
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
echo "<br>";
echo "{$xiaomin->getName()}";
echo "<br>";
?>
8、魔术方法__set(),__get(),__isset(),__unset
预定义__set和__get方法对私有属性进行获取和赋值
__isset()检测私有属性是否存在
__unset()删除私有属性
1、__set()方法
类中定义了__set()方法后，在调用私有属性值的时候将自动调用__setXXX()方法，并对该私有属性赋值
两个参数
第一个参数是属性名（并不需要真的存在这个属性名）
第二个参数是属性值（并不需要真的尊在这个属性值）
即意味着将不特定的属性值赋值给不特定的属性名
<?php
class Person{
function __construct(){
}
private $name;
private $age;
private $address;
//使用魔术方法
function __set($propName,$propValue){
$this->$propName=$propValue;//将不特定的属性值赋值个不特定的属性名
}
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
function __destruct(){
echo "good bye {$this->name}";
}
}
$xiaomin=new Person();
$xiaomin->name="lisi";
$xiaomin->age=25;
$xiaomin->address="shandong";
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
echo "<br>";
?>
2、__get()方法
类中定义了__get()方法后，在调用私有属性值的时候将自动调用__getXXX()方法，并对该私有属性赋值
只有一个属性名参数（并不需要真的存在这个属性名）
即意味着将获得不特定的属性的属性值
<?php
class Person{
function __construct(){
}
private $name;
private $age;
private $address;
//使用魔术方法
function __set($propName,$propValue){
$this->$propName=$propValue;
}
//使用魔术方法
function __get($propName){
return $this->$propName;
}
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
function __destruct(){
echo "good bye {$this->name}";
}
}
$xiaomin=new Person();
$xiaomin->name="lisi";
$xiaomin->age=25;
$xiaomin->address="shandong";
$xiaomin->callname();
echo "<br>";
$xiaomin->gotoArmy();
echo "<br>";
echo $xiaomin->address;
echo "<br>";
?>
2、__isset()和__unset()方法
__isset()测试私有属性是否存在
__unset()删除私有属性
对象在外部调用isset（）和unset（）方法的时候自动调用这俩方法
需要在__isset(）和unset（）中设置调用isset（）和unset（）方法，从而实际完成该魔法方法的逻辑
?php
class Person{
function __construct(){
}
private $name;
private $age;
private $address;
//使用魔术方法
function __set($propName,$propValue){
$this->$propName=$propValue;//这里是需要带美元符号的
}
//使用魔术方法
function __get($propName){
return $this->$propName;//这里是需要带美元符号的
}
//使用魔术方法
function __isset($propName){
return isset($propName);//这里是需要带美元符号的
}
//使用魔术方法
function __unset($propName){
unset($this->$propName);//这里是需要带美元符号的
}
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
function __destruct(){
echo "good bye {$this->name}";
}
}
$xiaomin=new Person();
$xiaomin->name="lisi";
$xiaomin->age=25;
$xiaomin->address="shandong";
echo isset($xiaomin->name);
unset($xiaomin->name);
echo "<br>";
echo isset($xiaomin->name);
echo "<br>";
?>
打印
1
1
Notice: Undefined property: Person::$name in E:\mysite\fengray\ex02\index.php on line 24
good bye
8、extents继承
class 父类名 extents 子类名
其余同java
<?php
class Person{
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
}
class Student extends Person{
var $grade;
var $major;
function __construct($name,$age,$address,$grade,$major){
$this->name=$name;
$this->age=$age;
$this->address=$address;
$this->grade=$grade;
$this->major=$major;
}
function study(){
echo "{$this->name} is study with {$this->major}";
}
}
$xiaomin=new Person("lisi",34,"hainan");
$xiaomin->gotoArmy();
echo "<br>";
$xiaozhang=new Student("zhaoliu",43,"wuhan","senior","news");
$xiaozhang->name="wanger";
echo $xiaozhang->name;
echo "<br>";
echo $xiaozhang->major;
echo "<br>";
echo $xiaozhang->study();
?>
9、访问控制修饰符
private
proteced
public
同java
10、子类重载父类方法
同java对父类的重载
<?php
class Person{
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
}
class Student extends Person{
var $grade;
var $major;
function __construct($name,$age,$address,$grade,$major){
$this->name=$name;
$this->age=$age;
$this->address=$address;
$this->grade=$grade;
$this->major=$major;
}
function study(){
echo "{$this->name} is study with {$this->major}";
}
function gotoArmy(){
echo "graduted from {$this->major}, {$this->name} deside to be a solider";
}
}
$xiaomin=new Person("lisi",34,"hainan");
$xiaomin->gotoArmy();
echo "<br>";
$xiaozhang=new Student("zhaoliu",43,"wuhan","senior","news");
$xiaozhang->name="wanger";
echo $xiaozhang->name;
echo "<br>";
echo $xiaozhang->major;
echo "<br>";
echo $xiaozhang->study();
echo "<br>";
echo $xiaozhang->gotoArmy();
?>
11、parent::子类调用父类方法
重写父类方法中，为了减少与父类方法中相同的冗余代码的产生，因此，可以通过parent：：父类方法在子类方法中调用父类方法
<?php
class Person{
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
var $name;
var $age;
var $address;
function callname(){
echo "my name is {$this->name}";
}
function gotoArmy(){
echo "when he was {$this->age} years old,{$this->name} deside goto army from {$this->address}";
}
}
class Student extends Person{
var $grade;
var $major;
function __construct($name,$age,$address,$grade,$major){
$this->name=$name;
$this->age=$age;
$this->address=$address;
$this->grade=$grade;
$this->major=$major;
}
function study(){
echo "{$this->name} is study with {$this->major}";
}
function gotoArmy(){
parent::gotoArmy();
echo "<br>";
parent::callname();
echo "<br>";
echo "graduted from {$this->major}, {$this->name} deside to be a solider";
}
}
$xiaomin=new Person("lisi",34,"hainan");
$xiaomin->gotoArmy();
echo "<br>";
$xiaozhang=new Student("zhaoliu",43,"wuhan","senior","news");
$xiaozhang->name="wanger";
echo $xiaozhang->name;
echo "<br>";
echo $xiaozhang->major;
echo "<br>";
echo $xiaozhang->study();
echo "<br>";
echo $xiaozhang->gotoArmy();
?>
12、常见的关键字和魔术方法
关键字有final，static，const
魔术方法有：__call()、__toString（）、__autoLoad()
1、final关键字
- fianl标识的类不能被继承
- 在类中使用final标识的成员方法，在子类中不能被覆盖
2、static关键字
- 静态关键字可以将类中的成员标识成静态的，包括静态属性和静态方法
- 通过类名来方位，使用双冒号
类名：：静态成员属性名
类名：：静态成员方法名 - 在类声明的成员方法中，也可以使用self来方位其他静态成员。静态成员属于类而非对象实例的，因此不能使用$this来访问。
self：：静态成员属性名
self：：静态成员方法名 - 在类的外部使用静态成员，可以使用实例形式也可以使用类形式，但通常使用类名访问。
<?php
class Person{
function __construct($age,$address){
$this->age=$age;
$this->address=$address;
}
static $name;
var $age;
var $address;
function callname(){
echo "my name is ".self::$name ;
}
static function gotoArmy(){
echo self::$name." deside goto army from fujian ";
}
}
$p1=new Person(34, "beijing");
Person::$name="lisi";
$p1->callname();
echo "<br>";
Person::gotoArmy();
?>
13、单态设计模式（单例模式）
实际上只要设计出一个类只有一个实例，也就是使用静态方法和静态成员
class DB{
private static $obj=null;
//构造函数构造为private，是为了在类内部去构造一个对象
private function __construct(){
echo "连接数据库成功"."<br>";
}
//只有通过这个方法才能返回本类的对象，静态方法，通过类名调用
static function getInstance(){
if (is_null(self::$obj)){
//如果obj成员属性为空，则创建本类的实例给obj
self::$obj=new self();
}
//返回本类的对象
return self::$obj;
}
//执行一条查询语句
function query($sql){
echo $sql;
}
}
//只能使用静态方法getInstance去获取DB类的对象
$db=DB::getInstance();
$db->query("select * from table");
?>
14、const常量关键字
const定义一个常量，常量和静态成员属性很相似，因此也是通过类名及self：：访问。
const定义的常量名不用带美元符，并且通常都是大写
15、instanceof关键字
对象 instanceof 类名
$db=DB::getInstance();
echo $db instanceof DB;
16、clone对象关键字
对象1=clone 对象2
为对象创建了一个副本，对象2的修改不会影响到对1
<?php
class Person{
var $name;
var $age;
var $address;
function sayname(){
echo "my name is {$this->name}";
}
}
$p1=new Person();
$p1->name="zhangsan";
$p1->sayname();
$p2=clone $p1;
echo "<br>";
$p2->sayname();
$p1->name="lisi";
echo "<br>";
$p1->sayname();
echo "<br>";
$p2->sayname();
?>
打印：
my name is zhangsan
my name is zhangsan
my name is lisi
my name is zhangsan
clone克隆是添加__clone()魔法方法，
<?php
class Person{
private $name;
private $age;
private $address;
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
//魔术方法，在克隆时自动调用
function __clone(){
$this->name="我是{$this->name}的副本";
$this->age=12;
}
function sayname(){
echo "my name is {$this->name},and age is {$this->age}";
}
}
$p1=new Person("zhangsan",23,"beijing");
$p1->sayname();
$p2=clone $p1;
echo "<br>";
$p2->sayname();
echo "<br>";
?>
打印：
my name is zhangsan,and age is 23
my name is 我是zhangsan的副本,and age is 12
17、类中的通用方法–__toString()
__toString(）方法一定要有一个字符串作为返回值。
<?php
class Person{
var $name;
function __construct($name){
$this->name=$name;
}
//魔术方法，在克隆时自动调用
function __toString(){
return $this->name;
}
}
$p1=new Person("zhangsan");
echo $p1->name;
echo "<br>";
echo $p1;
?>
18、类中的通用方法–__debugInfo()
和__toString()方法一样，当使用var_dump（）输出对象时，加入的__debugInfo()方法可以用来控制要输出的属性和值，因此该方法一定要有数组返回值
<?php
class Person{
private $prop;
function __construct($prop){
$this->prop=$prop;
}
function __debugInfo(){
return ['propSquared'=>$this->prop**2];//返回一个数组，只有一个元素
}
}
var_dump(new Person(100));
?>
打印：
object(Person)#1 (1) { [“propSquared”]=> int(10000) }
19、类中的通用方法–__call()
当调用的方法不存在时，则默认调用__call()方法
两个参数，
第一个参数是调用的不存在的函数名，
第二个参数是一个数组，即不存在函数的的不确定数目的参数
<?php
class Person{
function exitsffun(){
echo "this funcation is exits";
}
function __call($functionname,$args){
echo "你调用的函数".$functionname."及参数";
echo print_r($args)."不存在";
}
}
$p1=new Person();
$p1->notexits();
echo "<br>";
$p1->notexits2("zhangsan",23,"address");
echo "<br>";
$p1->exitsffun()
?>
20、serialize（）对象串行化（序列化）和unserialize（）反串行化
serialize（）实际就是讲对象写到文件里进行持久化
一个参数，被序列化的对象
unserialize（）将序列化后的结果反序列化为对象
类文件Person.class.php
class Person{
var $name;
var $age;
var $address;
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
function sayname(){
echo "my name is{$this->name},i am {$this->age} years old, i live in {$this->address}";
}
}
?>
本文件
<?php
require 'Person.class.php';
$p1=new Person("zhangsan",34,"dalian");
//将p1序列化为一个序列化字符串
$mySerilise=serialize($p1);
file_put_contents("file.txt", $mySerilise)
?>
反序列化
<?php
require 'Person.class.php';
$serlizeStr=file_get_contents("file.txt");
$per=unserialize($serlizeStr);
$per->sayname();
?>
打印：
my name iszhangsan,i am 34 years old, i live in dalian
__sleep(),__wakeup()屏蔽特定成员属性
__sleep()需要返回一个数组，数组元素为需要序列化的内容，
__wakeup()在反序列化时自动执行，可以为没有序列化或者已经序列化的成员属性重新赋值。
<?php
class Person{
var $name;
var $age;
var $address;
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
function sayname(){
echo "my name is{$this->name},i am {$this->age} years old, i live in {$this->address}";
}
function __sleep(){
//需要序列化的成员属性作为一个数组返回,要用引号引出函数名
$arry=array("name","address");//序列化name和address，age被忽略
return $arry;
}
function __wakeup(){
$this->age=33;
}
}
$p1=new Person("zhangsan",23,"beijing");
$serlizeStr=serialize($p1);
echo $serlizeStr;
echo "<br>";
$per=unserialize($serlizeStr);
$per->sayname();
?>
21、abstract抽象类
一个类只要有一个抽象方法就是方法类，因此抽象类也需要使用abstract修饰
抽象类作为子类重载的模板来使用
abstract class Person{
var $name;
var $age;
var $address;
function __construct($name,$age,$address){
$this->name=$name;
$this->age=$age;
$this->address=$address;
}
function sayname(){
echo "my name is{$this->name},i am {$this->age} years old, i live in {$this->address}";
}
abstract function work();
abstract function study();
}
class Chinese extends Person{
function work(){
echo "chinese work hard";
}
function study(){
echo "chinese study with chinese";
}
}
class Jpanese extends Person{
function work(){
echo "jpanese work carefuly";
}
function study(){
echo "jpanese study with jpanese";
}
}
$c1=new Chinese("zhangsan", 23, "beijing");
$j1=new Jpanese("fuyuanai", 33, "dongjing");
$c1->study();
echo "<br>";
$c1->work();
echo "<br>";
$c1->sayname();
echo "<br>--------------<br>";
$j1->study();
echo "<br>";
$j1->work();
echo "<br>";
$j1->sayname();
echo "<br>";
?>
22、interface接口
- 同java，php也只支持单继承，因此需要采用接口技术来变相实现多继承
- 接口中使用const关键字声明为常量的成员属性
- 所有成员属性都必须具备public的访问权限。
- 由于接口全部是抽象的，所以不用使用abtract关键字
- 使用interface声明
- 接口和抽象类都不可以实例化
- 可以使用extends继承父接口
- 需要使用接口中的成员，就需要通过子类实现（implements）接口中的全部抽象方法
- 如果是使用抽象类去实现接口也需要使用implements
interface 接口名称{
//常量成员
//抽象方法
}
案例
<?php
interface one{
const MYCON="const value";
function fun1();
function fun2();
}
interface two extends one{
function fun3();
function fun4();
}
abstract class MyAbstract implements one{
//子类实现接口部分方法
function fun1(){
echo "i am son class, i implement the father interface";
}
}
class FromAbstrace extends MyAbstract{
function fun1(){
echo "fun1---- i am son class, i extends from Abstract";
}
function fun2(){
echo "fun2---- i am son class, i extends from Abstract";
}
}
class MyReal implements two{
//子类实现接口全部方法
function fun1(){
echo "i implement the first emthod";
}
function fun2(){
echo "i implement the second emthod";
}
function fun3(){
echo "i implement the third emthod";
}
function fun4(){
echo "i implement the fourth emthod";
}
}
$fa=new FromAbstrace();
$fa->fun1();
echo "<br>";
$fa->fun2();
echo "<br>";
$mr=new MyReal();
$mr->fun1();
echo "<br>";
$mr->fun2();
echo "<br>";
$mr->fun3();
echo "<br>";
$mr->fun4();
echo "<br>";
?>
打印：
fun1---- i am son class, i extends from Abstract
fun2---- i am son class, i extends from Abstract
i implement the first emthod
i implement the second emthod
i implement the third emthod
i implement the fourth emthod
- implements后面通过逗号实现多接口的实现
class 类名 implements 接口1，接口2，...{
}
23、多态性的应用
interface Usb{
function run();
}
class UsbKey implements Usb{
function run(){
echo "usb key is in used";
}
}
class UsbMouse implements Usb{
function run(){
echo "usbMouse is in used";
}
}
class UsbKeyboard implements Usb{
function run(){
echo "usbKeyboard is in used";
}
}
class Computer{
function useUsb($usbmachine){
$usbmachine->run();
}
}
$computer1=new Computer();
$computer1->useUsb(new UsbKey());
echo "<br>";
$computer1->useUsb(new UsbMouse());
echo "<br>";
$computer1->useUsb(new UsbKeyboard());
echo "<br>";
?>
dayin：
usb key is in used
usbMouse is in used
usbKeyboard is in used
24、通过trait混入类
- 用来替代class，具备class所具备的所有特性
- trait不能被实例化
- 在类中通过use tarit名来混入到类中
<?php
trait TraitDemo{
function fun1(){echo "fun1 from trait";}
function fun2(){echo "fun2 from trait";}
}
class Real{
use TraitDemo;
}
$obj=new Real();
$obj->fun1();
echo "<br>";
$obj->fun2();
echo "<br>";
?>
打印：
fun1 from trait
fun2 from trait
- 多个trait冲突是，使用insteadof关键字进行屏蔽和替换
<?php
trait TraitDemo1{
function fun(){echo "1st fun from trait";}
}
trait TraitDemo2{
function fun(){echo "2se fun from trait";}
}
class Real{
use TraitDemo1,TraitDemo2{
TraitDemo2::fun insteadof TraitDemo1;//使用TraitDemo2的fun方法替代TraitDemo1的方法
}
}
$obj=new Real();
$obj->fun();
?>
打印：
2se fun from trait
- 可以进行trait的多层嵌套，使用多次use一层层嵌套
略，不想写
trait的重点问题
- trait会覆盖调用类继承的父方法
- 从基类继承的成员被trait插入的成员锁覆盖。有限顺序为：当前类成员覆盖trait方法，而trait则覆盖了父成员方法
- trait不能像类一样使用new实例对象
- 单个trait课有多个triat完成（嵌套）
- 在单个类中可以use引入多个trait，使用逗号隔开
- trait支持各类修饰符private，protect等
- 可以使用insteadof 及as操作符解决trait之间的冲突
- 使用as语法还可以用来调整方法的访问控制
25、new class匿名类
- 使用new和类名称来实例化对象
- 和普通类一样可以使用继承extends，实现implements及使用trait
- 为了访问外部类protected属性方法，匿名类可以继承此外部类。为了使用外部类的private属性，该属性必须通过构造器传进来
- 其他同java
<?php
$person=new class{
function say(){
echo "我是一个匿名类";
}
}
?>
<?php
class Outer{
private $prop=1;
protected $prop2=2;
//声明一个受保护的成员方法fun3
protected function func1(){
return 3;
}
//声明一个外部类的成员方法，在方法中返回内部匿名类对象
public function func2(){
//声明和返回匿名类对象
//通过构造方法将外部的私有成员传入，从而访问外部类的私有属性
//通过继承外部类，访问外部类的私有属性
return new class($this->prop) extends Outer{
private $prop3;//内部类的私有成员
// 构造方法，传入外部私有属性给内部类的私有成员属性
public function __construct($prop){
$this->prop3=$prop;
}
//内部类的成员方法，访问不同类中的成员进行运算，返回结果
public function fun3(){
return $this->prop2+$this->prop3+$this->func1();
}
};
}
}
echo (new Outer())->func2()->fun3();
?>
打印：
6
26、namesapce命名空间
- namespace是类class的上级容器，为了解决类容易重名的问题，本质上是一个字符串前缀
格式：
<?php
namespace 空间名
？>
- 命名空间如同文件夹，有分支（命名空间子空间）
<?php
namespace broshop\cart;
class Test{}
namespace broshop\order;
class Test{}
$test=new Test();
$cartTest=new broshop\cart\Test();
?>
- 公共空间中的代码段不属于任何命名空间
27、命名空间中的名称和属于
- 非限定名称
如：$u=new User() 如同文件名
- 限定名称
如：$u=new ydma\User() 如同相对路径
- 完全限定名称
如：$u=new \ydma\User() 如同绝对路径
28、命名空间中的别名和导入（导入命名空间）
- 调用命名空间的快捷方式
- 通过use来实现导入命名空间
- 通过as来取别名
- 导入其他名字空间的常量使用use const
- 导入其他名字空间的函数使用use function
<?php
namespace broshop\cart;
class Test{}
namespace broshop\nce;
use broshop\cart\Test as Myname;
class Test{}
$test=new Myname();
namespace broshop\order;
use broshop\nce\Test;//导入命名空间
//导入命名空间
class Test{}
$test=new Test();
$cartTest=new \broshop\nce\Test();
?>
29、面向对象版图形计算器
略
扫一扫
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
