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.
Assinar:
Postagens (Atom)
