Use a method of a class in another PHP OOP

Do all vehicles (Cars, Trucks, Motorcycles, Bikes, Space Ships... LOL) have to be painted, or put another way, have to have a property color? If the answer is yes, as seems obvious, then the method pintar()should be in the parent class which is Vehiculo.

Let's see an example where we also include a type of handling regarding the issue of the ruedas, discussed in comments. I clarify that it is only an example of how you could determine if you are trying to create a Coche. You will need to implement setRuedas()all the necessary logic to determine the type of vehicle, preventing one from Motohaving 50 wheels, one from Camion having 1 wheel and so on. I say this just to illustrate that it was the wrong way to create classes of type CuatroRuedas, DosRuedas, or NRuedas. The wheel issue is a property and should be handled/resolved in a method, not by creating classes.

The example also shows how properties are passed from the child to the parent and how from the child we can call methods like toString()to get the piece of information corresponding to the parent (you could also define the properties like protectedand use them from the child).

It's a very basic example where setter and getter would be missing . In fact, a more suitable method name might be maybe setColor()(which is the same as paint ), but respecting the usual naming convention .

These are the classes:

Vehiculo

class Vehiculo
{
     private $color;
     private $peso;
     private $ruedas;

     public function __construct($color, $peso, $ruedas=null)
     {
        $this->color=$color;
        $this->peso=$peso;
        $this->setRuedas($ruedas);
     }
 
     public function setRuedas($ruedas) 
     {
         #Aquí controlas la cantidad de ruedas y la clase llamadora
         #Si la clase hija no es Coche y no tiene 4 ruedas no se asigna la propiedad
         #Es sólo un ejemplo a ampliar
           
         if ($ruedas==4 && get_called_class()=="Coche")
         {
               $this->ruedas=$ruedas;
         }
     }  
       
     public function pintar($color)
     {
        $this->color = $color;
     }
       
     public function toString()
     {
          return "Color: {$this->color}  \tPeso: {$this->peso}  \tRuedas: {$this->ruedas}";
     }          
       
}

Coche

 class Coche extends Vehiculo
 {
    private $puertas;
    
    public function __construct($color, $peso, $ruedas=null, $puertas)
    {
        #Pasamos al padre las propiedades comunes
        parent::__construct($color, $peso, $ruedas);
        
        #Asignamos las propiedades particulares de Coche
        $this->puertas=$puertas;
        
    }    

    public function toString()
    {
          return parent::toString() . " \tPuertas: {$this->puertas}";
    }                  
    
  }

Let's look at several examples:

#Creamos un Vehículo
$mVehiculo= new Vehiculo("Verde", 1500);
echo $mVehiculo->toString().PHP_EOL;

#Lo pintamos
$mVehiculo->pintar("Negro");
echo $mVehiculo->toString().PHP_EOL;

#Creamos un Coche
$mCoche= new Coche("Rojo", 850, 4, 5);
echo $mCoche->toString().PHP_EOL;

#Lo pintamos. Aquí pintar() es un método de Vehiculo
$mCoche->pintar("Blanco");
echo $mCoche->toString().PHP_EOL;

Departure:

Color: Verde    Peso: 1500      Ruedas: 
Color: Negro    Peso: 1500      Ruedas: 
Color: Rojo     Peso: 850       Ruedas: 4   Puertas: 5
Color: Blanco   Peso: 850       Ruedas: 4   Puertas: 5

With that basic example you can try to build a class Motofor example, or a class NaveEspacial, and you can paint both objects from the class Vehiculo.

By the way, I have used the usual naming convention for classes which is PascalCase.

There are several concepts that are not right in the code. Static methods cannot access instance methods or attributes. Accessing attributes and instance methods requires an object initialized in that class. I will illustrate it with an example:

<?php

class One {
    public $var1 = "Verde";
    public static $var2 = "Rojo";
}

class Two {
    static $var3 = "Azul";
    public $var4 = "Negro";
    public static function color1() {
        echo One::$var1;
    }
    public static function color2(){
        echo One::$var2;
    }
    public static function color3() {
        echo self::$var3;
    }
    public static function color4() {
        echo self::$var4;
    }
    public function color5() {
        echo $this->var4;
    }
}

Now doing some tests:

Two::color1(); // Error: Access to undeclared static property One::$var1
Two::color2(); // Rojo
Two::color3(); // Azul
Two::color4(); // Error: Access to undeclared static property Two::$var4
Two::color5(); // Error: Non-static method Two::color5() cannot be called statically

// Creando un objeto
$obj = new Two();
$obj->color5(); // Negro

So a static method cannot change the color of your Vehicle. For this it has to be an instance method.
On the other hand, class attributes vehiculocannot be private if they are to be inherited by another class, they must be public or protected . See visibility concept . If you declare them private , the child class will not have access to them and the method repintar()will create a new attribute $this->colorfor the class object cochethat has nothing to do with the class object vehiculo.

So a modified version of your code that remains functional would be:

<?php
class vehiculo {
    protected $color;
    protected $peso;
    
    public function __construct($color, $peso) {
        $this->color = $color;
        $this->peso = $peso;
    }
}

class coche extends vehiculo {
    function __construct(...$args) { // Constructor de clase hija
        parent::__construct(...$args); // inicializacion constructor padre
    }
    
    public function repintar($color) {
        $this->color = $color;
    }

    public function get_color() {
        return $this->color;
    }
}

$vehiculo1 = new coche("Verde", 1500);
echo "El coche ahora es " . $vehiculo1->get_color();
// El coche ahora es Verde
$vehiculo1->repintar("Negro");
echo "El coche ahora es " . $vehiculo1->get_color();
// El coche ahora es Negro

[*] The method is needed get_color()to be able to return the attribute $this->colorsince it is declared as protected and cannot be accessed from outside the class. If it had been declared as public , the method is not needed and the attribute can be called directly:

$vehiculo1->color;