Para este bloco de código:

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

o valor de dé 0.0. Pode ser forçado a trabalhar lançando:

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

Mas existe outra maneira de obter o doubleresultado correto ? Não gosto de lançar primitivos, quem sabe o que pode acontecer.

double num = 5;

Isso evita um elenco. Mas você descobrirá que as conversões de elenco são bem definidas. Você não precisa adivinhar, basta verificar o JLS . int dobrar é uma conversão crescente. A partir do §5.1.2 :

As conversões primitivas ampliadas não perdem informações sobre a magnitude geral de um valor numérico.

[...]

A conversão de um valor int ou longo para flutuar ou de um valor longo para duplicar pode resultar em perda de precisão, ou seja, o resultado pode perder alguns dos bits menos significativos do valor. Nesse caso, o valor de ponto flutuante resultante será uma versão arredondada corretamente do valor inteiro, usando o modo IEEE 754 de arredondar para o mais próximo (§4.2.4) .

5 pode ser expresso exatamente como um duplo.

O que há de errado com a transmissão de primitivas?

Se você não quer transmitir por algum motivo, pode fazer

double d = num * 1.0 / denom;

Não gosto de lançar primitivos, quem sabe o que pode acontecer.

Por que você tem um medo irracional de lançar primitivos? Nada de ruim vai acontecer quando você joga um intpara um double. Se você não tiver certeza de como isso funciona, consulte a Especificação de Linguagem Java . Converter um intpara doubleé uma conversão primitiva cada vez maior .

Você pode se livrar do par extra de parênteses lançando o denominador em vez do numerador:

double d = num / (double) denom;

Se você alterar o tipo de uma das variáveis, lembre-se de esgueirar-se novamente duas vezes se sua fórmula mudar, porque se essa variável deixar de fazer parte do cálculo, o resultado será confuso. Eu tenho o hábito de transmitir dentro do cálculo e adiciono um comentário ao lado.

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

Observe que a transmissão do resultado não fará isso

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

Lance um dos números inteiros / os dois inteiros para flutuar para forçar a operação a ser feita com ponto flutuante Math. Caso contrário, o número inteiro Math é sempre preferido. Assim:

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

Observe que a transmissão do resultado não será suficiente. Porque a primeira divisão é feita conforme a regra de precedência.

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

Eu não acho que exista algum problema com o elenco, como tal, você está pensando.

Fundição tipo é a única maneira

Produzir uma doubledivisão inteira - não há outro caminho sem a conversão (pode ser que você não faça isso explicitamente, mas isso acontecerá).

Agora, existem várias maneiras pelas quais podemos tentar obter um doublevalor preciso (onde nume denomsão do inttipo e, é claro, com a transmissão ) -

1. com transmissão explícita:

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

mas não double d = (double) (num / denom);

2. com elenco implícito:

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

mas não double d = num / denom * 1.0;
e nãodouble d = 0.0 + ( num / denom );

use algo como:

double step = 1d / 5;

(1d é convertido para dobrar)

Você pode considerar agrupar as operações. Por exemplo:

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

Isso permite que você verifique (apenas uma vez) se o elenco faz exatamente o que você deseja. Esse método também pode estar sujeito a testes, para garantir que ele continue fazendo o que você deseja. Também não importa qual truque você usa para causar a divisão (você pode usar qualquer uma das respostas aqui), desde que resulte no resultado correto. Em qualquer lugar que você precisar dividir dois números inteiros, agora você pode simplesmente ligar Utils::dividee confiar que ele faz a coisa certa.

apenas use isso.

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

A melhor maneira de fazer isso é

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

d is 3.0 now.