Para este bloque de código:

int num = 5;
int denom = 7;
double d = num / denom;

El valor de des 0.0. Se puede forzar a trabajar al lanzar:

double d = ((double) num) / denom;

Pero, ¿hay otra forma de obtener el doubleresultado correcto ? No me gusta lanzar primitivas, quién sabe qué puede pasar.

double num = 5;

Eso evita un yeso. Pero encontrará que las conversiones de conversión están bien definidas. No tienes que adivinar, solo revisa el JLS . int a double es una conversión cada vez mayor. De §5.1.2 :

Las conversiones primitivas de ampliación no pierden información sobre la magnitud general de un valor numérico.

[...]

La conversión de un valor int o largo a flotante, o de un valor largo a doble, puede dar como resultado una pérdida de precisión, es decir, el resultado puede perder algunos de los bits menos significativos del valor. En este caso, el valor de punto flotante resultante será una versión correctamente redondeada del valor entero, utilizando el modo redondeado al más cercano IEEE 754 (§4.2.4) .

5 se puede expresar exactamente como un doble.

¿Qué hay de malo en lanzar primitivas?

Si no quieres emitir por alguna razón, puedes hacer

double d = num * 1.0 / denom;

No me gusta lanzar primitivas, quién sabe qué puede pasar.

¿Por qué tienes un miedo irracional a lanzar primitivas? Nada malo sucederá cuando lanzas un inta double. Si no está seguro de cómo funciona, búsquelo en la Especificación del lenguaje Java . Lanzar un intto doublees una conversión primitiva cada vez mayor .

Puedes deshacerte del par de paréntesis extra al usar el denominador en lugar del numerador:

double d = num / (double) denom;

Si cambia el tipo de una de las variables, debe recordar colarse en un doble nuevamente si su fórmula cambia, porque si esta variable deja de ser parte del cálculo, el resultado es confuso. Tengo la costumbre de emitir dentro del cálculo y agrego un comentario al lado.

double d = 5 / (double) 20; //cast to double, to do floating point calculations

Tenga en cuenta que emitir el resultado no lo hará

double d = (double)(5 / 20); //produces 0.0

Emite uno de los enteros / ambos enteros para flotar para forzar que la operación se haga con coma flotante matemática. De lo contrario, siempre se prefiere la matemática entera. Entonces:

1. double d = (double)5 / 20;
2. double v = (double)5 / (double) 20;
3. double v = 5 / (double) 20;

Tenga en cuenta que emitir el resultado no lo hará. Porque la primera división se realiza según la regla de precedencia.

double d = (double)(5 / 20); //produces 0.0

No creo que haya ningún problema con el casting como tal en el que está pensando.

La fundición de tipos es la única forma

Producir una doubledivisión de enteros: no hay otra forma sin lanzar (puede que no lo hagas explícitamente, pero sucederá).

Ahora, hay varias formas en que podemos tratar de conseguir precisa doublede valor (donde numy denomson inttipo y de curso con la fundición ) -

1. con casting explícito:

   • double d = (double) num / denom;
   • double d = ((double) num) / denom;
   • double d = num / (double) denom;
   • double d = (double) num / (double) denom;

pero no double d = (double) (num / denom);

2. con casting implícito:

   • double d = num * 1.0 / denom;
   • double d = num / 1d / denom;
   • double d = ( num + 0.0 ) / denom;
   • double d = num; d /= denom;

pero no double d = num / denom * 1.0;
y nodouble d = 0.0 + ( num / denom );

usa algo como:

double step = 1d / 5;

(1d es un elenco para duplicar)

Puede considerar ajustar las operaciones. Por ejemplo:

class Utils
{
    public static double divide(int num, int denom) {
        return ((double) num) / denom;
    }
}

Esto le permite buscar (solo una vez) si el elenco hace exactamente lo que quiere. Este método también podría estar sujeto a pruebas, para garantizar que continúe haciendo lo que desea. Tampoco importa qué truco use para causar la división (podría usar cualquiera de las respuestas aquí), siempre que resulte en el resultado correcto. En cualquier lugar donde necesite dividir dos enteros, ahora puede llamar Utils::dividey confiar en que hace lo correcto.

solo usa esto.

int fxd=1;
double percent= (double)(fxd*40)/100;

La mejor manera de hacer esto es

int i = 3;
Double d = i * 1.0;

d is 3.0 now.