博主信息
Lon
Lon
博文
29
粉丝
0
评论
0
访问量
3264
积分：0
P豆：64
最新更新
PHP 目录与文件操作常用函数2021-10-26
PHP Cookie与Session2021-10-26
PHP 常用魔术方法2021-10-26
PHP 面向对象2021-10-26
PHP 几个超级全局变量2021-10-25
PHP PDO2021-10-25
PHP JSON与cURL 函数2021-10-23
Axios.js 基本用法2021-10-11
博文分类
HTML5篇
CSS7篇
JavaScript7篇
PHP7篇
MySQL0篇
Node.js0篇
Vue.js0篇
ES63篇
Webpack0篇
热门文章
Axios.js 基本用法236
HTML 超链接简介228
CSS 盒子模型理解218
HTML 表单内容的详细介绍204
CSS Flex 布局语法教程200
CSS Grid 网格布局教程186
Mock.js 基本用法182
Emmet 语法 速查表158

PHP 面向对象

2021年10月26日 09:51:57阅读数：38博客 / Lon/ PHP

PHP 面向对象

了解更多请访问https://www.runoob.com/php/php-oop.html

面向对象内容

  • 类 − 定义了一件事物的抽象特点。类的定义包含了数据的形式以及对数据的操作。
  • 对象 − 是类的实例。
  • 成员变量 − 定义在类内部的变量。该变量的值对外是不可见的，但是可以通过成员函数访问，在类被实例化为对象后，该变量即可成为对象的属性。
  • 成员函数 − 定义在类的内部，可用于访问对象的数据。
  • 继承 − 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
  • 父类 − 一个类被其他类继承，可将该类称为父类，或基类，或超类。
  • 子类 − 一个类继承其他类称为子类，也可称为派生类。
  • 多态 − 多态性是指相同的函数或方法可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
  • 重载 − 简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
  • 抽象性 − 抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
  • 封装 − 封装是指将现实世界中存在的某个客体的属性与行为绑定在一起，并放置在一个逻辑单元内。
  • 构造函数 − 主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。
  • 析构函数 − 析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做”清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

1、PHP 类定义

  1. <?php
  2. class Teacher{
  3.     /* 成员变量 */
  4.     var $name;
  5.     var $age='18岁';
  6.      /* 成员方法 */
  7.     function info(){
  8.         ...
  9.     }
  10. }
  • 类使用 class 关键字后加上类名定义。
  • 类名后的一对大括号({})内可以定义变量和方法。
  • 类的变量使用 var 来声明, 变量也可以初始化值。
  • 函数定义类似 PHP 函数的定义，但函数只能通过该类及其实例化的对象访问。

2、PHP 中创建对象

类创建后，我们可以使用 new 运算符来实例化该类的对象：

  1. $obj1 = new Teacher;
  2. $obj2 = new Teacher;
  3. $obj3 = new Teacher;

以上代码我们创建了三个对象，三个对象各自都是独立的。

3、PHP 构造函数

构造函数是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。

  1. <?php
  2. class Teacher{
  3.     //成员属性（变量）
  4.     public $name;
  5.     //2、给与默认值
  6.     public $age='18岁';
  7.     //构造函数
  8.     function __construct($name, $age) {
  9.         //变量 $this 代表自身的对象。
  10.         $this->name = $name;
  11.         $this->age = $age;
  12.     }
  13.     //成员方法
  14.     public function info(){
  15.         echo '我叫：'.$this->name.'今年：'.$this->age.'<br>';
  16.     }
  17.     //析构函数
  18.     public function __destruct(){
  19.         echo "销毁 " . $this->name . "<br>";
  20.     }
  21. }
  22. //实例化对象
  23. $obj1 = new Teacher('张三','18');
  24. $obj2 = new Teacher('李四','20');
  25. $obj3 = new Teacher('王五','22');
  26. //输出成员属性
  27. echo $obj1->name.'<br>';
  28. echo $obj2->name.'<br>';
  29. echo $obj3->name.'<br>';
  30. // 调用成员函数
  31. $obj1->info();
  32. $obj2->info();
  33. $obj3->info();

4、析构函数

析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。

5、继承

PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承，格式如下：

  1. class Child extends Parent {
  2.    // 代码部分
  3. }

6、方法重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

  1. <?php
  2. // 父类
  3. class Teacher{
  4.     //成员属性（变量）
  5.     public $name;
  6.     //2、给与默认值
  7.     public $age='18岁';
  8.     // 构造方法，也是可以让子类继承的
  9.     public function __construct($n,$age)
  10.     {
  11.         //$this 代表 本类，因为它自己调用自己的属性和方法
  12.         $this->name = $n;
  13.         $this->age = $age;
  14.     }
  15.     //成员方法
  16.     public function info(){
  17.         echo '我叫：'.$this->name.' 今年：'.$this->age.'<br>';
  18.     }
  19. }
  20. //子类继承父类
  21. class Child extends Teacher{
  22.     //拓展
  23.     public $gerder='男';
  24.     //方法重新
  25.     public function info(){
  26.         echo '姓名：'.$this->name.' 年龄：'.$this->age.' 性别：'.$this->gerder.'<br>';
  27.     }
  28. }
  30. $obj1 = new Child('张三',18);
  31. $obj2 = new Child('李四',20);
  32. $obj3 = new Child('王五',22);
  34. $obj1->info();
  35. $obj2->info();
  36. $obj3->info();

7、访问控制

PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。

  • public（公有）：公有的类成员可以在任何地方被访问。
  • protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
  • private（私有）：私有的类成员则只能被其定义所在的类访问。
  1. <?php
  2. // 父类
  3. class Teacher{
  4.     //成员属性（变量）
  5.     public $name;
  6.     //2、给与默认值
  7.     public $age='18岁';
  8.     // 受保护的，可以继承,被子类访问
  9.     protected  $salary = 3000;
  10.     // private 私有的，只能它自己的类里访问，外面和它儿子，都不能访问
  11.     private  $former = 1;
  12.     // 构造方法，也是可以让子类继承的
  13.     public function __construct($n,$age,$g,$s,$f)
  14.     {
  15.         //$this 代表 本类，因为它自己调用自己的属性和方法
  16.         $this->name = $n;
  17.         $this->age = $age;
  18.         $this->gender = $g;
  19.         $this->salary = $s;
  20.         $this->former = $f;
  21.     }
  22.     //成员方法
  23.     public function info(){
  24.         return "我的名字叫：{$this->name},我的年龄：{$this->age},我的性别：{$this->gender},我的工资：{$this->salary},我谈过：{$this->former}个对象<br>";
  25.     }
  26. }
  27. //子类继承父类
  28. class Child extends Teacher{
  29.     //拓展
  30.     public $gerder='男';
  31.     //方法重新
  32.     public function info(){
  33.         //$this->former; //私有属性，在子类是访问不了的
  34.         echo '姓名：'.$this->name.' 年龄：'.$this->age.' 性别：'.$this->gerder.' 工资：'.$this->salary.'<br>';
  35.     }
  36. }
  37. $obj1 = new Teacher('王富贵',28,'男','7000','5');
  38. echo $obj1->info();
  40. $obj2 = new Child('张三',18,'男','3000','1');
  41. $obj2->info();

8、static 关键字

声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。

静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。

由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。

静态属性不可以由对象通过 -> 操作符来访问。

  1. <?php
  2. // static 关键词：可以给属性(变量)，也可以给方法
  3. class Shop
  4. {
  5.     //静态属性(变量)
  6.     public static $title;
  7.     public $price;
  8.     public $num1 = 1;
  9.     public  static  $num2 = 1;
  11.     // 给与默认值，会报错 $title = '苹果13pro'
  12.     // 使用静态成员的时候，没有经过构造方法
  13.     public function __construct($title , $price)
  14.     {
  15.         $this->title = $title;
  16.         $this->price = $price;
  17.         $this->num1 ++;//普通变量，都是重头开始计算
  19.         //静态成员，只要是调用了，它就会增加1
  20.         // 静态成员由本类调用，为所有的实例共享。
  21.         // 存在内存中，你没有new，也能使用。。如果你使用了以后，改变了它的值，它还会保存改变后的数据放在内存中
  22.         self::$num2 ++;
  23.     }
  24.     //静态方法
  25.     public static function viode(){
  26.         // 如果用在本类里，用自己的类名::访问属性和方法。
  27.         // $this 代表本类
  28.         // 静态成员，用 self:: 代表本类
  29.         return '这里是看视频的方法，使用的是：'.self::$title;
  30.     }
  31. }
  33. //$obj = new Shop('苹果13Pro',13000);
  34. // 如果这个属性和方法是静态的，不要用原始的访问方式，虽然可以访问，但是比较浪费资源
  35. //echo $obj->title;
  36. //echo '<hr>';
  38. // 静态成员访问方式，是用类名::属性名，类名::方法名()
  39. //可以不实例化类而直接访问。
  40. echo Shop::$title = '苹果14pro';
  41. echo '<hr>';
  42. echo Shop::viode();

9.final 关键字

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

  1. class Teacher{
  2.     //子类无法覆盖该方法
  3.     final function info{
  4.         ....
  5.     }
  6. }
  8. // 最终类，不能继承
  9. final class Teacher{
  10.     ...
  11. }

10、调用父类构造方法

PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。

  1. <?php
  2. // 父类
  3. class Teacher{
  4.     //成员属性（变量）
  5.     public $name;
  6.     //2、给与默认值
  7.     public $age='18岁';
  8.     // 构造方法，也是可以让子类继承的
  9.     public function __construct($n,$age)
  10.     {
  11.         //$this 代表 本类，因为它自己调用自己的属性和方法
  12.         $this->name = $n;
  13.         $this->age = $age;
  14.     }
  15.     //成员方法
  16.     public function info(){
  17.         return "我的名字叫：{$this->name},我的年龄：{$this->age}<br>";
  18.     }
  19. }
  20. //子类继承父类
  21. class Child extends Teacher{
  22.     // 子类构造方法不能自动调用父类的构造方法
  23.     function __construct($n,$age){
  24.         parent::__construct($n,$age);
  25.         print "Child类中构造方法" . PHP_EOL.'<br>';
  26.     }
  27.     // 子类有info，还想用父类的info
  28.     public function info(){
  29.         // 怎么用它父亲的inof呢？用 parent
  30.         return parent::info() . ',这是从Child类出来的话';
  31.     }
  32. }
  33. $obj = new Child('张三',18);
  34. echo $obj->info();

11、抽象类

任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。

定义为抽象的类不能被实例化。

被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。

  1. <?php
  2. // 多态的一种，静态也是多态的一种
  3. // 抽象类 用于描述一些事物所具有的特性和行为，但是没有具体实现
  4. // 抽象 有类，也有方法，关键词：abstract，它是class之前
  5. abstract class Person{
  6.     abstract public function say();
  7.     abstract public function eat();
  8. }
  10. // 如果继承了抽象类，不能把所有的方法都重写，那只能自己也是抽象类
  11. abstract class Chinese extends Person{
  12.     protected $name;
  13.     // 构造方法 ，可以在抽象类中使用
  14.     public function __construct($name){
  15.         $this->name = $name;
  16.     }
  18.     public function say(){
  19.         return '我是'.$this->name.'我是中国人，我说汉语';
  20.     }
  21. }
  23. class Anhui extends Chinese{
  24.     public function eat(){
  25.         return '我是'.$this->name.'我是中国人，我用筷子吃饭';
  26.     }
  27. }
  29. $obj = new Anhui('张三');
  30. echo $obj->say();
  31. echo '<hr>';
  32. echo $obj->eat();

抽象类：设计类与实现类 是分离的。可以为子类提供一些 公用的方法 作为子类重写的模板来使用

12、类常量

可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号。

常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。

  1. <?php
  2. // 有一些数据，是不能允许别人更改的。就会用到常量
  3. class App{
  4.     // const 关键词，常量就会当成静态的成员
  5.     const APP_NAME = 'php商城';
  7.     public function get_name(){
  8.         // $this->APP_NAME; // 不能用$this的方式访问
  9.         return self::APP_NAME;
  10.     }
  11. }
  12. //$obj = new App();
  13. //为什么不能访问常量呢
  14. //echo $obj->APP_ANEM;
  16. //要用静态方式访问 类名::
  17. echo App::APP_NAME;
  18. echo "<hr>";
  19. $obj = new App();
  20. echo $obj->get_name();

13、接口

使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

  1. <?php
  2. // 接口也是多态的一种，不管是普通类还是抽象类，都是单继承，就是一个子类只能继承一个父类
  3. // 我们如果需要 一个类，继承多个类，就无法实现。。 后来php发展出来 接口这个功能，它可以实现多个父亲
  4. // 使用 interface 关键词来创建接口，替换掉class
  5. interface Guojia{
  6.     public static function no_tifa($param);
  7. }
  8. interface File{
  9.     const APP_NAME = '中小学生教育部';
  10.     public function no_buke($one,$two);
  11.     public function no_zuoye(...$param);
  12. }
  13. // 接口不能继承，如果继承的话，就跟 单继承一样了，一个子类，只能有一个父类
  14. // implements 关键词，来使用接口，实现接口。 多个接口，使用,逗号隔开就行了
  15. class Teacher implements File,Guojia{
  16.     public function no_buke($one, $two){
  17.         return $one .'<hr>'. $two;
  18.     }
  19.     public function no_zuoye(...$param){
  20.         return print_r($param);
  21.     }
  22.     // 使用接口的时候，如果接口里有静态成员，重写的时候，也要按照静态的方式
  23.     public static function no_tifa($param){
  24.         return $param;
  25.     }
  26. }
  27. // 这样是实例化，有静态的成员，不要实例化
  28. //$obj = new Teacher();
  29. //echo $obj->no_tifa('我没有对学生体罚');
  31. echo Teacher::no_tifa('我没有对学生体罚');

14、后期静态绑定

自 PHP 5.3.0 起，PHP 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类。
关键词：static

  1. <?php
  2. //静态成员访问 
  3. //class A{
  4. //    public static function test(){
  5. //        return '这是A类的test方法';
  6. //    }
  7. //    public function show(){
  8. //        // 静态成员 不允许用 $this
  9. //        //return $this->test();
  10. //        // 用self:: 访问静态方法
  11. //        return self::test();
  12. //    }
  13. //}
  14. //
  15. //class B extends A{
  16. //    public static function test(){
  17. //        return '这是B类的test方法';
  18. //    }
  19. //}
  21. //$a = new A();
  22. //echo $a->show();    // 这是A类的test方法
  23. //echo '<hr>';
  24. //$b = new B();
  25. // 为什么实例化B，请求show方法，返回的是 A里的方法呢？
  26. //echo $b->show(); // 这是A类的test方法
  27. // 我们要的结果要像$this这样，new哪个类，就先去找哪个类里的方法
  29. class A{
  30.     public static function test(){
  31.         return '这是A类的test方法';
  32.     }
  33.     public function show(){
  34.         // 静态成员 不允许用 $this
  35.         // return $this->test();
  36.         // 用self:: 访问静态方法
  37.         // return self::test();
  38.         // 用static关键词替代 self关键词
  39.         return static::test();
  40.     }
  41. }
  42. class B extends A{
  43.     public static function test(){
  44.         return '这是B类的test方法';
  45.     }
  46. }
  48. $a = new A();
  49. echo $a->show();    // 这是A类的test方法
  50. echo '<hr>';
  51. $b = new B();
  52. echo $b->show();    // 这是B类的test方法
  53. // 静态集成的时候，上下文环境，静态调用类中的方法，没有正确识别 调用者

15、自动加载类

spl_autoload_register() 是一个实现自动加载类的函数，自动加载类就是我们在new一个class的时候，不需要手动去写require来导入这个class.php文件，程序自动帮我们加载导入进来

  1. <?php
  2. //类的自动加载：注册类的装载规则，自动化调用类的时候，会自动找对应类的文件名
  3. spl_autoload_register(function($className){
  4.     // $className 是new的Student这个类名，不是文件名
  5.     // 构建所有不同规则类文件路径
  6.     $arr = array(
  7.         "./public/$className.php",
  8.         "./libs/$className.php",
  9.         );
  10.     // 循环数组
  11.     foreach ($arr as $filename) {
  12.         //检测文件是否存在
  13.         if(file_exists($filename)){
  14.             //引入文件
  15.             require_once($filename);
  16.         } 
  17.     }
  18. });
  19. // 创建学生类对象
  20. $obj1 = new Student();
  21. // 创建教师类对象
  22. $obj2 = new Teacher();
  23. ?>

版权申明：本博文版权归博主所有，转载请注明地址！如有侵权、违法，请联系admin@php.cn举报处理！

全部评论

文明上网理性发言，请遵守新闻评论服务协议

0 条评论
  • php面向对象什么意思

    2021-06-30

    760

    在php中，面向对象就是将要处理的问题抽象为对象，然后通过对象的属性和行为来解决对象的实际问题。
    javascript是面向对象吗

    2021-10-19

    javascript并不是严格意义的面向对象语言，而是一种基于对象、事件驱动编程的客户端脚本语言。
    c++是面向对象还是面向过程？

    2020-07-10

    1053

    c++是面向对象。面向对象是相对于面向过程来讲的，面向对象方法，就是把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。
    Golang 是面向对象还是面向过程？

    2020-06-10

    1268

    Golang可以说两者都不算，因为Golang并没有明显的倾向，而是更倾向于让编程者去考虑该怎么去用它，也许它的特色就是灵活，编程者可以用它实现面向对象，但它本身并不支持面向对象的语义。
    javascript是不是面向对象语言

    2021-09-02

    javascript不是面向对象语言，而是一种基于对象的脚本语言。JavaScript不仅可以创建对象，也能使用现有的对象。
    php中面向对象的三面人生

    2021-03-04

    在面向对象思想中，有三大特性：封装、继承和多态。
    go语言是面向对象的吗

    2021-03-15

    go语言既不是面向对象，也不是面向过程，因为Golang并没有明显的倾向，而是更倾向于让编程者去考虑该怎么去用它，也许它的特色就是灵活，编程者可以用它实现面向对象，但它本身不支持面向对象的语义。
    PHP面向对象的魔术方法有哪些？

    2020-07-28

    790

    PHP面向对象的魔术方法有：__construct()、__destruct()、__call()、__callStatic()、__get()、__set()、__isset()、__unset()、
    golang是面向对象吗？

    2020-07-18

    1192

    golang不是面向对象的，go是面向过程的语言，也不是函数式编程范式，其表现在缺少箭头函数，需要显式声明lambda，而且不讲究纯函数和immutable。
    python是面向对象还是面向过程?

    2020-09-27

    1145

    python是面向对象的，第一个公开发行版发行于1991年，Python语法简洁而清晰，具有丰富和强大的类库。
    java什么是面向对象

    2020-10-12

    java面向对象是指在计算机程序中，模拟现实世界中的概念，借助对象的描述在计算机程序中用类似的实体模拟现实世界中的实体。
    讲解Python核心基础之面向对象

    2020-12-14

    519

    Python栏目讲解核心基础的面向对象，Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。
    谈一谈php面向对象的理解

    2020-06-15

    812

    面向对象编程（OOP)是我们编程的一项基本技能，PHP5对OOP提供了良好的支持。如何使用OOP的思想来进行PHP的高级编程，对于提高PHP编程能力和规划好Web开发构架都是非常有意义的。
    VB是一种面向对象的编程语言，对么

    2020-07-16

    1047

    VB是一种面向对象的编程语言，对。VB是一种通用的基于对象的程序设计语言，为结构化的、模块化的、面向对象的、包含协助开发环境的事件驱动为机制的可视化程序设计语言。
    面向对象程序设计的基本机制是什么

    2020-07-28

    1160

    面向对象程序设计的基本机制是“继承”，面向对象程序设计的英文全称是“Object Oriented Programming”，是一种计算机编程架构，面向对象的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成
    在面向对象方法中，不属于对象基本特点的是什么

    2020-07-13

    1678

    在面向对象方法中，不属于对象基本特点的是：一致性。对象基本特点有：1、对象唯一性；2、分类性；3、继承性；4、多态性。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。
    javaScript面向对象的三个基本特征介绍

    2020-10-21

    1081

    了解过面向对象的同学应该都知道，面向对象三个基本特征是：封装、继承、多态，但是对于这三个词具体可能不太了解。对于前端来讲接触最多的可能就是封装与继承，对于多态来说可能就不是那么了解了。
    PHP中什么是类和对象？为什么学习面向对象？如何使用？

    2021-06-17

    763

    上篇文章给大家介绍了《PHP中什么是pdo？访问数据库有什么优点？扩展的作用是什么？​》，本文继续给大家介绍PHP中什么是类和对象？为什么学习面向对象？如何使用？
    VB是一种面向对象的程序设计语言，构成对象的三要素是什么

    2020-07-09

    1898

    VB是一种面向对象的程序设计语言，构成对象的三要素是：属性、事件和方法。VB的控件是具有自己的属性、事件和方法的对象，可以把属性看做一个对象的性质，把事件看做对象的响应，把方法看做对象的动作。
    php和java面向对象的区别是什么

    2021-09-17

    766

    区别：1、php的class关键字不能有除abstract、final之外的修饰符；而Java可以有。2、php的new关键字后面的类名可以是字符串类型的变量，java不可以。
    提交
    首页视频教程原生手册编程词典工具下载免责声明赞助与捐赠

    Copyright 2014-2021 //m.sbmmt.com/ All Rights Reserved PHP中文网 版权所有

    php中文网：公益在线php培训，帮助PHP学习者快速成长！

    苏ICP备2020058653号-1

    关注公众号QQ交流群