Come fare in modo che la divisione di 2 ints produca un float anziché un altro int?

In un altro Bruce Eckels si esercita nel calcolo della velocità, v = s / tdove s e t sono numeri interi. Come faccio a farlo in modo che la divisione tiri fuori un galleggiante?

class CalcV {
  float v;
  float calcV(int s, int t) {
    v = s / t;
    return v;
  } //end calcV
}

public class PassObject {

  public static void main (String[] args ) {
    int distance;
    distance = 4;

    int t;
    t = 3;

    float outV;

    CalcV v = new CalcV();
    outV = v.calcV(distance, t);

    System.out.println("velocity : " + outV);
  } //end main
}//end class

Per prima cosa basta lanciare uno dei due operandi su un float.

v = (float)s / t;

Il cast ha una precedenza maggiore rispetto alla divisione, quindi accade prima della divisione.

L'altro operando verrà effettivamente castato automaticamente su un float dal compilatore perché le regole dicono che se uno degli operandi è di tipo a virgola mobile, allora l'operazione sarà un'operazione a virgola mobile, anche se l'altro operando è integrale. Specifica del linguaggio Java, §4.2.4 e §15.17

Provare:

v = (float)s / (float)t;

Lanciare gli ints su float consentirà la divisione in virgola mobile.

Devi davvero solo lanciarne uno, però.

Cast uno degli interi su un float per forzare l'operazione da eseguire con la matematica a virgola mobile. Altrimenti si preferisce sempre la matematica dei numeri interi. Così:

v = (float)s / t;

Per ridurre l'impatto sulla leggibilità del codice, suggerirei:

v = 1d* s/t;

Puoi lanciare il numeratore o il denominatore per galleggiare ...

le operazioni int di solito restituiscono int, quindi è necessario modificare uno dei numeri operativi.

Puoi lanciare anche solo uno di essi, ma per coerenza potresti voler lanciare esplicitamente entrambi, quindi qualcosa come v = (float) s / (float) t dovrebbe funzionare.

Standard JLS

JLS 7 15.17.2. Operatore di divisione / dice:

La divisione di numeri interi viene arrotondata a 0. Cioè, il quoziente prodotto per operandi n e d che sono numeri interi dopo la promozione numerica binaria (§5.6.2) è un valore intero q la cui grandezza è il più grande possibile mentre soddisfacente | d · q | ≤ | n |. Inoltre, q è positivo quando | n | ≥ | d | e n e d hanno lo stesso segno, ma q è negativo quando | n | ≥ | d | ed n hanno segni opposti.

Questo è il motivo per cui 1/2non dà un galleggiante.

La conversione di uno solo in float come in è (float)1/2sufficiente perché 15.17. Gli operatori moltiplicativi dicono:

La promozione numerica binaria viene eseguita sugli operandi

e 5.6.2. La promozione numerica binaria dice:

• Se uno degli operandi è di tipo double, l'altro viene convertito in double.
• Altrimenti, se uno degli operandi è di tipo float, l'altro viene convertito in float

Eseguire il cast di uno degli interi / entrambi dell'intero per fluttuare per forzare l'operazione da eseguire con la matematica in virgola mobile. Altrimenti si preferisce sempre la matematica intera. Così:

1. v = (float)s / t;
2. v = (float)s / (float)t;

Prova questo:

class CalcV 
{
      float v;
      float calcV(int s, int t)
      {
          float value1=s;
          float value2=t;
          v = value1 / value2;
          return v;
      } //end calcV
}