Call a different constructor depending on the static type of the instance created

I have a program where a class car implements two interfaces : rentable and buyable.

My class looks something like this:

Class Car implements IRentable, IBuyable{
   private String name;
   private float rentValue;
   private float sellValue;

   //rentable constructor
   public Car(String name, float rentValue){
   ...
   }
   //buyable constructor
   public Car(String name, float buyValue){
   ...
   }
   ...
}

And the instantiation of the object would look something like this:

IRentable c1= new Car("name",700f);
IBuyable c2= New Car ("name",35_000f);

I was wondering if there is a way to call a specific constructor based on the static type of the object. For example, if I have the IRentable type:

IRentable c1= new Car("name",700f);

call the rentable constructor.
If I have the IBuyable type:

IBuyable c2= New Car ("name",35_000f);

call the buyable constructor.

This is not possible as different constructors need different method signatures.
You could have one constructur with a flag as third parameter:

IRentable c1= new Car("name",700f,true);
IBuyable c2= New Car ("name",35_000f,false);

I think for this case you should consider builder pattern or if you only need those two constructors then you could make the all args constructor private and create two static methods that would create you objects accordingly.

Use static methods, which can be named to clarify the difference. Make the constructor private.

class Car implements IRentable, IBuyable {
    private String name;
    private float rentValue;
    private float buyValue;

    public static IRentable rent(String name, float rentValue) {
        return new Car(name, rentValue, Float.NaN);
    }

    public static IBuyable buy(String name, float buyValue) {
        return new Car(name, Float.NaN, buyValue);
    }

    private Car(String name, float rentValue, float buyValue) {
        ...
    }

    ...
}

They are used like this:

IRentable c1 = Car.rent("name", 700f);
IBuyable c2 = Car.buy("name", 35_000f);

You can't create more than 1 constructor with the same type signature(s). If a car is only suppose to be either Rentable or Buyable, you could create a single interface that both of the aforementioned interfaces extend like Costable (bad name i know).

interface Costable {
    float amount();
}

Then compose the Car of a Costable object.

class Car implements Costable {
    
    private final Costable;

    public Car(Costable costable) {
        this.costable = costable;
    }

    @Override
    public float amount() {
        return costable.amount();
    }
}

Then you could extend Rentable/Buyable with your implementations. Here is an example with IRentable like you have above.

class IRentable implements Costable {
    
    private final float amount;

    public IRentable(float amount) {
        this.amount = amount;
    }

    @Override
    public float amount() {
        return amount;
    }
}

Costable rentable = new Car(new IRentable(1_000));