PHP类方法怎么定义_PHP类方法编写规范与实际应用

<?php

class MyClass {
    public function myPublicMethod() {
        // 可以在类的外部访问
        echo "This is a public method.\n";
    }

    private function myPrivateMethod() {
        // 只能在类的内部访问
        echo "This is a private method.\n";
    }

    protected function myProtectedMethod() {
        // 可以在类的内部和子类中访问
        echo "This is a protected method.\n";
    }

    public function callPrivateMethod() {
        // 在类的内部调用private方法
        $this->myPrivateMethod();
    }

    public function callProtectedMethod() {
         // 在类的内部调用protected方法
        $this->myProtectedMethod();
    }
}

$obj = new MyClass();
$obj->myPublicMethod(); // 输出: This is a public method.
$obj->callPrivateMethod(); // 输出: This is a private method.
$obj->callProtectedMethod(); // 输出: This is a protected method.

// 下面的调用会导致错误，因为private和protected方法不能在类的外部直接访问
// $obj->myPrivateMethod(); // 错误：Call to private method MyClass::myPrivateMethod() from context ''
// $obj->myProtectedMethod(); // 错误：Call to protected method MyClass::myProtectedMethod() from context ''

?>

<?php

/**
 * Class User
 *
 * This class represents a user.
 */
class User {
    /**
     * @var string The user's name.
     */
    private $name;

    /**
     * @var string The user's email.
     */
    private $email;

    /**
     * User constructor.
     *
     * @param string $name  The user's name.
     * @param string $email The user's email.
     */
    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
    }

    /**
     * Get the user's name.
     *
     * @return string The user's name.
     */
    public function getName(): string {
        return $this->name;
    }

    /**
     * Set the user's name.
     *
     * @param string $name The user's name.
     */
    public function setName(string $name): void {
        $this->name = $name;
    }

    /**
     * Get the user's email.
     *
     * @return string The user's email.
     */
    public function getEmail(): string {
        return $this->email;
    }

    /**
     * Set the user's email.
     *
     * @param string $email The user's email.
     */
    public function setEmail(string $email): void {
        $this->email = $email;
    }

    /**
     * Send a welcome email to the user.
     *
     * @throws Exception If the email could not be sent.
     */
    public function sendWelcomeEmail(): void {
        $message = "Welcome, " . $this->name . "!";
        // 这里应该添加发送邮件的逻辑，为了简化，这里只是抛出一个异常
        throw new Exception("Failed to send email to " . $this->email);
    }
}

try {
    $user = new User("John Doe", "john.doe@example.com");
    $user->sendWelcomeEmail();
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

?>

<?php

class MyClass {
    public $name = "Default Name";

    public function setName($newName) {
        $this->name = $newName; // 使用$this访问对象的属性
    }

    public function getName() {
        return $this->name;
    }

    public function greet() {
        echo "Hello, " . $this->getName() . "!\n"; // 使用$this调用对象的方法
    }
}

$obj = new MyClass();
echo $obj->getName() . "\n"; // 输出: Default Name
$obj->setName("New Name");
echo $obj->getName() . "\n"; // 输出: New Name
$obj->greet(); // 输出: Hello, New Name!

?>

<?php

class MyClass {
    public static $count = 0; // 静态属性

    public static function incrementCount() { // 静态方法
        self::$count++; // 使用self访问静态属性
    }

    public function getCount() { // 普通方法
        return self::$count; // 普通方法可以访问静态属性
    }
}

MyClass::incrementCount(); // 使用类名调用静态方法
echo MyClass::$count . "\n"; // 输出: 1

$obj = new MyClass();
echo $obj->getCount() . "\n"; // 输出: 1
$obj->incrementCount(); // 不推荐：虽然可以这样调用，但不符合语义
echo $obj->getCount() . "\n"; // 输出: 2

?>

<?php

class ParentClass {
    public function myMethod($arg1 = null, $arg2 = null) {
        if ($arg1 === null && $arg2 === null) {
            echo "Method called with no arguments.\n";
        } elseif ($arg2 === null) {
            echo "Method called with one argument: " . $arg1 . "\n";
        } else {
            echo "Method called with two arguments: " . $arg1 . ", " . $arg2 . "\n";
        }
    }

    public function overriddenMethod() {
        echo "ParentClass::overriddenMethod()\n";
    }
}

class ChildClass extends ParentClass {
    public function overriddenMethod() {
        echo "ChildClass::overriddenMethod()\n"; // 重写父类的方法
    }
}

$parent = new ParentClass();
$parent->myMethod(); // 输出: Method called with no arguments.
$parent->myMethod("Hello"); // 输出: Method called with one argument: Hello
$parent->myMethod("Hello", "World"); // 输出: Method called with two arguments: Hello, World
$parent->overriddenMethod(); // 输出: ParentClass::overriddenMethod()

$child = new ChildClass();
$child->overriddenMethod(); // 输出: ChildClass::overriddenMethod()

?>

<?php

// 抽象类
abstract class AbstractClass {
    abstract public function abstractMethod(); // 抽象方法

    public function concreteMethod() {
        echo "AbstractClass::concreteMethod()\n";
    }
}

class ConcreteClass extends AbstractClass {
    public function abstractMethod() { // 必须实现抽象方法
        echo "ConcreteClass::abstractMethod()\n";
    }
}

// 接口
interface MyInterface {
    public function interfaceMethod();
}

class MyClass implements MyInterface {
    public function interfaceMethod() { // 必须实现接口方法
        echo "MyClass::interfaceMethod()\n";
    }
}

$obj = new ConcreteClass();
$obj->abstractMethod(); // 输出: ConcreteClass::abstractMethod()
$obj->concreteMethod(); // 输出: AbstractClass::concreteMethod()

$obj2 = new MyClass();
$obj2->interfaceMethod(); // 输出: MyClass::interfaceMethod()

?>