How to make an exception to "private" constructors?

Question

I want to declare a non-public constructor so it's users of the class can't call new Message() directly but have to instantiate the object from a static builder method declared on an abstract class that Message extends.

So far my code is:

abstract class SqlDecodable  {
    public function instanceFromRawSql (array $rawSql) {
        $newInstanceToReturn = new static() // problem is here 
        // .. map the new instance .. 
        return $newInstance ;
    } 

}

// for exemple... 
class Message extends SqlDecodable {
    private $receiverId ; 
    private $senderId ; 
    private $text ;

    private/protected/public?? function __construct() {
        // problem here : this constructor should be usable only by 
           parent class, not for user of Message
    }
    static function propertiesToSqlFields() {
        return [
        "receiverId" => "receiver_id_field_in_db", 
        "senderId" => "sender_id",
        "text" => "text" 
        ]
    }
}

This is actually more complicated, but I simplified the system for this question

When I implement my method instanceFromRawSqlArray, I have to create a new instance of the child class: $instanceToReturn = new static(), and set the variables one by one afterwards.

Though, I don't want to let a __construct that takes no args in my model classes. I don't want the dev user of Message to be able to new Message().

This constructor should be usable only by instanceFromRawSqlArray. The problem is that, as I saw, there is no C++ friends class in PHP. I can't make my __construct protected, because, as I saw, protected methods are accessibles for childs, not for parent.

Do you have ideas to map this new instance in the method instanceFromRawSqlArray, without creating any constructor or setter that would corrupt my model class "encapsulation protections"?

Answer 1

You were very close. You can simply declare your constructor to be protected.

Instantiating the class directly won't work, but you can call new from the static method declared in the abstract class.

E.g.:

abstract class SuperAbstract {

    static function create() {
        return new static();
    }
}

class Extended extends SuperAbstract {

    private $hello = '';

    protected function __construct() {
        $this->hello = "world";
    }

    public function hello() {
        return "hello " . $this->hello;
    }
}

// works
$a = Extended::create();

echo $a->hello(); // outputs "hello world"

// can't touch this. This will fail because the constructor is `protected`.
$b = new Extended();

Of course, since it's protected the constructor could also be called from children classes. That's unavoidable, as long as children classes are a possibility. But you could also declare Extended as final, making extension of the class impossible. Thus, it would only be possible to create new instances from the factory method defined in the abstract parent.

final Extended extends SuperAbstract

    protected function __construct() { }
}

You can see it working (and failing), here: https://3v4l.org/LliKj