PHP: Static Readonly property in class

Directly answering your question: No, you cannot mark regular properties as readonly. If you want to set primitive types (except array), that will never change, you should use constants

const QWE = '666';

That doesn't work for objects and arrays. I see two (lets say) "solutions"

1. Use Getter

   private $qwe;
   public function getQwe() { return $this->qwe; }
   protected function setQwe($value) { $this->qwe = $value; }
   

   I don't like them very much ("Properties define the state, not the behavior, like methods do"). You always get twice as much additional methods as properties and if you have many properties, this will extremely blow up your class. However, it's as far as I can see the only way to implement what you want to achieve.

2. Trust your users ;) Comment your property and say something like "If you change this value, probably something will break and its your very own fault".

   /**
    * QWE
    *
    * This property should be treatened as "readonly". If you change this value
    * something scary will happen to you.
    *
    * @readonly
    * @var string
    */
   public $qwe = '666';
   

   Its not great, but at least you can say "I told you".

Readonly properties were introduced in PHP 8.1, but static readonly properties are not supported.

From the RFC:

Readonly static properties are not supported. This is a technical limitation, in that it is not possible to implement readonly static properties non-intrusively. In conjunction with the questionable usefulness of readonly static properties, this is not considered worthwhile at this time.

However you can declare a static function to more or less get the same end result.

public static function getType(): string
{
    return 'Duck';
}

If the value never changes, you can use const instead. Otherwise, there's no way that satisfies your restrictions (short of hooking function calls in PHP through an extension, but even then you'd need to change your static variable accesses to function calls; otherwise, you'd have to patch PHP).

Of course, it's highly doubtful that what your application is doing is good design. Relying on changing static properties is more or less the same as relying on global variables.

This is a bit easier:

class aaa{
private static $qwe='rty';
public static function qwe() { return self::$qwe; }
}

It does not allow changes, and is still easy to access:

aaa::$qwe = 'something'; // fails
echo aaa::qwe(); // success

I know it is not ideal, but you can do a replace all

aaa::$qwe 

with

aaa::qwe()

It would be nice if php offered a getStatic() method but since it doesn't you can repurpose __callStatic() to fetch them like this:

class Foo
{
    private static $readonly_var = 'FOO';
    public static function __callStatic($name, $args) {
        return self::${$name};
    }
}
echo Foo::readonly_var() . PHP_EOL;

Simply call the variable name as a function. It's scalable since you don't need to create any special getter function for it to work.