Diferença entre int e Int - Variáveis JAVA

int = primitiva ; ( Local )
Int = referêncial ; ( Classes )

Existem duas versões de variável: Primitiva e referêncial.

Tamanho das variáveis.

byte : 8
short : 16
int : 32
long : 64
Float : 32
double : 64

TIPO PRIMITIVO

Tipo Quantidade de bits Intervalo de valores

BOLLEANO E CHAR

Bolleno (específica da JVM) verdadeiro ou falso
char 16 bits 0 a 65535

NUMÉRICO (Todos têm sinal)
Interiro
byte 8 bits -128 a 127
curto 16 bits -32768 a 32767
int 32 bits -2147483648 a 2147483647
long 64 bits - enorme e enorme

PONTO FLUTUANTE
float 32 bits varia
double 64 bits varia


DECLARAÇÕES PRIMITIVAS COM ATRIBUIÇÕES:

int x;
x = 234;
// IsFun = é diversão
boolean isFun = true;
double d = 3456.98;
char c = 'f' ;
int z = x;
boolean isPunkRock;
isPunkRock = false;
boolean powerOn;
powerOn isFun;
long big = 3456789;
float f = 32.5f;

Observe o 'f'. É preciso inseri-lo em um tipo float, porque o Java considera tudo que encontra com um ponto flutunate como um tipo double, a menos que 'f' seja usado.

QUANDO VOCÊ PROJETAR UMA CLASSE, PENSE NOS OBJETOS QUE SERÃO CRIADOS COM ESSE TIPO DE CLASSE. CONSIDERE:

EXERCÍCIOS PAG 18

public class Shuffle1 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int x = 3;

while (x > 0){
// Ramificação
if (x > 2){
System.out.println("a");
}

// Contator
x = x - 1;

System.out.println("-");

// Ramificação
if (x == 2){
System.out.println("b c");
// Contator
x = x - 1;
}

// Ramificação
if (x == 1){
System.out.println("d");
// Contator
x = x - 1;
}

}





EXERCÍCIO A

public class ExerciseIb {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

// Esse código será compilado e executado (sem saída), mas sem uma
// linha adicionada ao programa, ele seria processado indefinidamente
// em um loop 'while' infinito!

int x = 1;
while (x < 10){

x = x + 1;
if (x > 3){
System.out.println("big (grande) x");
}
}

}


EXERCÍCIO B

public class foo {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

// Esse arquivo não será compilado sem um declaração
// de classe, e não se esqueça da chave correspondente!

int x = 5;
while (x > 1){

x = x - 1;

if (x < 3){
System.out.print("Small (pequeno) x");
}
}


EXERCÍCIO C


public class exercise1b {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 5;

// O código do loop 'while' deve ficar dentro de um método. Não pode
// ficar simplismente isolado fora da classe.

while (x > 1){
x = x - 1;
if (x < 3){
System.out.println("small (pequeno) x");
}
}
}

QUEBRA CABEÇA NO QUDRADO

Sua tarefa é pegar trecho de código no quadrado e inseri-los nas linhas em branco do código. Você pode não usar o mesmo trecho mais de uma vez e não terá que empregar todos os trechos. Seu objetivo é criar uma classe que seja compilada e executada produzindo a saída listada. Não se engane – esse exercício é mais difícil do que você pensa.
public static void main(String[] args) {
// TODO code application logic here

int x = 0;

while ( ) {

________________________
if (x < 1){
_____________________
{

_____________________

if ( ) {

______________________
______________________

}

if (x == 1){
__________________
}

if ( ){
_______________________
}

System.out.println("");

____________________

}
}


RESPOSTA!

*
* @author thiago_azeredo
*/
public class PoolPuzzleOne {
public static void main(String[] args) {
// TODO code application logic here

int x = 0;

while (x < 4) {

System.out.print("a");

if (x < 1){
System.out.print(" ");
}

System.out.print("n");

if (x > 1) {
System.out.println(" oyster");
x = x + 2;
}

if (x == 1){
System.out.print("noys");
}

if ( x < 1){
System.out.print("oise");
}

System.out.println("");

x = x + 1;

}
}

MENSAGENS MISTURADAS PAG 16

Um programador Java curto é listado a seguir. Um bloco do programa está falando. Seu desafio é comparar o bloco de código candidato (à esquerda) com a saída que você veria se ele fosse inserido. Nem todas as linhas de saída serão usadas e algumas delas podem ser usadas mais de uma vez. Desenhe linhas conectando os blocos de código candidatos à saída de linha de comando correspondentes. (As respostas estão no final.)




package msgMisturadaPag16;

/**
*
* @author thiago_azeredo
*/
public class MenssagemMisturada {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int x = 0;
int y = 0;
// Primeiro cruzamento !
while (x < 5){

// 1° Cruzamento RESPOSTA 00 11 21 32 42
//y = x - y;

// 2° cruzamento RESPOSTA 00 11 23 36 410
// y = y + x;

// 3° cruzamento RESPOSTA 02 14 25 36 47
// y = y + 2;
// if (y > 4){
// y = y - 1;
// }

// 4° cruzamento RESPOSTA 11 34 59
// x = x + 1;
// y = y + x;

// 5° cruzamento RESPOSTA 02 14 36 48
//if ( y < 5 ){

// x = x + 1;
// if (x < 3){
// x = x - 1;
// }
// }
// y = y + 2;


System.out.println(x + "" + y + "");
x = x + 1;
}

}

}

Agora daremos algo para o lado direito de seu celebro faze:

É uma palavra ...mas quase todas as palavras da solução ... Apenas para que você fique alerta, também incluímos algumas palavras (não relacionadas à Java) do universo tecnológico.
Código linha de comando ? (3 letras)
Mais um vez? (4 letras)
Não pode seguir dois cominhos ? (11 letras)
Acrônimo do tipo de energia de seu laptop? (2 Letras)
Tipo numérico de variável? (3 letras)
Acrômico de um chip? (2 Letras)
Exibir Algo? (12 letras)
Um conjunto de caracteres? (6 letras)
Anunciar uma nova classe ou método? (8 letras)
Para que serve um prompt? (7 Letras)
Não é um inteiro (ou seu Barco é um objeto___) (8 letras)
Voltou de mãos vazias? (6 letras)
As portas estão abertas? (5 letras)
Depto. de manipuladores de LAN (3 letras)
Contêineres de itens (4 letras)
Até que as atitudes melhorem? (9 letras)
Consumidor de código-fonte? (4 letras)
Não é possível fixa-la? (2 letras)
Modificador inesperado? (8 letras)
Como fazer algo? (6 letras)
Consumidor de bytecode? (6 letras)



RESPOSTA DAS PERGUNTAS !
JVM
LOOP
RAMIFICADOS
CC
Int
CI
SAíDA SISTEMA
STRING
DECLARAR
COMANDO
MATRIZ
STATIC
WHILE
JVM
MAIN
FLUTUANTE
VOID
COMPILADOR
VARIAVEL
IR
PUBLIC
MÉTODO

SEJA O COMPILADOR

arquivos Java dessa página representa um arquivo-fonte completo. Sua tarefa é personificar o compilador e determinar se cada um deles pode ser compilado. Se não puderem ser compilados, com você os corrigiria?

OBS: ROTINA COM ERRO!

public class ExerciseIb {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int x = 1;

while (x < 10){
if (x > 3){
System.out.println("Grande X");
}
}
}

OBS: A rotina acima não está funcionando pois está sem um contador,e com isso ficaria em lupe eterno e não imprimeria nunca a mensagem.

OBS: A Rotina que está abaixo está correto e irá imprimir no console 7 vezes a mensagem.

public class ExerciseIb {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int x = 1;

while (x < 10){
if (x > 3){
System.out.println("Grande X");
}
x = x + 1;
}
}

*******************************************************************************

OBS: ROTINA CORRETA

* @author thiago_azeredo
*/
public class ExerciseIb {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here

int x = 5;

while (x > 1){

x = x - 1;
if (x < 3){
System.out.println("Pequeno x");
}
}
}

*****************************************************************************

OBS: ROTINA INCORRETA, pois não será executada não tem o método MAIN !

public class ExerciseIb {

int x = 5;
while (x > 1){
x = x - 1 ;
if (x < 3){
System.out.println("Pequeno x");
}
}


OBS: Abaixo está a rotina correta, com o Método MAIN !

* @author thiago_azeredo
*/
public class ExerciseIb {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 5;
while (x > 1){
x = x - 1 ;
if (x < 3){
System.out.println("Pequeno x");
}
}
}