Do PHP interfaces have properties?

Question

Do interfaces in PHP have properties, or do they only have methods?

Answer 1

You can declare properties in DocBlock for the interface. IDE's will then hint those properties for the interface (PhpStorm does) but this will not force the actual implementation of these fields in the implementing class. E. g.

/**
 * @property string $password
 * @property string $username
 */
interface IUserDocument
{


}

Answer 2

It depends what you mean by "properties". If you mean actual fields, then no, they don't. If you're referring to properties such as those in C#, then yes they can (since the property accessors are strictly syntactic sugar for accessor methods anyway). The same goes for events (though of course, in each case, no implementation is specified for the get/set or add/remove accessors).

Update: Since PHP does not have properties in the sense of get/set accessors, then the answer to your question is no. Interfaces cannot carry their own data/state.

Answer 3

Interfaces in PHP may only contain public method signatures without a method body. They may also contain constants. But that's it. Nothing else.

See http://www.php.net/manual/en/language.oop5.interfaces.php

Interfaces are defined using the interface keyword, in the same way as a standard class, but without any of the methods having their contents defined. […] All methods declared in an interface must be public, this is the nature of an interface. […] Its possible for interfaces to have constants. Interface constants works exactly like class constants except they cannot be overridden by a class/interface that inherits it.

Answer 4

PHP interfaces can have constants, but not properties (instance variables). If you don't need to modify your "property", you can use a constant instead.

Answer 5

I'm late but this may help someone in the future... Interfaces should not have properties, since that corresponds to the implementation (ie, to the class). The properties must be used for the representation of the internal state of the class. The interface is more of a type and defines what that type can or cannot do (methods).

The object must be sufficiently versatile and decoupled to give responses to its types.

Reference book: Design Patterns - Erich Gamma

The way to use interfaces (syntax for >8)

<?php

interface Transport {
    public function ticketCode();
}

interface Vehicle {
    public function start();
    public function stop();
    public function getStatus();
}

class Cab implements Transport, Vehicle {
    private string $ticket;
    private string $status;
    
    function __construct(){
        $this->ticket = time();
        $this->status = "off";
    }

    public function start(){
        $this->status = 'on';
    }
    
    public function stop(){
        $this->status = 'off';
    }
    
    public function getStatus(){
        echo "The status is: {$this->status}";
    }
    
    public function ticketCode() {
        echo "The ticket code is: {$this->ticket}";
    }
}

class Motorcycle implements Vehicle {
    private string $status;
    
    function __construct(){
        $this->status = "off";
    }

    public function start(){
        $this->status = 'on';
    }
    
    public function stop(){
        $this->status = 'off';
    }
    
    public function getStatus(){
        echo "The status is: {$this->status}";
    }
}

$cab = new Cab();
echo " > cab is a Transport? " . ($cab instanceof Transport ? 'yes':'no') . " || cab is a Vehicle? " .  ($cab instanceof Vehicle ? 'yes':'no'); 

$motorcycle = new Motorcycle();
echo " > motorcycle is a Transport? " . ($motorcycle instanceof Transport ? 'yes':'no') . " || motorcycle is a Vehicle? " . ($motorcycle instanceof Vehicle?'yes':'no'); 

In the previous example we can see how the interfaces define the types that my class will take (a class can have more than one type), the class is in charge of defining how those types are implemented and interact. So, this explains why an interface doesn't allow having properties (No, it's not a language error), it's really the class that should manage and define the states (properties). Who must manipulate them and change their values is the object or class instance. The interface simply says that it must implement the class to be considered a certain type, an interface must not do things.

function startVehicle(Vehicle $vehicle){
    $vehicle->start();
}

$motorcycle->getStatus();
$cab->getStatus();
startVehicle($motorcycle);
startVehicle($cab);
$motorcycle->getStatus();
$cab->getStatus();

Using interfaces will allow you things like polymorphism or working with objects (class instances or whatever you want to call it) by type regardless of the class they come from, as long as it implements the "X" type it will be a valid object to do things with its interface (in example above, the type would be Vehicle).

The interface is really an interface, I have called it type so that it can be easier to understand the approach it has.

RESUME

If you want an interface with properties then you have badly designed your solution and need to rethink it. Maybe I should be thinking about class inheritance.

The explanation may seem controversial considering that a class can equally be treated as a type, or what I mention as a type, but the concept is somewhat more complex to understand and I invite you to read the aforementioned book that can explain the difference better. that I.

Answer 6

The [valid] reason for needing properties in an interface is to specify that a DTO class has a certain aspect, e.g. IOrderable { OrderDate, OrderStatus }, IDeliverable { DeliveryAddress, Route, ... }, etc. The aspect can be used in a number of DTOs e.g. Sales Order, Work Order, Sales Invoices, etc. A DTO class can support multiple aspects, i.e. multiple inheritance which is desirable in Data Classes (but not Code Classes). Thereafter, the client of the DTO is assured it can view the DTO through that aspect (an interface contract). This pattern abides by all 5 of the SOLID principles.

In PHP the closest you have to interface properties is traits http://php.net/manual/en/language.oop5.traits.php. Similar to interfaces, traits cannot be instantiated, however can be used directly in classes without implementing them.