首页 >后端开发 >php教程 >PHP、类和对象

PHP、类和对象

Barbara Streisand原创: 2024-12-29 14:42:11881浏览

PHP, Classes and Objects

PHP 中的类和对象

PHP 与 Java 一样，支持面向对象编程，并使用类和对象作为其核心构建块。理解这些概念对于掌握 PHP 至关重要。本指南将涵盖您需要了解的有关 PHP 中的类和对象的所有内容。

定义一个类

PHP 中的类是创建对象的蓝图。它定义了类的对象将具有的结构和行为。

句法

class ClassName {
    // Properties (Fields)
    // Methods
}

例子

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

创建对象

对象是类的实例。您可以使用 new 关键字从类创建对象。

句法

$objectName = new ClassName();

例子

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

属性和方法

属性（也称为字段）表示对象的状态，而方法定义对象的行为。

特性

属性是保存对象数据的变量。

例子

class Car {
    public $color;
    public $model;
    public $year;
}

方法

方法是在类中定义的函数，用于描述对象的行为。

例子

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

构造函数

构造函数是实例化对象时自动调用的特殊方法。他们初始化新创建的对象。

默认构造函数

如果没有定义构造函数，PHP 会提供一个不带参数的默认构造函数。

例子

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

参数化构造函数

参数化构造函数允许您使用特定值初始化对象。

例子

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

使用参数化构造函数

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

构造函数重载

PHP 本身并不像 Java 那样支持方法重载，但您可以使用可选参数或通过在单个构造函数中手动处理参数来模拟它。

例子

class Car {
    public $color;
    public $model;
    public $year;

    // Simulating constructor overloading
    public function __construct($color = "Unknown", $model = "Unknown", $year = 0) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

使用模拟重载构造函数

class Main {
    public function run() {
        $defaultCar = new Car();
        $defaultCar->displayInfo();

        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

PHP 中的封装、访问修饰符和静态成员

封装

PHP 中的封装是将数据（属性）和方法（函数）捆绑在一个类中的做法。它确保对象的内部状态不受外界干扰和误用。

访问修饰符

PHP 中的访问修饰符控制属性、方法和构造函数的可见性和可访问性。 PHP 支持三种主要的访问修饰符：

公共：可从任何地方访问。
受保护：可在类、子类和同一包内访问。
私有：只能在定义类中访问。

用法示例：

class ClassName {
    // Properties (Fields)
    // Methods
}

静态成员

PHP 中的静态成员与类本身相关联，而不是与任何特定实例相关联。无需创建类的对象即可访问它们。

静态属性：

静态属性在类的所有实例之间共享。它们是使用 static 关键字声明的。

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

静态方法：

静态方法是使用 static 关键字声明的。它们属于类而不是实例。

$objectName = new ClassName();

访问静态成员：

静态成员是使用类名访问的，而不是通过对象。

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

PHP 中的访问修饰符

PHP 中的访问修饰符控制类成员的可见性，确保封装并强制执行访问限制。

访问修饰符的类型

公共
受保护
私人

1. 公开

可从以下位置访问：任何地方。
用法： 对需要广泛访问的成员使用 public。

class Car {
    public $color;
    public $model;
    public $year;
}

2. 受保护

可从以下位置访问： 在类及其子类内。
用法： 对只能在类层次结构中访问的成员使用 protected。

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3. 私人的

可从以下位置访问： 仅在班级内。
用法： 对于不应在定义类外部访问的成员使用 private。

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

PHP 中的非访问修饰符

PHP 中的非访问修饰符修改类成员的行为而不影响其可见性。

非访问修饰符的类型

静态
决赛
摘要

1.静态

用法： 声明属于类而不是实例的属性和方法。
示例：

class ClassName {
    // Properties (Fields)
    // Methods
}

2.决赛

用法：防止进一步修改方法或继承类。
变量： PHP 不支持最终变量。
方法： 最终方法不能被覆盖。
课程：期末课程不能延长。
示例：

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

3.摘要

用法： 声明不完整且必须在子类中实现的类和方法。
抽象类：无法实例化。
抽象方法： 声明时没有主体，必须由子类实现。
示例：

$objectName = new ClassName();

PHP 中的继承和访问修饰符

遗产

PHP 中的继承是一种机制，其中一个类（子类）可以继承另一个类（超类）的属性和方法。它促进代码重用并允许在类之间创建层次关系。

继承语法

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

例子

class Car {
    public $color;
    public $model;
    public $year;
}

在此示例中：

Animal 是具有属性 $name 和 eat() 方法的超类。
Dog 是继承 Animal 的 $name 和 eat() 的子类，并添加了自己的方法 bark()。

继承中的访问修饰符

PHP 中的访问修饰符决定子类和程序其他部分中类成员的可见性。它们在继承中发挥着关键作用。

普通属性和方法的访问修饰符

公共：可从任何地方访问。
受保护：可在类、子类和同一包内访问。
private: 只能在声明它的类中访问。

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

静态属性和方法的访问修饰符

PHP 中的静态成员与类相关联，而不是与任何特定实例相关联。它们遵循与继承中的非静态成员相同的访问规则。

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

静态方法是继承的吗？

静态方法在 PHP 中是继承的，但不能像实例方法一样被重写。当子类定义同名静态方法时，会隐藏父类的静态方法。

class ClassName {
    // Properties (Fields)
    // Methods
}

抽象方法的访问修饰符

PHP 中的抽象方法必须定义在抽象类中。抽象方法在超类中的可见性决定了它在子类中的可见性。子类必须实现具有相同或较少限制的访问修饰符的抽象方法。

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

最终属性和方法的访问修饰符

PHP 中的 Final 方法不能被子类覆盖，并且 Final 类不能扩展。

最终方法：防止方法覆盖。
最终类：防止继承。

$objectName = new ClassName();

在 PHP 中声明顶级类的语法

在 PHP 中，顶级类（未嵌套在其他类中的类）的声明遵循特定的关键字顺序。声明可以包含访问修饰符、abstract 或final 关键字以及class 关键字。

可以使用的关键词：

访问修饰符： public
类类型：抽象或最终

命令：

class ClassName {
    // Properties (Fields)
    // Methods
}

句法：

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

重要提示：

如果未指定，PHP 假定 public 作为默认访问修饰符。
一个类不能同时是抽象类和最终类。
顶级类不允许使用 protected 和 private 访问修饰符。

例子：

$objectName = new ClassName();

在 PHP 中声明类属性的语法

可以使用的关键词：

访问修饰符： public、protected、private
静态修饰符：静态
不可变修饰符： readonly（在 PHP 8.1 中引入）

命令：

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

句法：

class Car {
    public $color;
    public $model;
    public $year;
}

重要提示：

如果未指定访问修饰符，属性默认为 public。
静态属性属于类而不是实例。
只读属性只能在声明期间或构造函数中初始化一次（PHP 8.1）。

例子：

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

在 PHP 类中声明方法的语法

可以使用的关键词：

访问修饰符： public、protected、private
静态修饰符：静态
最终修饰符：最终
抽象修饰符： 摘要

命令：

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

句法：

class Car {
    public $color;
    public $model;
    public $year;

    // Parameterized constructor
    public function __construct($color, $model, $year) {
        $this->color = $color;
        $this->model = $model;
        $this->year = $year;
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

重要提示：

如果没有指定访问修饰符，该方法默认是public。
静态方法属于类，而不是实例。
Final 方法不能在子类中被重写。
抽象方法必须在抽象类中声明，并且不能有方法体。

例子：

class Main {
    public function run() {
        $myCar = new Car("Red", "Tesla", 2022);
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

PHP 中的抽象类

PHP 中的抽象类与 Java 中的抽象类类似，用于定义其他类的蓝图。它们包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。抽象类使用abstract关键字声明，不能直接实例化。

1. 抽象类简介

抽象类充当派生类的基类。它为其子类定义了常见行为，同时允许在这些子类中实现特定方法。

2. 声明抽象类

要在 PHP 中声明抽象类，请在 class 关键字之前使用abstract 关键字。

例子：

class ClassName {
    // Properties (Fields)
    // Methods
}

3. 抽象方法

抽象方法在抽象类中定义，但没有方法体。子类必须实现所有抽象方法。

例子：

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

4. 具体方法

抽象类中的具体方法具有主体，可以由子类按原样继承或重写。

例子：

$objectName = new ClassName();

5. 创建子类

抽象类的子类必须实现其所有抽象方法，除非子类也声明为抽象。

例子：

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

6. 实例化抽象类

抽象类不能直接实例化。您必须使用具体的子类来创建实例。

例子：

class Car {
    public $color;
    public $model;
    public $year;
}

7. 抽象类中的构造函数

抽象类可以有构造函数，它们的构造函数在子类实例化时被调用。

例子：

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

8. 具有字段和方法的抽象类

抽象类可以包含实例变量和具体方法，为子类提供可重用的功能。

例子：

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

9. 抽象类中的静态方法

抽象类可以包含静态方法。静态方法属于类，无需实例化即可调用。

例子：

class ClassName {
    // Properties (Fields)
    // Methods
}

在 PHP 中声明抽象类的语法

可以使用的关键词：

摘要
公共、受保护、私有（访问修饰符）

命令：

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

示例：

具有抽象方法和具体方法的抽象类

$objectName = new ClassName();

具有字段和最终方法的抽象类

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

重要提示：

抽象类不能直接实例化。
抽象方法必须由非抽象子类实现。
未实现所有抽象方法的子类也必须声明为抽象。
抽象类中的具体方法是可选的，可供子类重写。
抽象类可以有构造函数、属性和常量。
抽象类可以对其方法和属性使用任何可见性修饰符。

PHP 中的接口

PHP 中的接口为实现它的类定义了一个契约。它指定类必须实现的方法，但本身不提供任何方法实现。接口允许更灵活和模块化的代码，使类能够遵守一组通用的方法签名，无论其继承层次结构如何。

1. 接口介绍

PHP中的接口类似于抽象类，但它只能定义方法签名而没有任何实现。实现接口的类必须提供接口中声明的所有方法的实现。一个类可以实现多个接口，这使得接口成为 PHP 支持行为多重继承的关键部分。

2. 声明接口

要声明接口，请使用interface关键字。接口只能包含方法声明（没有方法体）、常量和抽象方法。

例子：

class Car {
    public $color;
    public $model;
    public $year;
}

3. 实现接口

实现接口的类必须提供接口中声明的所有方法的实现。一个类可以实现多个接口，接口之间用逗号分隔。

例子：

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

4. 接口方法签名

接口中的方法不能有主体，并且它们必须是公共的。当类实现接口时，它必须完全按照接口中声明的方式实现这些方法，包括方法签名。

例子：

class Car {
    public $color;
    public $model;
    public $year;

    // Default constructor
    public function __construct() {
    }

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

5. 多接口实现

PHP中的一个类可以实现多个接口。这使得设计系统时更加灵活，其中类可以遵守不同的契约。

例子：

class ClassName {
    // Properties (Fields)
    // Methods
}

6. 接口常量

接口可以包含常量。这些常量自动是公共的，并且可以被任何实现该接口的类访问。

例子：

class Car {
    // Properties
    public $color;
    public $model;
    public $year;

    // Methods
    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

7. 接口继承

一个接口可以扩展另一个接口。这意味着子接口继承了父接口的所有方法（签名），并且还可以添加新的方法。实现子接口的类必须实现父接口和子接口的所有方法。

例子：

$objectName = new ClassName();

8. 接口中的静态方法

接口不能包含静态方法。接口中声明的所有方法都必须是实例方法。接口中不允许使用静态方法，因为接口为实现类定义了实例级契约。

在 PHP 中声明和实现接口的语法

可以使用的关键词：

界面
公开

命令：

class Main {
    public function run() {
        $myCar = new Car(); // Creating an object of the Car class
        $myCar->color = "Red";
        $myCar->model = "Tesla";
        $myCar->year = 2022;
        $myCar->displayInfo();
    }
}

$main = new Main();
$main->run();

示例：

与方法签名的接口

class Car {
    public $color;
    public $model;
    public $year;
}

与多种实现的接口

class Car {
    public $color;
    public $model;
    public $year;

    public function displayInfo() {
        echo "Model: " . $this->model . "\n";
        echo "Color: " . $this->color . "\n";
        echo "Year: " . $this->year . "\n";
    }
}

重要提示：

接口方法：接口中的方法必须是公共的，并且不能有主体。
实现多个接口：一个类可以实现多个接口，用逗号分隔。
访问修饰符：接口中的所有方法都是隐式公共的。不允许使用 private 或 protected 等访问修饰符。
接口常量：接口可以声明自动公开的常量，并且可以通过实现类来访问。
接口继承：一个接口可以扩展一个或多个接口，结合它们的方法签名。
静态方法：接口不能包含静态方法。
实现所有方法：类必须实现其实现的接口定义的所有方法。

以上是PHP、类和对象的详细内容。更多信息请关注PHP中文网其他相关文章！

Java php less Static Object define if for while include using class public private protected internal Interface Property default constructor this everything Access Other

声明：

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

上一篇：. Find Largest Value in Each Tree Row下一篇：How to Convert a String Date to PHP Date and DateTime Objects?

查看更多