dark_creator wrote:Double, Boolean, Byte e Long são classes empacotadoras de primitivos (Wrappers(acho que é assim que escreve)).
em Java você possui os tipos primitivos byte, char, short, int, long, float, double e boolean e para cada tipo existe uma classe empacotadora Byte, Character, Short, Integer, Long, Float, Double e Boolean.

Em Java tirando os primitivos e as Interfaces acredito que pode-se dizer que tudo são objetos (me corrijam se estiver errado ) e quando você possui uma variavel de um tipo primitivo e nescessita usa-la como objeto é ai que os Wrappers então (veja collections depois)

... int numero = 10; //Declara uma variavel do tipo int List lista = new ArrayList(); //Cria uma ArrayList lista.add(numero); //Adiciona o valor 10 ao ArrayList; porem o método add so aceita objetos e não primitivos, ai //entra o Boxing

Exemplo Casting
int inteiro = 10; //declara um inteiro short numero = (short)inteiro;

Descupe-me mas estou morrendo de sono agora e tenho de ir me deitar, qualquer coisa amanhã respondo com mais tempo mais pesquise sobre Boxing, UnBoxing, Wrappers, tipo primitivos, tipos por referencia e Casting

ViniGodoy wrote:Leia também esse tópico:
http://www.guj.com.br/posts/preList/98808/532303.java#532303

Vocês são estudam no mesmo colégio? São da mesma sala?

xandao99 wrote:Pessoal, cade vocês ? Podem me ajudar...

ViniGodoy wrote:

xandao99 wrote:Pessoal, cade vocês ? Podem me ajudar...

Oi, nós estavamos aproveitando o nosso domingo!
Que falta de educação é essa? Ficar insistindo é muito pouco ético, fazer postagens só para o seu tópico voltar ao topo da lista também.
Por favor, não repita atitudes como essa.


Então, você criou um arquivo chamado BoxingEquality.java? Todo arquivo java deve ter o mesmo nome da classe. Faça isso e só então cole o código que eu postei no outro artigo.

Note que no exemplo que eu postei já existe um main. Se quiser fazer na sua própria classe, recorte só o corpo do main e cole no seu main. Colocar imports e definir outra classe dentro do main não vai dar certo mesmo.

A classe ArrayList é uma lista de objetos. Tal como um array, mas dinâmico (você não precisa se preocupar com o tamanho dele). Você verá isso ao estudar o tópico collections.

Agora... me diz uma coisa. Pelo seu grau de conhecimento, você estava mesmo perguntando sobre:
1) Double;
2) Boolean;
3) Long;
4) Byte;

Ou você queria dizer:
1) double;
2) boolean;
3) long;
4) byte;

Estou sentindo que era sobre o segundo caso. Note que as letras maiúsculas no início de cada palavra fazem toda diferença. A primeira lista se refere a classes do Java, que são usadas para representar valores numéricos. A segunda lista representa os tipos primitivos, que são tipos de variável que contém os valores básicos, e onde podemos fazer operações como soma, subtração, multiplicação, E, OU, etc...

ViniGodoy wrote:A regra do casting é simples. Você sempre precisará fazer cast de um tipo mais preciso para um menos preciso.
Ou seja:

long -> int -> short -> byte

ou de um tipo com casa decimal para um sem casa decimal:
double -> long, int, short ou byte
float -> long, int, short ou byte

Isso porque nesse tipo de conversão existe chance de você perder dados. Aí ocorre coisas esquisitas como essa aqui:
http://www.guj.com.br/posts/list/98657.java

No sentindo inverso, não há necessidade de conversão. Afinal, você não perde dados tornando sua variável mais precisa.

Quanto a somas, qual é a sua dúvida?
Você pode fazer soma normalmente:
int x = 10 + 5; int y = x + x; int z = (y * 2) / x;
Tome cuidado com os tipos literais. Por exemplo, o valor 10, na equação acima é do tipo inteiro. O java é esperto o suficiente para te poupar do cast em atribuições diretas:
byte x = 10; //Ok, ao invés de inteiro, esse 10 é byte mesmo.

Quando uma expressão mistura mais de um tipo, o cast é feito aumaticamente para o tipo mais preciso. Se houver um número de ponto flutuante (double ou float), o cast é feito para o tipo de ponto flutuante.

Tome cuidado que o simples fato de você dividir não provoca casts. Então, a conta abaixo pode causar surpresa em alguns iniciantes:
double x = 9 / 2; System.out.println(x); //Imprime 4.0

9 é inteiro. 2 é inteiro. Não houve cast no resultado e, por ser inteiro, perdeu as casas demais. Contas de inteiros são admitidas pela linguagem. Para contornar o problema, faça o seguinte:

double x = 9.0 / 2; //Agora 9 é um double. 2 será promovido para double e o resultado será double.

Ou:
double x = 9 / 2.0; //Agora 2 é um double. 9 será promovido para double e o resultado será double.

Ou ainda:
double x = 9.0 / 2.0; //Ok, ambos double. Resultado double.

Cara, não entendi. Qual é o seu problema com o for e com o while?

thingol wrote:Acho que o problema com o for e o while é que não devem ter aprendido fluxogramas na escola.

Parecem coisas jurássicas, os fluxogramas, mas são muito úteis para explicar as coisas.

Se aprendermos fluxogramas, descobriremos que tudo é uma variação de "if" e "goto" - já que é assim que funciona o computador.

Acho que primeiramente deveria ser ensinado o "if", o "switch", então o "do/while" (que é relativamente fácil de representar em fluxogramas"), então o "while" (que é um pouco mais difícil de representar), e por fim o "for", que é uma espécie de "while" metido a besta.

Se bem que, pelo meu estilo de pensamento, preferiria primeiramente aprender o "for" (com os parâmetros padrão, do tipo "for (int i = 1; i <= 10; ++i)" ), depois o "if", e então o "do/while" e por fim o "while", que acho terrivelmente difícil de entender logo de cara.

ViniGodoy wrote:As variáveis tem um tamanho na memória. Esse tamanho, diz o quão grandes ou pequenos os valores das variáveis podem ser.

Uma variável byte, por exemplo, ocupa um único byte, (surpresa!!!), ou seja, oito bits. Por isso seus valores variam de -128 até 127 (eleve 2 a 8 e subtraia 1 = 255). É impossível guardar um valor fora desse intervalo em um único byte.

Uma variável short tem 16 bits, logo seus valores variam de 2^16-1=-32.768 até 32.767.
Um int, 32 bits, os valores variam de -2.147.483.648 até 2.147.483.647.
E um long tem 64 bits, os valores variam de 18.446.744.073.709.551.616 até 18.446.744.073.709.551.617.

No caso do double e do long, é basicamente a mesma coisa. O double tem o dobro de tamanho que um long, por isso, terá uma precisão muito maior, por suportará mais casas decimais.

A escolha dos tamanhos das variáveis tem algumas consequências:
1. Afeta a precisão dos seus resultados e os intervalos máximos e mínimos que o seu programa trabalha;
2. Envolve o consumo de memória do seu programa. Embora isso geralmente não seja um problema, exceto em aplicações muito específicas, como jogos de computadores;
4. Pode ter impacto na performance do seu programa. Geralmente, variáveis com o tamanho da palavra do seu processador (32 bits na maior parte dos computadores, embora estão se tornando comuns os micros de 64), são processadas mais rapidamente.

A recomendação geral é que vc escolha int e double. Mas é muito bom saber que outros tipos existem. Aliás, alguns tipos também são adequados em situações específicas:

long -> Quando trabalhamos com o tempo em milisegundos;
byte[] -> Em manipulação de dados no formato binário;
float -> Em aplicações de computação gráfica. Usa-se para representar cores, posição dos vértices de uma figura, normais de luz, etc.

Entre outros exemplos...