can you explain PHP Covariance with inherited class – Declarations incompatibles

In PHP, starting from version 8.0, you can use return type covariance for overridden methods. This means that you can return a more specific type in a subclass method compared to its parent method. To achieve this with an abstract class and methods, follow these steps:
1. Create an Abstract Class with Abstract Method:
Define an abstract class with an abstract method that has a return type defined as an abstract class or interface.

abstract class AbstractBase {
abstract public function getValue(): AbstractType;
}
interface AbstractType {
// ... abstract type definition ...
}

2. Implement Subclasses:
Create a concrete class that implements the abstract type from the interface and inherits from the abstract class. In this subclass, you can override the method and use a more specific return type.

class ConcreteType implements AbstractType {
// ... implementation ...
}
class SubClass extends AbstractBase {
public function getValue(): ConcreteType {
// ... return an instance of ConcreteType ...
}}

In this example, `SubClass` is extending the `AbstractBase` abstract class and providing an implementation for the `getValue` method with a more specific return type, which is `ConcreteType`.
This approach uses the return type covariance feature introduced in PHP 8.0. It allows you to override a method with a more specific return type as long as the return type in the subclass is a valid subtype of the return type in the parent class.
Keep in mind that your PHP environment must be running version 8.0 or newer to use this feature. Also, be sure to carefully design your class hierarchy and type relationships to ensure that your code remains consistent and well-structured.