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.
sexta-feira, 13 de março de 2009
quarta-feira, 18 de fevereiro de 2009
terça-feira, 17 de fevereiro de 2009
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");
}
}
}
/**
* @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;
}
}
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;
}
}
domingo, 15 de fevereiro de 2009
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;
}
}
}
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;
}
}
}
sábado, 14 de fevereiro de 2009
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
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
sexta-feira, 13 de fevereiro de 2009
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");
}
}
}
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");
}
}
}
Exercício – Imãs com código
Um programador Java funcional está todo misturado sobre a porta da geladeira. Você conseguiria reorganizar os trechos de código para criar um programa Java funcional que produzisse a saída listada abaixo? Algumas das chaves caíram no chão e são muito pequenas para que as recuperemos, portanto, fique a vontade para adicionar quantas delas precisar.
/**
*
* @author thiago_azeredo
*/
public class ImasComCodigo {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 3;
if (x > 2){
System.out.println("Print AAAAAAA");
}
}
quinta-feira, 12 de fevereiro de 2009
Bate Papo entre compilador e JVM
Conversa de hoje: O compilador e a JVM discutem a questão.
Quem é mais importante?
A Máquina Vitual Java
- O que, você está brincando? Olá. Sou o Java. Sou eu quem efetivamente faz um programa ser executado. O compilador apenas lhe oferece um arquivo. É só. Apenas um arquivo. Você pode imprimir e usá-lo como papel de parede, para acender fogo, forrar a gaiola de pássaros ou seja lá o que for, mas o arquivo não fará nada a menos que eu esteja lá para executá-lo.
O Compilador
- Não aprecio esse tom.
A Máquina Vitual Java
- E esse é outro problema, o compilador não tem senso de humor. Lógico, se você tivesse que passar o dia inteiro verificando pequenas violações na sintaxe munuciosamente...
O Compilador
- Desculpe, mas sem a minha presença, o que exatamente você executaria? Há uma razão para o Java ter sido projetado para usar um compilador de bytecode, se você não sabe. Se ele fosse uma linguagem de puramente interpretada, onde - no tempo de execução – a máquina virtual tivesse que converter código-fonte diretamente de um editor de texto, o programa Java seria executado a uma velocidade comicamente lenta. O Java já demorou tempo suficiente para convencer as pessoas de que é rápido e poderoso o bastante para a maioria dos trabalhos.
A Máquina Vitual Java
Não estou falando que você é, digamos, completamente inútil. Mas conversamos, o que você faz? Sério. Não faço idéias. Um programador poderia apenas escrever bytecode manualmente, e eu o usaria. Você pode ficar sem trabalho em breve, amigo.
O Compilador
Desculpe, mas esse é um ponto de vista bem displicente (para não dizer arrogante). Embora seja verdade que – teoricamente – você possa executar qualquer bytecode formatado aproximadamente mesmo se ele não vier de um compilador Java, na prática isso é absurdo. Um programador escrevendo bytecode manualmente é como se você executasse se processamento de palavras usando postScript pura. E eu apreciaria se não se dirigisse a mim como “amigo”.
A Máquina Vitual Java
(Vou continuar insistindo na veia irônica.) Mas você ainda não respondeu minha pergunta, o que faz realmente?
O Compilador
Lembre-se de que o Java é uma linguagem fortemente tipificada, o que significa que não posso permitir que as variáveis armazenadas dados com o tipo errado. Esse é um recurso de segurança crucial e posso bloquear a grande maioria das violações antes que elas cheguem até você. Além disso.
A Máquina Vitual Java
Mas algumas ainda passam! Possa lançar exceções ClassCastException e às vezes vejo pessoas tentando inserir o tipo errado de coisa em uma matriz que foi declarada como contendo algo e -
O Compilador
Desculpe, mas não terminei. E sim, há algumas exceções de tipo de dado que podem surgir no tempo de execuções, mas algumas delas têm que ser permitidas, para que outro recurso Java importante tenha suporte – a vinculação dinâmica. No tempo de execução, um programa Java pode incluir novos objetivos que não eram conhecidos nem mesmo pelo programador original, portanto, tenho que permitir um certo nível de flexibilidade. Mas meu trabalho é bloquear qualquer coisa mais séria – poderia ser – bem sucedida no tempo de execução. Geralmente consigo saber quando algo não vai funcionar, por exemplo, se um programador tentasse acidentalmente usar um objetivo Button como uma conexão de soquete, eu detectaria isso e evitaria que ele causasse danos no tempo de execução.
A Máquina Vitual Java
OK. Certo. Mas e quanto à segurança? Veja que eu faço com relação à segurança e você fica, digamos, procurando sinais de ponto-e-virgula? Ooooh, mas grande risco à segurança! Muito obrigado”
O Compilador
Desculpe, mas sou a primeira linha de defesa, como dizem. As violações de tipo de dado que descrevi anteriormente poderiam danificar um programa se fosse permitido que elas se manifestassem. Também sou eu que impeço as violações de acesso, como, por exemplo, um código que tentasse chamar um método privado, ou alterar um método que – por razões de segurança – não pudesse nunca ser alterado. Impeço as pessoas de mexer em códigos que tentem acessar dados críticos de outra classe. Demoraria horas, talvez dias, para eu conseguir descrever a importância de meu trabalho.
A Máquina Vitual Java
Não Importa. Acabo tendo que fazer a mesma coisa só para me certificar se alguém obteve acesso depois de você e alterou o bytecode antes de executá-los.
O Compilador
É claro, mas com descrevi anteriormente, se eu impedisse o que talvez chegue a 99% dos problemas potenciais, você acabaria travando. E parece que não temos mais tempo, portanto, teremos que voltar a isso um bate-papo em um bate-papo posterior.
A Máquina Vitual Java
Oh, pode contar com isso. Amigo.
Quem é mais importante?
A Máquina Vitual Java
- O que, você está brincando? Olá. Sou o Java. Sou eu quem efetivamente faz um programa ser executado. O compilador apenas lhe oferece um arquivo. É só. Apenas um arquivo. Você pode imprimir e usá-lo como papel de parede, para acender fogo, forrar a gaiola de pássaros ou seja lá o que for, mas o arquivo não fará nada a menos que eu esteja lá para executá-lo.
O Compilador
- Não aprecio esse tom.
A Máquina Vitual Java
- E esse é outro problema, o compilador não tem senso de humor. Lógico, se você tivesse que passar o dia inteiro verificando pequenas violações na sintaxe munuciosamente...
O Compilador
- Desculpe, mas sem a minha presença, o que exatamente você executaria? Há uma razão para o Java ter sido projetado para usar um compilador de bytecode, se você não sabe. Se ele fosse uma linguagem de puramente interpretada, onde - no tempo de execução – a máquina virtual tivesse que converter código-fonte diretamente de um editor de texto, o programa Java seria executado a uma velocidade comicamente lenta. O Java já demorou tempo suficiente para convencer as pessoas de que é rápido e poderoso o bastante para a maioria dos trabalhos.
A Máquina Vitual Java
Não estou falando que você é, digamos, completamente inútil. Mas conversamos, o que você faz? Sério. Não faço idéias. Um programador poderia apenas escrever bytecode manualmente, e eu o usaria. Você pode ficar sem trabalho em breve, amigo.
O Compilador
Desculpe, mas esse é um ponto de vista bem displicente (para não dizer arrogante). Embora seja verdade que – teoricamente – você possa executar qualquer bytecode formatado aproximadamente mesmo se ele não vier de um compilador Java, na prática isso é absurdo. Um programador escrevendo bytecode manualmente é como se você executasse se processamento de palavras usando postScript pura. E eu apreciaria se não se dirigisse a mim como “amigo”.
A Máquina Vitual Java
(Vou continuar insistindo na veia irônica.) Mas você ainda não respondeu minha pergunta, o que faz realmente?
O Compilador
Lembre-se de que o Java é uma linguagem fortemente tipificada, o que significa que não posso permitir que as variáveis armazenadas dados com o tipo errado. Esse é um recurso de segurança crucial e posso bloquear a grande maioria das violações antes que elas cheguem até você. Além disso.
A Máquina Vitual Java
Mas algumas ainda passam! Possa lançar exceções ClassCastException e às vezes vejo pessoas tentando inserir o tipo errado de coisa em uma matriz que foi declarada como contendo algo e -
O Compilador
Desculpe, mas não terminei. E sim, há algumas exceções de tipo de dado que podem surgir no tempo de execuções, mas algumas delas têm que ser permitidas, para que outro recurso Java importante tenha suporte – a vinculação dinâmica. No tempo de execução, um programa Java pode incluir novos objetivos que não eram conhecidos nem mesmo pelo programador original, portanto, tenho que permitir um certo nível de flexibilidade. Mas meu trabalho é bloquear qualquer coisa mais séria – poderia ser – bem sucedida no tempo de execução. Geralmente consigo saber quando algo não vai funcionar, por exemplo, se um programador tentasse acidentalmente usar um objetivo Button como uma conexão de soquete, eu detectaria isso e evitaria que ele causasse danos no tempo de execução.
A Máquina Vitual Java
OK. Certo. Mas e quanto à segurança? Veja que eu faço com relação à segurança e você fica, digamos, procurando sinais de ponto-e-virgula? Ooooh, mas grande risco à segurança! Muito obrigado”
O Compilador
Desculpe, mas sou a primeira linha de defesa, como dizem. As violações de tipo de dado que descrevi anteriormente poderiam danificar um programa se fosse permitido que elas se manifestassem. Também sou eu que impeço as violações de acesso, como, por exemplo, um código que tentasse chamar um método privado, ou alterar um método que – por razões de segurança – não pudesse nunca ser alterado. Impeço as pessoas de mexer em códigos que tentem acessar dados críticos de outra classe. Demoraria horas, talvez dias, para eu conseguir descrever a importância de meu trabalho.
A Máquina Vitual Java
Não Importa. Acabo tendo que fazer a mesma coisa só para me certificar se alguém obteve acesso depois de você e alterou o bytecode antes de executá-los.
O Compilador
É claro, mas com descrevi anteriormente, se eu impedisse o que talvez chegue a 99% dos problemas potenciais, você acabaria travando. E parece que não temos mais tempo, portanto, teremos que voltar a isso um bate-papo em um bate-papo posterior.
A Máquina Vitual Java
Oh, pode contar com isso. Amigo.
terça-feira, 10 de fevereiro de 2009
PARÁFRASE PAG 12
Teste meu novo código de paráfrase e você falará engenhosamente como o chefe ou o pessoal de marketing.
package parafrasePag12;
/**
*
* @author thiago_azeredo
*/
public class PhraseOMatic {
/**
* @param args the command line arguments
*
* Códido de Paráfrases.
*
* -> Teste meu novo código de paráfrase e você falará engenhosamente
* como o chefe ou o pessoal de marketing
*
*/
public static void main(String[] args) {
// TODO code application logic here
// crie três conjuntos de palavras onde será feita a seleção. Adicione
// o que quiser!
String [] wordListOne = { "24/7", "várias camadas", "30.000 pés",
"B-to-B", "Todos ganham", "front-end", "baseado na web", "difundido",
"inteligente","seis", "sigma", "caminho crítico","dinâmico"};
String []wordListTwo = { "habilitado", "adesivo", "valor agragado", "orientado",
"central", "distribuído", "agrupado", "solidificado", "independente da máquina",
"posicionado", "en rede", "dedicado", "alavancado", "alinhado", "destinado",
"compartilhado", "cooperativo", "acelerado"};
String [] wordListTheree = {"processo", "ponto máximo", "soluções", "arquitetura",
"habilitação no núcleo", "estratégia","mindshare","portal","espaço","visão",
"paradigma","missão"};
// Descubra quantas palavras existem em cada lista
// a "função" length verificará a quantidade de palavras (word) em cada Lista !
int oneLength = wordListOne.length;
int twoLength = wordListTwo.length;
int ThereeLength = wordListTheree.length;
System.out.println("One: " + oneLength + " Two: " + twoLength + " Theree: " + ThereeLength);
// Gere trê números aleatórios
int rand1 = (int) (Math.random() * oneLength);
int rand2 = (int) (Math.random() * twoLength);
int rand3 = (int) (Math.random() * ThereeLength);
// Agora phrase (frase) ( Construindo uma frase )
String phrafe = wordListOne[rand1] + " " + wordListTwo[rand2] + " " + wordListTheree[rand3];
// Exibindo a frase
System.out.println("Procedimentos -> " + phrafe);
}
}
Certo, quer dizer que a canção da cerveja não era na verdade um aplicativo empresarial profissional. Ainda precisa de algo prático para mostrar ao chefe?
Veja o código da paráfrase.
Nota: quando você digitar isso em um editor, deixe o código criar sua própria quebra de palavra/linha! Nunca pressione a tecla enter quando estiver digitando uma string ( algo entre “aspas”) , ou ela não será compilado. Portanto, os hífens vistos nessa nessa página são reais e você pode digitá-los, mas não pressione a tecla Enter antes de terminar uma string.
package parafrasePag12;
/**
*
* @author thiago_azeredo
*/
public class PhraseOMatic {
/**
* @param args the command line arguments
*
* Códido de Paráfrases.
*
* -> Teste meu novo código de paráfrase e você falará engenhosamente
* como o chefe ou o pessoal de marketing
*
*/
public static void main(String[] args) {
// TODO code application logic here
// crie três conjuntos de palavras onde será feita a seleção. Adicione
// o que quiser!
String [] wordListOne = { "24/7", "várias camadas", "30.000 pés",
"B-to-B", "Todos ganham", "front-end", "baseado na web", "difundido",
"inteligente","seis", "sigma", "caminho crítico","dinâmico"};
String []wordListTwo = { "habilitado", "adesivo", "valor agragado", "orientado",
"central", "distribuído", "agrupado", "solidificado", "independente da máquina",
"posicionado", "en rede", "dedicado", "alavancado", "alinhado", "destinado",
"compartilhado", "cooperativo", "acelerado"};
String [] wordListTheree = {"processo", "ponto máximo", "soluções", "arquitetura",
"habilitação no núcleo", "estratégia","mindshare","portal","espaço","visão",
"paradigma","missão"};
// Descubra quantas palavras existem em cada lista
// a "função" length verificará a quantidade de palavras (word) em cada Lista !
int oneLength = wordListOne.length;
int twoLength = wordListTwo.length;
int ThereeLength = wordListTheree.length;
System.out.println("One: " + oneLength + " Two: " + twoLength + " Theree: " + ThereeLength);
// Gere trê números aleatórios
int rand1 = (int) (Math.random() * oneLength);
int rand2 = (int) (Math.random() * twoLength);
int rand3 = (int) (Math.random() * ThereeLength);
// Agora phrase (frase) ( Construindo uma frase )
String phrafe = wordListOne[rand1] + " " + wordListTwo[rand2] + " " + wordListTheree[rand3];
// Exibindo a frase
System.out.println("Procedimentos -> " + phrafe);
}
}
Certo, quer dizer que a canção da cerveja não era na verdade um aplicativo empresarial profissional. Ainda precisa de algo prático para mostrar ao chefe?
Veja o código da paráfrase.
Nota: quando você digitar isso em um editor, deixe o código criar sua própria quebra de palavra/linha! Nunca pressione a tecla enter quando estiver digitando uma string ( algo entre “aspas”) , ou ela não será compilado. Portanto, os hífens vistos nessa nessa página são reais e você pode digitá-los, mas não pressione a tecla Enter antes de terminar uma string.
SEGUNDA DE MANHÃ NA CASA DE BOB
O despertador de Bob toca às 08:00 da manhã de segunda, como em todos os outros dias da semana. Mas Bob leve um fim de semana e procura o botão SNOOZE. E aí que a ação começa e os aparelhos habilitados com Java despertando.
Primeiro, o despertador envia uma mensagem para a cafeteira. “Ei, o espertinho está dormindo de novo, atrase o café em 12 minutos.”
A cafeteira envia uma mensagem para a torradeira Motorola. “Sugere a torrada, Bob está tirando uma soneca.”
Em seguida, o despertador envia uma mensagem para o celular Nokia Navigator de Bob: “Chama Bob às 9 horas e diga para ele que estamos ficando um pouco atrasado.”
Para concluir, o despertador envia uma mensagem para a coleira sem fio de Sam (Sam é o cachorro dele), com um sinal bastante familiar que significa: “Pegue o jornal, mas não espere ser levado para um passeio.”
Alguns minutos depois, o despertador toca novamente. E mas uma vez Bob aperta o botão SNOOZE, e os aparelhos começam a se comunicar. O despertador toca uma terceira vez. Mas, assim bob alcança o botão SNOOZE, o despertador envia o sinal “Salte a lata” para a coleira da Sam. Trazido à consciência por esse choque, Bob se levanta, grato por suas aptidões em Java e um pequeno passeio à Radio Shake terem melhorando a rotina diária de sua vida.
Sua torrada está pronta.
Seu café está quente.
Seu jornal está esperando.
Apenas mais uma maravilhosa manhã na Casa Habilitada com Java.
Você também pode ter um lar habilitado com Java. Adote sensata que use Java, a Ethenet e a tecnologia Jini. Cuidado com imitações ao usar outras plataformas “plug and play” (que na verdade significa “conecte e perca os próximos três dias tentando fazer funcionar”) ou “portáveis”. A irmã de Bob, Betty, testou uma dessas outras plataformas e os resultados foram, digamos, não muito atraente, ou seguros. Também não deu certo com seu cachorro ...
Essa história poderia ser verdadeira? Sim ou não. Embora haja versão de Java sedo executadas em dispositivos, dentre os quais os PDAs, telefones celulares (principalmente nos telefones celulares), pagers, alarmes, cartões, inteligentes e outros – talvez você não encontre uma torradeira ou colecione com Java. Mas mesmo se você não conseguir encontrar uma versão habilitada para Java de seus aparelhos favoritos, ainda poderá executá-los como se fossem um dispositivo Java, controlando-os através de algumas outras interface (como seu laptop) que esteja executando Java. Isso é conhecido como arquitetura substantiva Jini. Sim, você pode ter essa casa dos sonhos de um nerd.
• IP multicast se você for sistemático com relação a protocolos
Primeiro, o despertador envia uma mensagem para a cafeteira. “Ei, o espertinho está dormindo de novo, atrase o café em 12 minutos.”
A cafeteira envia uma mensagem para a torradeira Motorola. “Sugere a torrada, Bob está tirando uma soneca.”
Em seguida, o despertador envia uma mensagem para o celular Nokia Navigator de Bob: “Chama Bob às 9 horas e diga para ele que estamos ficando um pouco atrasado.”
Para concluir, o despertador envia uma mensagem para a coleira sem fio de Sam (Sam é o cachorro dele), com um sinal bastante familiar que significa: “Pegue o jornal, mas não espere ser levado para um passeio.”
Alguns minutos depois, o despertador toca novamente. E mas uma vez Bob aperta o botão SNOOZE, e os aparelhos começam a se comunicar. O despertador toca uma terceira vez. Mas, assim bob alcança o botão SNOOZE, o despertador envia o sinal “Salte a lata” para a coleira da Sam. Trazido à consciência por esse choque, Bob se levanta, grato por suas aptidões em Java e um pequeno passeio à Radio Shake terem melhorando a rotina diária de sua vida.
Sua torrada está pronta.
Seu café está quente.
Seu jornal está esperando.
Apenas mais uma maravilhosa manhã na Casa Habilitada com Java.
Você também pode ter um lar habilitado com Java. Adote sensata que use Java, a Ethenet e a tecnologia Jini. Cuidado com imitações ao usar outras plataformas “plug and play” (que na verdade significa “conecte e perca os próximos três dias tentando fazer funcionar”) ou “portáveis”. A irmã de Bob, Betty, testou uma dessas outras plataformas e os resultados foram, digamos, não muito atraente, ou seguros. Também não deu certo com seu cachorro ...
Essa história poderia ser verdadeira? Sim ou não. Embora haja versão de Java sedo executadas em dispositivos, dentre os quais os PDAs, telefones celulares (principalmente nos telefones celulares), pagers, alarmes, cartões, inteligentes e outros – talvez você não encontre uma torradeira ou colecione com Java. Mas mesmo se você não conseguir encontrar uma versão habilitada para Java de seus aparelhos favoritos, ainda poderá executá-los como se fossem um dispositivo Java, controlando-os através de algumas outras interface (como seu laptop) que esteja executando Java. Isso é conhecido como arquitetura substantiva Jini. Sim, você pode ter essa casa dos sonhos de um nerd.
• IP multicast se você for sistemático com relação a protocolos
sexta-feira, 6 de fevereiro de 2009
CODIFICANDO UM APLICATIVO EMPRESARIAL REAL
Colocaremos todas as suas novas aplicações em Java em uso como algo prático. Precisamos de uma classe com método main(), um tipo int e uma variável String, um loop while e teste IF. Mais alguns retoques e você estará construindo esse back-end empresarial sem demora. Mas antes examinará o código dessa rotina e pensará por um instante em você codificaria esse grande clássico, “99 garrafas de cervejas”.
OBS: Há erros tente encontrar o ERRO na rotina !
public class BeerSong {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int beerNum = 99;
String word = "bottles";
while (beerNum > 0) {
if (beerNum == 1){
word = "bottle"; // no singular, uma Garrafa
}
System.out.println(beerNum + " " + word + " of beer on the wall") ;
System.out.println("Take one down.");
System.out.println("Pass it around");
if (beerNum > 0){
System.out.println(beerNum + " " + word + " of beer on the wall");
}else{
System.out.println("No more bottles of beer on the wall");
}
}
}
OBS: Há erros tente encontrar o ERRO na rotina !
public class BeerSong {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int beerNum = 99;
String word = "bottles";
while (beerNum > 0) {
if (beerNum == 1){
word = "bottle"; // no singular, uma Garrafa
}
System.out.println(beerNum + " " + word + " of beer on the wall") ;
System.out.println("Take one down.");
System.out.println("Pass it around");
if (beerNum > 0){
System.out.println(beerNum + " " + word + " of beer on the wall");
}else{
System.out.println("No more bottles of beer on the wall");
}
}
}
RAMIFICAÇÃO CONDICIONAL
Em Java, um IF é basicamente o mesmo que o teste booleano de um loop while – só que em vez de dizer “while (enquanto) ainda houve cerveja ...”, você dirá “ IF (se) ainda houver cerveja ...”
public class IfTest {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 3; // atribui o número 3 a uma variavel do tipo inteiro !
if (x == 3){ // == se x for realmente iqual a 3 ( iqualdade )
System.out.println("x deve ser iqual a 3");
}else{
System.out.println("Isso será executado de qualquer forma");
}
}
O código anterior executará a linha que exibe “x deve ser igual a 3” somente se a condição (x é iqual a 3) for atendida. Independentemente de ser verdadeira, no entanto, a linha que exibe “Isto será executado de qualquer forma” será executada. Portanto, dependendo do valor de x, uma ou duas instruções serão exibidas.
Mas podemos adicionar uma instrução else à condição, para podermos dizer algo como “IF ainda houver cerveja, continue a codificar, else (caso contrário) pegue mais cerveja e então continue ...
public class IfTest2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 2; // atribuição
if (x == 3){
System.out.println("x deve ser igual a 3");
}else{
System.out.println("x NÃO é igual a 3");
}
System.out.println("Isso será executado de qualquer forma");
}
public class IfTest {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 3; // atribui o número 3 a uma variavel do tipo inteiro !
if (x == 3){ // == se x for realmente iqual a 3 ( iqualdade )
System.out.println("x deve ser iqual a 3");
}else{
System.out.println("Isso será executado de qualquer forma");
}
}
O código anterior executará a linha que exibe “x deve ser igual a 3” somente se a condição (x é iqual a 3) for atendida. Independentemente de ser verdadeira, no entanto, a linha que exibe “Isto será executado de qualquer forma” será executada. Portanto, dependendo do valor de x, uma ou duas instruções serão exibidas.
Mas podemos adicionar uma instrução else à condição, para podermos dizer algo como “IF ainda houver cerveja, continue a codificar, else (caso contrário) pegue mais cerveja e então continue ...
public class IfTest2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 2; // atribuição
if (x == 3){
System.out.println("x deve ser igual a 3");
}else{
System.out.println("x NÃO é igual a 3");
}
System.out.println("Isso será executado de qualquer forma");
}
quinta-feira, 5 de fevereiro de 2009
EXEMPLO DE UM LOOP WHILE
public class Loop {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 1;
System.out.println("Antes do loop");
while (x < 1) {
System.out.println("No loop");
System.out.println("O valor de x é " + x);
x = x + 1;
}
System.out.println("Esse é o fim do loop");
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 1;
System.out.println("Antes do loop");
while (x < 1) {
System.out.println("No loop");
System.out.println("O valor de x é " + x);
x = x + 1;
}
System.out.println("Esse é o fim do loop");
}
}
NÃO EXISTEM PERGUNTAS IDIOTAS ! Pag 9
P: Por que temos que inserir tudo em uma classe?
R: O Java é uma linguagem orientada a objetos (OO) não é com antigamente, quando tínhamos compiladores antiquados e criávamos um arquivo-fonte monolítico com uma pilha de procedimentos. No capítulo 2, você apreenderá que uma classe consiste no projeto de um objetivo e que quase tudo em Java é um objeto.
P: Tenho que inserir um método main em toda classe que criar?
R: Não. Um programa em Java pode usar várias classes (até mesmo centenas), mas você pode ter só uma com um método main – que fará o programa começar a ser executado. Você pode criar classes de teste, no entanto, que tenham método main para testar suas outras classes.
P: Em minha outra linguagem, posso fazer um teste booleano com um tipo inteiro. Em Java, posso dizer algo como
Int x = 1 ;
While (x) { }
R: Não. Um booleano e um inteiro não são tipos comportáveis em Java. Como o resultado de um teste condicional deve ser um booleano, a única variável que você pode testar diretamente (sem usar um operador de comparação ( < > = == ) é um booleano. Por exemplo, você dizer:
Boolean inHot = true;
While(ishot) { }
R: O Java é uma linguagem orientada a objetos (OO) não é com antigamente, quando tínhamos compiladores antiquados e criávamos um arquivo-fonte monolítico com uma pilha de procedimentos. No capítulo 2, você apreenderá que uma classe consiste no projeto de um objetivo e que quase tudo em Java é um objeto.
P: Tenho que inserir um método main em toda classe que criar?
R: Não. Um programa em Java pode usar várias classes (até mesmo centenas), mas você pode ter só uma com um método main – que fará o programa começar a ser executado. Você pode criar classes de teste, no entanto, que tenham método main para testar suas outras classes.
P: Em minha outra linguagem, posso fazer um teste booleano com um tipo inteiro. Em Java, posso dizer algo como
Int x = 1 ;
While (x) { }
R: Não. Um booleano e um inteiro não são tipos comportáveis em Java. Como o resultado de um teste condicional deve ser um booleano, a única variável que você pode testar diretamente (sem usar um operador de comparação ( < > = == ) é um booleano. Por exemplo, você dizer:
Boolean inHot = true;
While(ishot) { }
iterando e iterando e.... Loop !
O Java tem três estruturas de loop padrão: while, do-while e for. Você verá os loops posteriormente no livro, mas não nesse momento; dessa forma, usemos while por enquanto.
A sintaxe (para não mencionar a lógica) é tão simples, que provavelmente você já deve ter adormecido. Contanto que algumas condições seja verdadeira, você fará algo dentro do bloco de loop. O bloco de loop é delimitado por um par de chaves; portanto, o que você quiser repetir terá que está dentro desse bloco.
A principal parte de um loop é o teste condicinal. Em Java, o teste condicional é uma expressão que resulta em um valor booleano – em outras palavras, algo que é verdadeiro ou falso.
Se você disser algo com “Enquanto (while) sorveteNoPote for verdadeiro, continue a atirar”, terá claramente um teste booleano. Há sorvete no pote ou não há. Mas se você dissesse “Enquanto Bob continuar a tirar”, não teria realmente um teste. Para fazer isso funcionar, você teria que alterar para algo como “Enquanto Bob estiver roncando...” ou “Enquanto Bob não estiver usando xadrez....”
A sintaxe (para não mencionar a lógica) é tão simples, que provavelmente você já deve ter adormecido. Contanto que algumas condições seja verdadeira, você fará algo dentro do bloco de loop. O bloco de loop é delimitado por um par de chaves; portanto, o que você quiser repetir terá que está dentro desse bloco.
A principal parte de um loop é o teste condicinal. Em Java, o teste condicional é uma expressão que resulta em um valor booleano – em outras palavras, algo que é verdadeiro ou falso.
Se você disser algo com “Enquanto (while) sorveteNoPote for verdadeiro, continue a atirar”, terá claramente um teste booleano. Há sorvete no pote ou não há. Mas se você dissesse “Enquanto Bob continuar a tirar”, não teria realmente um teste. Para fazer isso funcionar, você teria que alterar para algo como “Enquanto Bob estiver roncando...” ou “Enquanto Bob não estiver usando xadrez....”
O que você pode inserir no método main?
Quando você estiver dentro de main (ou de qualquer método), a diversão começará. Você pode inserir todas as coisas que costumam ser usadas na maioria das linguagens de programação para fazer o computador executar algo.
Seu código pode instruir a JVM a: (instruções , loops, Ramificação)
1) Fazer algo
Instrução: declarações, atribuições, chamadas de método, etc
/**
* @author thiago_azeredo
*/
public class Simples {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 3;
String name = "Dirk";
// A multiplicalçõ desse valor dará 51
x = x * 17;
// Irá imprimir no console
System .out.println(" x is " + x);
double d = Math.random();
System.out.println("Double -> " + d);
}
}
2) Fazer algo repetidamente
Loops: for e while
public class Loop {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//
int x = 20;
while (x > 12){
// irá rodar até x maior que 12
x = x - 1;
System.out.println("Print while !" + x);
}
for (x = 0; x < 10; x = x + 1){
System.out.println("x is now " + x);
}
}
}
3) Fazer algo sob essa condições
Ramificação: testes IF /else
/**
*
* @author thiago_azeredo
*/
public class Ramificacoes {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 1;
if (x == 10){
System.out.println(" Número de x é iqual a 10 ");
}else{
System.out.println("Número de x é diferente de 10 ");
}
String name = "drik";
if ((x < 3) & (name.equals("drik"))){
System.out.println("Gentil");
}
System.out.println("this line runs no matter what / esta linha não importa o que é executado");
}
ANALISE GERAL DESSE CÓDIGOS
A brincareira da sintexe !
- Cada instrução deve terminar com ponto-e-vírgula
x = x – 1;
- Um comentário de linha única começa com duas barras
x = 22;
// esta linha me incomoda ! he
- As variáveis são declaradas com um nome e tipo (Isso terá uma melhor explicação)
Int weight;
// tipo int, nome: weigth
- As classes e métodos devem ser definidos dentro de um par de chaves.
Public void GO( ) {
// o código entra aqui !
}
Seu código pode instruir a JVM a: (instruções , loops, Ramificação)
1) Fazer algo
Instrução: declarações, atribuições, chamadas de método, etc
/**
* @author thiago_azeredo
*/
public class Simples {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 3;
String name = "Dirk";
// A multiplicalçõ desse valor dará 51
x = x * 17;
// Irá imprimir no console
System .out.println(" x is " + x);
double d = Math.random();
System.out.println("Double -> " + d);
}
}
2) Fazer algo repetidamente
Loops: for e while
public class Loop {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//
int x = 20;
while (x > 12){
// irá rodar até x maior que 12
x = x - 1;
System.out.println("Print while !" + x);
}
for (x = 0; x < 10; x = x + 1){
System.out.println("x is now " + x);
}
}
}
3) Fazer algo sob essa condições
Ramificação: testes IF /else
/**
*
* @author thiago_azeredo
*/
public class Ramificacoes {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
int x = 1;
if (x == 10){
System.out.println(" Número de x é iqual a 10 ");
}else{
System.out.println("Número de x é diferente de 10 ");
}
String name = "drik";
if ((x < 3) & (name.equals("drik"))){
System.out.println("Gentil");
}
System.out.println("this line runs no matter what / esta linha não importa o que é executado");
}
ANALISE GERAL DESSE CÓDIGOS
A brincareira da sintexe !
- Cada instrução deve terminar com ponto-e-vírgula
x = x – 1;
- Um comentário de linha única começa com duas barras
x = 22;
// esta linha me incomoda ! he
- As variáveis são declaradas com um nome e tipo (Isso terá uma melhor explicação)
Int weight;
// tipo int, nome: weigth
- As classes e métodos devem ser definidos dentro de um par de chaves.
Public void GO( ) {
// o código entra aqui !
}
quarta-feira, 4 de fevereiro de 2009
Criando uma classe com um método main
Em Java, tudo é inserido em uma classe. Você criará seu arquivo de código-fonte (com extensão .java) e, em seguida, o converterá em um novo arquivo de classe (com extensão .class). Quando executar seu programa, na verdade estará executando uma classe.
Executar um programa significa informar à Java Virtual Machine (JVM) para “carregar a classe Hello e, em seguida, execute seu método main(). Continue executando até todo o código de main ter terminado.”
Come escrever um código Java de modo que ele seja executado? E tudo começa com o MAIN().
O método main() é onde seu programa começará a ser executado.
Independentemente do tamanho de seu programa (em outras palavras, não importa quantas classes o seu programa vai usar), é preciso que haja um método main() que dê início ao processo.
Executar um programa significa informar à Java Virtual Machine (JVM) para “carregar a classe Hello e, em seguida, execute seu método main(). Continue executando até todo o código de main ter terminado.”
Come escrever um código Java de modo que ele seja executado? E tudo começa com o MAIN().
O método main() é onde seu programa começará a ser executado.
Independentemente do tamanho de seu programa (em outras palavras, não importa quantas classes o seu programa vai usar), é preciso que haja um método main() que dê início ao processo.
quinta-feira, 29 de janeiro de 2009
Anatomia de uma classe
Quando a JVM começa a ser executado, procurará a classe que você forneceu na linha de comando. Em seguida, começará a procurar um método especialmente escrito que se pareça exatamente com:
public static void main (String[] args) {
// Seu código entra aqui !
}
OBS: ISSO É UMA CLASSE MAIN !!!!!!!!!!!!!!!!!
O que é uma class MAIN ???
Resposta: é a que será executada em um determinado projeto !
Depois a JVM executará tudo que estiver entre as chaves { } de seu método principal. Todo aplicativo Java precisa ter pelo menos uma class e um método main (não um método main por classe, apenas um por aplicativo).
public static void main (String[] args) {
// Seu código entra aqui !
}
OBS: ISSO É UMA CLASSE MAIN !!!!!!!!!!!!!!!!!
O que é uma class MAIN ???
Resposta: é a que será executada em um determinado projeto !
Depois a JVM executará tudo que estiver entre as chaves { } de seu método principal. Todo aplicativo Java precisa ter pelo menos uma class e um método main (não um método main por classe, apenas um por aplicativo).
quarta-feira, 28 de janeiro de 2009
O que existe em um método ?
Dentro das chaves de um método , escreva as instruções de como ele deve ser executado.O código do método é basicamente um conjunto de instruções, e por enquanto você pode considerar o método com se fosse uma função ou um preenchimento.
O que existe em uma classe ?
Uma classe tem um ou mais métodos. Na classe João (Dog) o método bark conterá instruções de como o cão deve latir ... bem o João (Exemplo abaixo). Seus métodos devem ser declarados dentro de uma classe ( em outras palavras, dentro das chaves da classe).
Arquivo- FONTE?
Um arquivo de código-fonte (com a extensão .java) contém uma definição de classe. A classe representa uma parte de seu programa,embora um aplicativo muito pequeno possa precisar apenas de uma classe. A classe deve ficar dentro de um par de chaves.
quinta-feira, 22 de janeiro de 2009
Exercício Java Aponte o Lápis 1
OBS: Esse código-fonte não funciona, contudo você começará a ter uma noção do que é a programação em Java e o que um linguagem orientada a objeto.
Abaixo está as respostas !
OBS: Ainda não é preciso se preocupar em entender tudo isso !
Tudo que se encontra aqui é explicado com maiores detalhes ...
Veja como é fácil escrever código JAVA !
Int size = 27; = Declara uma variável de tipo inteiro chamada “size” e lhe atribui o valor 27.
String name = “Figo”; = Declara um variável de string de caracteres chamada ‘name’ e lhe atribui o valor “Figo”.
Dog myDog = new Dog (name, size); = Declara a nova variável de tipo Dog chamada ‘myDog’ e cria o novo objetivo Dog usando ‘name’ e ‘size’.
X = size - 5; = subtrai 5 de 27 (valor de ‘size’) e atribui o valor a uma variável chamada ‘x’
While (x > 3) { = matém o loop até x ser maior que 3…
myDog.play(); = pede ao cão que brinque (independentemente do que isso signifique para um cão ...
} = aqui parece ser o fim do loop – tudo que estiver entre { } será feito no loop
Int [ ] numlist = {2,4,6,8}; = Declara a lista de variáveis de tipo inteiro ‘numList’ e insere 2, 4, 6, 8 nela.
System.out. print(“alô”); = exibe alô no console … provavelmente na linha de comando
String num = “8”; = Declara a variável de string de caracteres “num” e lhe atribui o valor “8”
Int z = Integer.parseInt(num); = Converte a string de “8” no valor numérico 8. Observe há uma diferença entre int e Interger .... explicarei mais a frente !
Try { = Tentar fazer algo... Pode ser que o que estaremos tentando não funcione ...
readTheFile(“myFile.txt”); = lê o arquivo de texto chamado “myFile.txt” (ou pelo menos TENTAR ler o arquivo…)
} = deve ser o fim das “tentativas“, portanto, acho que é possível tentar fazer muitas coisas ...
Catch (FileNotFoundException ex) { = aqui deve ser onde você saberá se o que tentou não funcionou...
System.out.print(“File not found.”); = Imprime o erro do console !
} = parece que tudo que se encontra entre { } é o que deve ser feito se a ‘tentativa’ não funcionar.
Abaixo está as respostas !
OBS: Ainda não é preciso se preocupar em entender tudo isso !
Tudo que se encontra aqui é explicado com maiores detalhes ...
Veja como é fácil escrever código JAVA !
Int size = 27; = Declara uma variável de tipo inteiro chamada “size” e lhe atribui o valor 27.
String name = “Figo”; = Declara um variável de string de caracteres chamada ‘name’ e lhe atribui o valor “Figo”.
Dog myDog = new Dog (name, size); = Declara a nova variável de tipo Dog chamada ‘myDog’ e cria o novo objetivo Dog usando ‘name’ e ‘size’.
X = size - 5; = subtrai 5 de 27 (valor de ‘size’) e atribui o valor a uma variável chamada ‘x’
While (x > 3) { = matém o loop até x ser maior que 3…
myDog.play(); = pede ao cão que brinque (independentemente do que isso signifique para um cão ...
} = aqui parece ser o fim do loop – tudo que estiver entre { } será feito no loop
Int [ ] numlist = {2,4,6,8}; = Declara a lista de variáveis de tipo inteiro ‘numList’ e insere 2, 4, 6, 8 nela.
System.out. print(“alô”); = exibe alô no console … provavelmente na linha de comando
String num = “8”; = Declara a variável de string de caracteres “num” e lhe atribui o valor “8”
Int z = Integer.parseInt(num); = Converte a string de “8” no valor numérico 8. Observe há uma diferença entre int e Interger .... explicarei mais a frente !
Try { = Tentar fazer algo... Pode ser que o que estaremos tentando não funcione ...
readTheFile(“myFile.txt”); = lê o arquivo de texto chamado “myFile.txt” (ou pelo menos TENTAR ler o arquivo…)
} = deve ser o fim das “tentativas“, portanto, acho que é possível tentar fazer muitas coisas ...
Catch (FileNotFoundException ex) { = aqui deve ser onde você saberá se o que tentou não funcionou...
System.out.print(“File not found.”); = Imprime o erro do console !
} = parece que tudo que se encontra entre { } é o que deve ser feito se a ‘tentativa’ não funcionar.
O que você fará em Java ?
Resposta: Você criará em arquivo de código-fonte, compilará usando o compilador javac e, em seguida, executará o bytecode compilado em uma máquina virtual Java.
1)Digite o código-fonte. E salve com jextenso.java (arquivo que irá ser compilado para gerar o bytecode).
OBS: Não precisa entender o código agora, contudo irá funcionar a rotina que imprime valor extenso. Não ache que vendo esse código você nunca irá aprender Java !
package valorextenso;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JOptionPane;
// Titulo: JExtenso
public class JExtenso {
private ArrayList nro;
private BigInteger num;
private String Qualificadores[][] = { { "centavo", "centavos" },
{ "", "" }, { "mil", "mil" }, { "milhão", "milhães" },
{ "bilhão", "bilhães" }, { "trilhão", "trilhães" },
{ "quatrilhão", "quatrilhães" }, { "quintilhão", "quintilhães" },
{ "sextilhão", "sextilhães" }, { "septilhão", "septilhães" } };
private String Numeros[][] = {
{ "zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete",
"oito", "nove", "dez", "onze", "doze", "treze", "quatorze",
"quinze", "desesseis", "desessete", "dezoito", "desenove" },
{ "vinte", "trinta", "quarenta", "cinquenta", "sessenta",
"setenta", "oitenta", "noventa" },
{ "cem", "cento", "duzentos", "trezentos", "quatrocentos",
"quinhentos", "seiscentos", "setecentos", "oitocentos",
"novecentos" } };
/**
* Construtor
*/
public JExtenso() {
nro = new ArrayList();
}
/**
* Construtor
*
* @param dec
* valor para colocar por extenso
*/
public JExtenso(BigDecimal dec) {
this();
setNumber(dec);
}
/**
* Constructor for the JExtenso object
*
* @param dec
* valor para colocar por extenso
*/
public JExtenso(double dec) {
this();
setNumber(dec);
}
/**
* Sets the Number attribute of the JExtenso object
*
* @param dec
* The new Number value
*/
public void setNumber(BigDecimal dec) {
// Converte para inteiro arredondando os centavos
num = dec.setScale(2, BigDecimal.ROUND_HALF_UP).multiply(
BigDecimal.valueOf(100)).toBigInteger();
// Adiciona valores
nro.clear();
if (num.equals(BigInteger.ZERO)) {
// Centavos
nro.add(new Integer(0));
// Valor
nro.add(new Integer(0));
} else {
// Adiciona centavos
addRemainder(100);
// Adiciona grupos de 1000
while (!num.equals(BigInteger.ZERO)) {
addRemainder(1000);
}
}
}
public void setNumber(double dec) {
setNumber(new BigDecimal(dec));
}
/**
* Description of the Method
*/
public void show() {
Iterator valores = nro.iterator();
while (valores.hasNext()) {
System.out.println(((Integer) valores.next()).intValue());
}
System.out.println(toString());
}
/**
* Description of the Method
*
* @return Description of the Returned Value
*/
public String toString() {
StringBuffer buf = new StringBuffer();
int numero = ((Integer) nro.get(0)).intValue();
int ct;
for (ct = nro.size() - 1; ct > 0; ct--) {
// Se ja existe texto e o atual não é zero
if (buf.length() > 0 && !ehGrupoZero(ct)) {
buf.append(" e ");
}
buf.append(numToString(((Integer) nro.get(ct)).intValue(), ct));
}
if (buf.length() > 0) {
if (ehUnicoGrupo())
buf.append(" de ");
while (buf.toString().endsWith(" "))
buf.setLength(buf.length() - 1);
if (ehPrimeiroGrupoUm())
buf. insert(0, "h");
if (nro.size() == 2 && ((Integer) nro.get(1)).intValue() == 1) {
buf.append(" real");
} else {
buf.append(" reais");
}
if (((Integer) nro.get(0)).intValue() != 0) {
buf.append(" e ");
}
}
if (((Integer) nro.get(0)).intValue() != 0) {
buf.append(numToString(((Integer) nro.get(0)).intValue(), 0));
}
return buf.toString();
}
private boolean ehPrimeiroGrupoUm() {
if (((Integer) nro.get(nro.size() - 1)).intValue() == 1)
return true;
return false;
}
/**
* Adds a feature to the Remainder attribute of the JExtenso object
*
* @param divisor
* The feature to be added to the Remainder attribute
*/
private void addRemainder(int divisor) {
// Encontra newNum[0] = num modulo divisor, newNum[1] = num dividido
// divisor
BigInteger[] newNum = num.divideAndRemainder(BigInteger
.valueOf(divisor));
// Adiciona modulo
nro.add(new Integer(newNum[1].intValue()));
// Altera numero
num = newNum[0];
}
/**
* Description of the Method
*
* @param ps
* Description of Parameter
* @return Description of the Returned Value
*/
private boolean temMaisGrupos(int ps) {
for (; ps > 0; ps--) {
if (((Integer) nro.get(ps)).intValue() != 0) {
return true;
}
}
return false;
}
/**
* Description of the Method
*
* @param ps
* Description of Parameter
* @return Description of the Returned Value
*/
private boolean ehUltimoGrupo(int ps) {
return (ps > 0) && ((Integer) nro.get(ps)).intValue() != 0
&& !temMaisGrupos(ps - 1);
}
/**
* Description of the Method
*
* @return Description of the Returned Value
*/
private boolean ehUnicoGrupo() {
if (nro.size() <= 3)
return false;
if (!ehGrupoZero(1) && !ehGrupoZero(2))
return false;
boolean hasOne = false;
for (int i = 3; i < nro.size(); i++) {
if (((Integer) nro.get(i)).intValue() != 0) {
if (hasOne)
return false;
hasOne = true;
}
}
return true;
}
boolean ehGrupoZero(int ps) {
if (ps <= 0 || ps >= nro.size())
return true;
return ((Integer) nro.get(ps)).intValue() == 0;
}
/**
* Description of the Method
*
* @param numero
* Description of Parameter
* @param escala
* Description of Parameter
* @return Description of the Returned Value
*/
private String numToString(int numero, int escala) {
int unidade = (numero % 10);
int dezena = (numero % 100); // * nao pode dividir por 10 pois
// verifica de 0..19
int centena = (numero / 100);
StringBuffer buf = new StringBuffer();
if (numero != 0) {
if (centena != 0) {
if (dezena == 0 && centena == 1) {
buf.append(Numeros[2][0] );
} else {
buf.append(Numeros[2][centena]);
}
}
if ((buf.length() > 0) && (dezena != 0)) {
buf.append(" e ");
}
if (dezena > 19) {
dezena /= 10;
buf.append(Numeros[1][dezena - 2]);
if (unidade != 0) {
buf.append(" e ");
buf.append(Numeros[0][unidade]);
}
} else if (centena == 0 || dezena != 0) {
buf.append(Numeros[0][dezena]);
}
buf.append(" ");
if (numero == 1) {
buf.append(Qualificadores[escala][0] );
} else {
buf.append(Qualificadores[escala][1] );
}
}
return buf.toString();
}
/**
* Para teste
*
* @param args
* numero a ser convertido
*/
public static void main(String[] args) {
double numero=Double.parseDouble(JOptionPane.showInputDialog("Entre com o valor"));
// if (args.length == 0) {
// System.out.println("Sintax : ...Extenso");
// return;
// }
/*JExtenso teste = new JExtenso(new BigDecimal(args[0] ));
System.out.println("Numero : "
+ (new DecimalFormat().format(Double.valueOf(args[0] ))));
System.out.println("JExtenso : " + teste.toString());
*/
JExtenso teste = new JExtenso(new BigDecimal(numero));
System.out.println("Numero : "
+ (new DecimalFormat().format(Double.valueOf(numero ))));
System.out.println("JExtenso : " + teste.toString());
}
}
2)Compilador
Compile o arquivo jextenso.java executando o javac (o aplicativo do compilador). Se não houver erros, você terá um segundo documento chamado jextenso.class. O arquivo jextenso.class gerado pelo compilador é composto de bytecodes.
3)Saída (Código) Bytecode
Código compilado: jextendo.class
4)Máquinas Virtuais
Execute o programa iniciado em Java Vitual Machine (JVM) com o arquivo jextendo.class. A JVM converterá o bytecode em algo que a plataforma ( Win, Linux, etc ) subjacente entenderá e executará seu programa.
1)Digite o código-fonte. E salve com jextenso.java (arquivo que irá ser compilado para gerar o bytecode).
OBS: Não precisa entender o código agora, contudo irá funcionar a rotina que imprime valor extenso. Não ache que vendo esse código você nunca irá aprender Java !
package valorextenso;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JOptionPane;
// Titulo: JExtenso
public class JExtenso {
private ArrayList nro;
private BigInteger num;
private String Qualificadores[][] = { { "centavo", "centavos" },
{ "", "" }, { "mil", "mil" }, { "milhão", "milhães" },
{ "bilhão", "bilhães" }, { "trilhão", "trilhães" },
{ "quatrilhão", "quatrilhães" }, { "quintilhão", "quintilhães" },
{ "sextilhão", "sextilhães" }, { "septilhão", "septilhães" } };
private String Numeros[][] = {
{ "zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete",
"oito", "nove", "dez", "onze", "doze", "treze", "quatorze",
"quinze", "desesseis", "desessete", "dezoito", "desenove" },
{ "vinte", "trinta", "quarenta", "cinquenta", "sessenta",
"setenta", "oitenta", "noventa" },
{ "cem", "cento", "duzentos", "trezentos", "quatrocentos",
"quinhentos", "seiscentos", "setecentos", "oitocentos",
"novecentos" } };
/**
* Construtor
*/
public JExtenso() {
nro = new ArrayList();
}
/**
* Construtor
*
* @param dec
* valor para colocar por extenso
*/
public JExtenso(BigDecimal dec) {
this();
setNumber(dec);
}
/**
* Constructor for the JExtenso object
*
* @param dec
* valor para colocar por extenso
*/
public JExtenso(double dec) {
this();
setNumber(dec);
}
/**
* Sets the Number attribute of the JExtenso object
*
* @param dec
* The new Number value
*/
public void setNumber(BigDecimal dec) {
// Converte para inteiro arredondando os centavos
num = dec.setScale(2, BigDecimal.ROUND_HALF_UP).multiply(
BigDecimal.valueOf(100)).toBigInteger();
// Adiciona valores
nro.clear();
if (num.equals(BigInteger.ZERO)) {
// Centavos
nro.add(new Integer(0));
// Valor
nro.add(new Integer(0));
} else {
// Adiciona centavos
addRemainder(100);
// Adiciona grupos de 1000
while (!num.equals(BigInteger.ZERO)) {
addRemainder(1000);
}
}
}
public void setNumber(double dec) {
setNumber(new BigDecimal(dec));
}
/**
* Description of the Method
*/
public void show() {
Iterator valores = nro.iterator();
while (valores.hasNext()) {
System.out.println(((Integer) valores.next()).intValue());
}
System.out.println(toString());
}
/**
* Description of the Method
*
* @return Description of the Returned Value
*/
public String toString() {
StringBuffer buf = new StringBuffer();
int numero = ((Integer) nro.get(0)).intValue();
int ct;
for (ct = nro.size() - 1; ct > 0; ct--) {
// Se ja existe texto e o atual não é zero
if (buf.length() > 0 && !ehGrupoZero(ct)) {
buf.append(" e ");
}
buf.append(numToString(((Integer) nro.get(ct)).intValue(), ct));
}
if (buf.length() > 0) {
if (ehUnicoGrupo())
buf.append(" de ");
while (buf.toString().endsWith(" "))
buf.setLength(buf.length() - 1);
if (ehPrimeiroGrupoUm())
buf. insert(0, "h");
if (nro.size() == 2 && ((Integer) nro.get(1)).intValue() == 1) {
buf.append(" real");
} else {
buf.append(" reais");
}
if (((Integer) nro.get(0)).intValue() != 0) {
buf.append(" e ");
}
}
if (((Integer) nro.get(0)).intValue() != 0) {
buf.append(numToString(((Integer) nro.get(0)).intValue(), 0));
}
return buf.toString();
}
private boolean ehPrimeiroGrupoUm() {
if (((Integer) nro.get(nro.size() - 1)).intValue() == 1)
return true;
return false;
}
/**
* Adds a feature to the Remainder attribute of the JExtenso object
*
* @param divisor
* The feature to be added to the Remainder attribute
*/
private void addRemainder(int divisor) {
// Encontra newNum[0] = num modulo divisor, newNum[1] = num dividido
// divisor
BigInteger[] newNum = num.divideAndRemainder(BigInteger
.valueOf(divisor));
// Adiciona modulo
nro.add(new Integer(newNum[1].intValue()));
// Altera numero
num = newNum[0];
}
/**
* Description of the Method
*
* @param ps
* Description of Parameter
* @return Description of the Returned Value
*/
private boolean temMaisGrupos(int ps) {
for (; ps > 0; ps--) {
if (((Integer) nro.get(ps)).intValue() != 0) {
return true;
}
}
return false;
}
/**
* Description of the Method
*
* @param ps
* Description of Parameter
* @return Description of the Returned Value
*/
private boolean ehUltimoGrupo(int ps) {
return (ps > 0) && ((Integer) nro.get(ps)).intValue() != 0
&& !temMaisGrupos(ps - 1);
}
/**
* Description of the Method
*
* @return Description of the Returned Value
*/
private boolean ehUnicoGrupo() {
if (nro.size() <= 3)
return false;
if (!ehGrupoZero(1) && !ehGrupoZero(2))
return false;
boolean hasOne = false;
for (int i = 3; i < nro.size(); i++) {
if (((Integer) nro.get(i)).intValue() != 0) {
if (hasOne)
return false;
hasOne = true;
}
}
return true;
}
boolean ehGrupoZero(int ps) {
if (ps <= 0 || ps >= nro.size())
return true;
return ((Integer) nro.get(ps)).intValue() == 0;
}
/**
* Description of the Method
*
* @param numero
* Description of Parameter
* @param escala
* Description of Parameter
* @return Description of the Returned Value
*/
private String numToString(int numero, int escala) {
int unidade = (numero % 10);
int dezena = (numero % 100); // * nao pode dividir por 10 pois
// verifica de 0..19
int centena = (numero / 100);
StringBuffer buf = new StringBuffer();
if (numero != 0) {
if (centena != 0) {
if (dezena == 0 && centena == 1) {
buf.append(Numeros[2][0] );
} else {
buf.append(Numeros[2][centena]);
}
}
if ((buf.length() > 0) && (dezena != 0)) {
buf.append(" e ");
}
if (dezena > 19) {
dezena /= 10;
buf.append(Numeros[1][dezena - 2]);
if (unidade != 0) {
buf.append(" e ");
buf.append(Numeros[0][unidade]);
}
} else if (centena == 0 || dezena != 0) {
buf.append(Numeros[0][dezena]);
}
buf.append(" ");
if (numero == 1) {
buf.append(Qualificadores[escala][0] );
} else {
buf.append(Qualificadores[escala][1] );
}
}
return buf.toString();
}
/**
* Para teste
*
* @param args
* numero a ser convertido
*/
public static void main(String[] args) {
double numero=Double.parseDouble(JOptionPane.showInputDialog("Entre com o valor"));
// if (args.length == 0) {
// System.out.println("Sintax : ...Extenso
// return;
// }
/*JExtenso teste = new JExtenso(new BigDecimal(args[0] ));
System.out.println("Numero : "
+ (new DecimalFormat().format(Double.valueOf(args[0] ))));
System.out.println("JExtenso : " + teste.toString());
*/
JExtenso teste = new JExtenso(new BigDecimal(numero));
System.out.println("Numero : "
+ (new DecimalFormat().format(Double.valueOf(numero ))));
System.out.println("JExtenso : " + teste.toString());
}
}
2)Compilador
Compile o arquivo jextenso.java executando o javac (o aplicativo do compilador). Se não houver erros, você terá um segundo documento chamado jextenso.class. O arquivo jextenso.class gerado pelo compilador é composto de bytecodes.
3)Saída (Código) Bytecode
Código compilado: jextendo.class
4)Máquinas Virtuais
Execute o programa iniciado em Java Vitual Machine (JVM) com o arquivo jextendo.class. A JVM converterá o bytecode em algo que a plataforma ( Win, Linux, etc ) subjacente entenderá e executará seu programa.
quarta-feira, 21 de janeiro de 2009
Como funciona o Java ?
O objetivo é escrever um aplicativo (neste exemplo, um convite de festa interativo) e fazê-lo funcionar em qualquer dispositivo que seus amigos tiverem.
Assinar:
Postagens (Atom)
