Instituto Superior Politécnico de Tete

DIVISÃO DE ENGENHARIA

ENGENHARIA INFORMÁTICA

Programação I

2° Ano – Turma B

Curso Diurno

Discente:
- António Milton Mugabe
- Carlos Ricardo Boene
- Elton Filimão Langa
Docente:
- MSc Lourenço Roberto

Tete, 2021
 António Milton Mugabe
Carlos Ricardo Boene
Elton Filimão Langa

Casting (Conversões de tipos)

Trabalho de pesquisa apresentado ao Instituto

Superior Politécnico de Tete, para a cadeira de
Programação I, orientado pelo docente Lourenço
Roberto no âmbito do curso de Engenharia
Informática, 2º ano do período laboral.

Tete, 2021
Índice
Introdução ...................................................................................................................................4

Conversões entre tipos ................................................................................................................5

Casos não tão comuns de casting e atribuição ..........................................................................6

Castings possíveis ...................................................................................................................7

Tipos de conversões de tipos .......................................................................................................7

Implícita ..................................................................................................................................7

Explícita ..................................................................................................................................8

Exemplo ......................................................................................................................................9

Conclusão ................................................................................................................................. 11

Referências Bibliográficas......................................................................................................... 12
 Introdução

A conversão de tipos é o ato de forçar uma expressão a utilizar e retornar um determinado tipo.
Também chamamos esta modalidade de “Casting”. A conversão de um tipo de dado em número
ou em literal é muito comum em situações de programação. Também podemos encontrar casos
que possam gerar erros na conversão de tipos.
No presente trabalho iremos aprofundar mais acerca de Casting (conversões entre tipos), onde
vamos apresentar exemplos, e também podemos ter dois tipos de conversões de tipos, pode ser
implícita ou explicitas, que são conversões especificadas.
A metodologia utilizada para elaboração do presente trabalho foi com base nas pesquisas,
enriquecida com algumas informações obtidas ao longo da realização do mesmo.
 Conversões entre tipos

Java não tem problemas para atribuir um tipo int para um double – ele vai tratar o valor como
double. Assim sempre que uma atribuição for efectuada o tipo mais representativo será utilizado.
Entretanto, existem ocasiões onde queremos representar o valor inteiro de um tipo double. Por
exemplo, assim, torna-se necessário converter o tipo, em uma operação chamada de cast. Essa
conversão nada mais é do que indicar o tipo desejado, como no exemplo:
double x = 9.345;
int z = (int)x;
A variável z terá como valor o número 9. As conversões permitidas sem cast são:
byte > short > int > long > float > double e char >int.
Alguns valores são incompatíveis se você tentar fazer uma atribuição direta. Enquanto um número
real costuma ser representado em uma variável do tipo double , tentar atribui-lo a uma variável int
não funciona, porque é um código que diz: "i deve valer d", mas não se sabe se d realmente é um
número inteiro ou não.

double d = 3.1415;

int i = d; // não compila.

A mesma coisa ocorre no seguinte trecho:

int i = 3.14;

O mais interessante é que nem mesmo o seguinte código compila:

double d = 5; // ok, o double pode conter um número inteiro.

int i = d; // não compila.

Apesar de 5 ser um bom valor para um int , o compilador não tem como saber qual valor estará
dentro desse double no momento da execução. Esse valor pode ter sido digitado pelo usuário, e
ninguém garantirá que essa conversão ocorra sem perda de valores.

Já no caso a seguir é o contrário:

int i = 5;

double d2 = i;
O código acima compila sem problemas, uma vez que um double pode guardar um número com
ou sem ponto flutuante. Todos os inteiros representados por uma variável do tipo int podem ser
guardados em uma variável double, então não existem problemas no código acima.

Às vezes, precisamos que um número quebrado seja arredondado e armazenado em um número

inteiro. Para fazer isso sem que haja o erro de compilação, é preciso ordenar que o número
quebrado seja moldado (casted) como um número inteiro. Esse processo recebe o nome de casting.

double d3 = 3.14;

int i = (int) d3;

O casting foi feito para moldar a variável d3 como um int . O valor de i agora é 3. O mesmo caso
ocorre entre valores int e long.

long x = 10000;

int i = x; // não compila, pois pode estar perdendo informação.

E se quisermos realmente fazer isso, fazemos o casting:

long x = 10000;

int i = (int) x;

Casos não tão comuns de casting e atribuição

Alguns castings aparecem também:

float x = 0.0;

O código acima não compila, pois todos os literais com ponto flutuante são considerados double
pelo Java. E float não pode receber um double sem a perda de informação. Para fazê-lo funcionar,
podemos escrever:

float x = 0.0f;

A letra f, que pode ser maiúscula ou minúscula, indica que aquele literal deve ser tratado como
float.Outro caso que é mais comum:

double d = 5;
float f = 3;

float x = f + (float) d;

Você precisa do casting porque o Java faz as contas e vai armazenando sempre no maior tipo que
apareceu durante as operações, neste caso, o double.

E uma observação: no mínimo, o Java armazena o resultado em um int na hora de fazer as contas.
Até casting com variáveis do tipo char podem ocorrer. O único tipo primitivo que não pode ser
atribuído a nenhum outro tipo é o boolean.

Castings possíveis
Abaixo estão relacionados todos os casts possíveis na linguagem Java, mostrando quando você
quer converter de um valor para outro. A indicação Impl. quer dizer que aquele cast é implícito e
automático, ou seja, você não precisa indicar o cast explicitamente. (lembrando que o tipo boolean
não pode ser convertido para nenhum outro tipo).

Para:
byte short char int long float double
De:
byte ---- Impl. (char) Impl. Impl. Impl. Impl.
short (byte) ---- (char) Impl. Impl. Impl. Impl.
char (byte) (short) ---- Impl. Impl. Impl. Impl.
int (byte) (short) (char) ---- Impl. Impl. Impl.
long (byte) (short) (char) (int) ---- Impl. Impl.
float (byte) (short) (char) (int) (long) ---- Impl.
double (byte) (short) (char) (int) (long) (float) ----

Tipos de conversões de tipos

Implícita
• Tamanho de uma variável é maior que o tamanho da variável ou o valor que está sendo
atribuído.
int y = 15;
long x = y;
Explícita
• Tamanho de uma variável é menor que o tamanho da variável ou o valor que está sendo
atribuído.
long y = 15L;
int x = (int) y;
Tipo Tamanho
Boolean 1 bit
Byte 1 byte
Short 2 bytes
chart 2 bytes
Int 4 bytes
Float 4 bytes
Long 8 bytes
Double 8 bytes

Funções de Conversão de Tipos

Abaixo listamos todas as funções de conversão de tipos, é essencial para qualquer programador
saber todos os tipos de conversões, mais cedo ou mais tarde sempre estaremos nos debatendo de
frente com esse tipo de problema, principalmente programadores que trabalham com o modo
visual.
Função Descrição
ToBoolean Converte um determinado valor para um valor boolean.
ToByte Converte um determinado valor para um inteiro de 8 bits.
ToChar Converte um determinado valor para um caractere unicode.
ToDateTime Converte um determinado valor para um DateTime.
ToDecimal Converte um determinado valor para um número Decimal.
Converte um determinado valor para um valor de número de
ToDouble
ponto flutuante com a precisão do tipo Double.
ToInt16 Converte um determinado valor para um inteiro de 16 bits.
 Converte um determinado valor para um inteiro de 32 bits
ToInt32
(compatível com int).
Converte um determinado valor para um inteiro de 64 bits
ToInt64
(compatível com long).
Converte um determinado valor para um valor numérico de
ToSingle ponto flutuante com precisão do tipo Single (compatível
com float).
ToString Converte um determinado valor para um formato String.
Converte um determinado valor para um inteiro de 16 bits
ToUInt16
(compatível com ushort).
Converte um determinado valor para um inteiro de 32 bits
ToUInt32
(compatível com uint).
Converte um determinado valor para um inteiro de 64 bits
ToUInt64
(compatível com ulong).

Exemplo

/**
* Exemplo de conversão de tipos primitivos utilizando casting.
*/
public class ExemploCasting {
public static void main(String[] args) {
/* Casting feito implicitamente, pois o valor possui um
tamanho menor que o tipo da variavel que irá recebe-lo. */
char a = 'a';
int b = 'b';
float c = 100;

System.out.println(a); //Imprime a
System.out.println(b); //Imprime 98
System.out.println(c); //Imprime 100.0

/* Casting feito explicitamente, pois o valor possui um tamanho

maior que o tipo da variavel que irá recebe-lo. */
int d = (int) 5.1987;
float e = (float) 5.0;
 int f = (char) (a + 5);
char g = (char) 110.5;

System.out.println(d); //Imprime 5
System.out.println(e); //Imprime 5.0
System.out.println(f); //Imprime 102
System.out.println(g); //Imprime n
}
}
 Conclusão

Durante a realização do mesmo viu que é possível se atribuir o valor de um tipo de variável a outro
tipo de variável, porém para tal é necessário que esta operação seja apontada ao compilador. Pois,
isso chamamos de Casting.

E também possível fazer conversões de tipos de ponto flutuante para inteiros, e inclusive entre o
tipo caractere, porém, vimos que estas conversões podem ocasionar a perda de valores, quando se
molda um tipo de maior tamanho, como um double dentro de um int.

No mesmo vimos que o boolean é o único tipo que não suporta casting, isso por ter um espaço tão
pequeno.
 Referências Bibliográficas

1. http://www.caelum.com.br-Java-e-Orientação-a-Objetos.
2. https://universidadejava.com.br/java-Casting-de-tipos-primitivos
3. www.devmedia.com.br/conversões-de-tipos.
4. Claro D. B. e Sobral J. B. M. PROGRAMAÇÃO EM JAVA. Pearson Education.
Florianópolis, SC.