Baixe apostilajava e outras Notas de estudo em PDF para Cultura, somente na Docsity!
AUTOR (ERA SÓ O QUE FALTAVA)...
Fábio Burch Salvador
O PRIMEIRO E ÚNICO
LOUCADEMIA
DE JAVA
J2SE
OU
ENCICLOPEDIAE JAVALISTICUS UNIVERSALIS
UM GUIA PARA QUEM NÃO SABE NADA DA LINGUAGEM JAVA, MAS QUER
APRENDER. VOCÊ COMEÇA A LER APENAS COM CONHECIMENTOS BEM
BÁSICOS EM LÓGICA DA PROGRAMAÇÃO, E TERMINA A LEITURA
DESENVOLVENDO SISTEMAS EMPRESARIAIS COMPLETOS – SÓ QUE VAI
DAR TRABALHO, CLARO!
ENTÃO, SE VOCÊ ESTIVER AFIM DE VAGABUNDAGEM, VÁ TENTAR UMA
CARREIRA POLÍTICA OU ALGO ASSIM. OU VIRE HIPPIE.
Loucademia de Java – Versão 1.
“Homem de preto, qual é a
sua missão?”
“É aprender logo Java e tirar
Certificação!”
“Homem de preto, o que é
que você faz?”
“Escrevo um código fonte
que apavora o Satanás!”
Powered by
Luisius
WWW.FABIOSALVADOR.COM.BR - Página 2
Loucademia de Java – Versão 1.
O autor – quem é esse cara?
Fábio Burch Salvador nasceu em 1981, em Porto Alegre. É viciado em
informática desde guri, mais precisamente desde o dia em que colocou
as mãos em um XT na firma onde o pai trabalhava. Programador desde
os 13 anos (o pai tinha um 286) começou no Basic desenvolvendo
Games cabulosos tirando sarro de amigos e conhecidos. Mais tarde,
evoluiu, desenvolvendo então outras coisas medonhas em outras
linguagens. Mas também desenvolveu muita coisa boa, sistemas
empresariais principalmente - e apostilas!
Programa Basic, VB, JavaScript, Pascal, PHP, Java. Monta sites
escrevendo HTML e CSS no Bloco de Notas. Aprendeu Flash sozinho. E
também Photoshop, Corel Draw, SQL, e tudo mais. Incrivelmente, tem apenas um curso - de AutoCAD (?) - ele que
rodou na sétima série exatamente por não saber nada de geometria e nem a Fórmula de Báskhara (que ele aliás não
domina até hoje).
É formado em Jornalismo desde 2005 pela PUC de Porto Alegre. Por quê logo Jornalismo? Ninguém sabe. Nem ele.
Apaixonado pelas câmeras, teve até uma curta carreira como cineasta, dirigindo 4 curtas-metragens, todos dignos de um
Cine Trash.
Defensor implacável do DOS nos anos 90, acabou rendendo-se. Pródigo em criar bordões, Fábio criou frases de efeito
que ficaram na História de todos os lugares pode onde passou. Iniciou sua vida profissional "pegando" uma série de
empregos variados, mais ou menos no estilo Seu Madruga. Foi, entre outras coisas, digitador de cadastro nas Lojas
Renner, técnico de fiscalização da Anatel, estagiário na Prefeitura de Porto Alegre, monitor de laboratório na PUC, e só
não foi astronauta porque o Brasil não tinha programa espacial.
Em 2004, fundou um pasquim em Viamão/RS chamado "A Cidade". O jornal sagrou-se como o mais polêmico no
município, tinha o desenho mais estiloso e foi o primeiro a ter um site. Bagunçou a vida dos políticos locais e estampou
manchetes gritantes em capas surrealistas até seu fechamento no início de 2006. Fábio então passou a colaborar no "de-
vez-em-quandário" Correio Viamonense, outro pasquim ainda mais mefítico do que o primeiro. Virou sub-celebridade
local e passou a ser sistematicamente convidado pelos partidos políticos em tudo que é eleição.
Ainda buscando uma carreira de comunicador, tentou a sorte na redação do site Terra, como redador temporário. Em
seguida, cansou-se de nunca ter grana para nada e resolveu abandonar o jornalismo. Voltou a dedicar-se à informática.
Deu o arriscado passo da troca de carreira e acertou na mosca.
Como desenvolvedor de softwares, sua falta de instrução formal na área foi facilmente esquecida por todos os que o
empregaram porque, afinal de contas, seus programas funcionam.
Agraciado com o Prêmio McGyver da Programação, Fábio foi professor no Senac em São Leopoldo, ensinando sua arte
softwarística e tornando seus alunos tão pirados quanto ele. Acabou também ensinando design, liderança, oratória,
administração e outras coisas mais. Saiu do Senac por vontade própria em 2008 para dedicar-se a programar em turno
integral. Não que não goste de dar aulas. Teve seu$ motivo$ pe$$oai$.
Desde o começo e sempre, teve principalmente a ajuda indispensável de seus pais, que sempre o incentivaram a ir em
frente e até a levantar nas inúmeras vezes em que caiu. Mais tarde, iria somar-se neste esforço de apoio sua namorada
que virou esposa. Apesar de serem todos pessoas bem mais "normais" e discretas do que o autor deste livro, sempre
tentaram compreendê-lo. Ele que por vezes é incompreensível. E que incompreensivelmente conseguiu achar seu
caminho na vida.
Fábio é casado, tem uma filha, é um gaúcho urbano criado na Capital e nunca andou a cavalo. Não sabe tocar gaita. E
não usa pilcha. Mas sabe assar churrasco, provando mais uma vez que a conveniência é a mãe da sabedoria.
Continua programando, atuando na área do ensino e dedica-se também a escrever. E ainda por cima mantém seu "lado
jornalista" vivo no site que mantém na Internet e cujo jabá já foi feito neste livro. Projeta carros espalhafatosos em
AutoCAD 3D (e publica os projetos na Internet). Às vezes, filosofa. Também mete-se na política. E até escreve sobre
teologia.
Ainda não plantou uma árvore. Mas já teve um filho. E agora acaba de escrever um livro.
WWW.FABIOSALVADOR.COM.BR - Página 4
Fábio Burch Salvador
Agradecimentos
Este livro não teria sido escrito sem a ajuda de algumas pessoas. Em primeiro lugar, quero agradecer à minha esposa Fabiana por me aturar nos tempos em que passei concentrado escrevendo, à minha filha Camila por me trazer bolachinhas e beijos enquanto eu escrevo, aos meus pais que sempre me apoiaram e no final são os verdadeiros responsáveis por eu estar aqui hoje escrevendo. Ao meu cunhado Ismael por consertar meu PC nas vezes em que ele apresentou problemas. À minha sogra por me aturar. Ao meu sobrinho Raphael por me alegrar, e à minha irmã Ângela por ter crescido ao meu lado e ter participado de quase todos os momentos mais importantes da minha vida. Novamente à minha mãe por sempre me dar força e ao meu pai por me incentivar a aprender Basic.
Também quero homenagear meus alunos do Senac, tanto a galera do Java e do PHP, sempre formando turmas de pessoas divertidas, o que me estimulava a aprender mais para ensinar mais. E também à gurizada da Aprendizagem Comercial: Manu, Luan, Douglas, Alemão, Frajola, Tainara, Francine, Alisson, Elvis, Pri, e todo o resto da gurizada medonha. Ah, e claro, a Deize que veio da capital tecnológica do mundo Ocidental, Crissiumal. Essa gurizada, com seu jeito barulhento e impulsivo, acabou tornando a mim mesmo mentalmente mais jovem (o papel de professor estava a envelhecer-me aos poucos) e me fez ver que eu não poderia acomodar-me tão cedo, que deveria ser mais confiante e construir meu futuro com ambições maiores e, no fim, causaram eles mesmos a perda de seu professor de todas as tardes.
Também homenageio aos colegas do Senac, a Raquel, o Alexandre, o Antonio, o Alisson, a Pati, a Su, e todos os outros malucos que dividiram comigo um ano absolutamente divertido e edificante. E, claro, ao Nelson e à Carla, que na direção da escola souberam lidar com pessoas como, por exemplo, eu – o que sei ser uma missão casca-grossa.
Mando também um alô especial para a galera do Espiral, da WaySys, da Memo e de todos os lugares onde eu pude desenvolver sistemas, aprimorando-me no decorrer do caminho.
Também quero agradecer a Steve Wozniak, que inventou o computador pessoal. Ao Bill Gates, por ter criado um sistema operacional simplesmente maravilhoso. E ao Linus Torvalds pelo mesmo motivo.
Quero agradecer a Jesus Cristo, sem o qual nós hoje seríamos Zoroastristas ou mais provavelmente Mitraístas – se não fôssemos uns tribais animistas dançando seminus em vota de uma pedra e sacrificando virgens ao deus Dagon – quando se sabe que virgens têm outra utilidade bem melhor.
Não posso também deixar de agradecer a mim mesmo, pessoa sem a qual este texto não se auto-escreveria sozinho.
E quero agradecer a vocês, que já leram umas quantas páginas e ainda não viram nada de Java. Mas verão, e não se arrependerão. Então, vamos ao Java!
Página 5 - WWW.FABIOSALVADOR.COM.BR
Dejair, Clauber,
Pozzebon e eu -
turma de
Java em 2007
Luis, Michel, Bruno,
Mauricio, Sergio e
Diego (faltou o
lendário Daniel)
Java de 2008
- Loucademia de Java – Versão 1.
- Prefácio.................................................................................................................................................... Índice
- PreDifícil...................................................................................................................................................
- O autor – quem é esse cara?..................................................................................................................
- Agradecimentos......................................................................................................................................
- Índice........................................................................................................................................................
- Nomenclaturas e badulaques.................................................................................................................
- Java a JavaScript.....................................................................................................................................................
- O que é uma API......................................................................................................................................................
- J2SE, J2EE e J2ME.................................................................................................................................................
- Java Virtual Machine (JVM).....................................................................................................................................
- Java Developer Kit (JDK).........................................................................................................................................
- O que é uma IDE......................................................................................................................................................
- Palavras Reservadas...............................................................................................................................................
- Coleta automática de lixo.......................................................................................................................................
- Classes e objetos..................................................................................................................................
- Explicação Wikipédica............................................................................................................................................
- Explicação “no popular”..........................................................................................................................................
- Padrões básicos de programação Java..............................................................................................
- Principais tipos de dados.......................................................................................................................................
- Usando chaves.......................................................................................................................................................
- Fazendo cálculos....................................................................................................................................................
- Comparações.........................................................................................................................................................
- Concatenando condições.......................................................................................................................................
- Montando um programa simples.........................................................................................................
- Sintaxes principais................................................................................................................................
- Laços de repetição.................................................................................................................................................
- Estruturas condicionais..........................................................................................................................................
- Aplicando Orientação a Objetos..........................................................................................................
- Instanciando uma classe........................................................................................................................................
- Herança..................................................................................................................................................................
- Polimorfismo...........................................................................................................................................................
- Modificadores .......................................................................................................................................
- Static.......................................................................................................................................................................
- Public......................................................................................................................................................................
- Private.....................................................................................................................................................................
- Final........................................................................................................................................................................
- Protected................................................................................................................................................................
- Pacotes...................................................................................................................................................
- Tratamento de erros e exceções..........................................................................................................
- Throw – informado os erros à classe que instanciou o objeto...............................................................................
- Tipos de Excessão.................................................................................................................................................
- Escrevendo dados em arquivos textos e lendo eles de volta............................................................
- Tokenizer (caracteres separadores)......................................................................................................................
- Métodos da classe StringTokenizer:......................................................................................................................
- Tocando sons em Java.........................................................................................................................
- A classe Console...................................................................................................................................
- Sobrepondo métodos – uma técnica essencial.....................................................................................................
- Interface gráfica em Java......................................................................................................................
- Bibliotecas AWT e SWING.....................................................................................................................................
- Nossa primeira tela................................................................................................................................................. - WWW.FABIOSALVADOR.COM.BR - Página
- JLabel..................................................................................................................................................................... Fábio Burch Salvador
- JButton....................................................................................................................................................................
- JTextField...............................................................................................................................................................
- JFormattedTextField...............................................................................................................................................
- JToggleButton........................................................................................................................................................
- Icon.........................................................................................................................................................................
- JOptionPane...........................................................................................................................................................
- Tipos de mensagem:..............................................................................................................................................
- showConfirmDialog................................................................................................................................................
- showOptionDialog..................................................................................................................................................
- showInputDialog.....................................................................................................................................................
- JMenuBar, JMenu e JMenuItem............................................................................................................................
- JCheckBox.............................................................................................................................................................
- JRadioButton..........................................................................................................................................................
- JComboBox............................................................................................................................................................
- JTabbedPane.........................................................................................................................................................
- JScrollPane............................................................................................................................................................
- JTables...................................................................................................................................................................
- JFileChooser..........................................................................................................................................................
- JInternalFrame.......................................................................................................................................................
- Tree........................................................................................................................................................................
- Eventos (Listeners)...............................................................................................................................
- ActionListener.........................................................................................................................................................
- FocusListener.........................................................................................................................................................
- KeyEvent................................................................................................................................................................
- MouseListener........................................................................................................................................................
- Uma coleção de pequenos comandos soltos.....................................................................................
- Leitura de dimensões de componentes gráficos e da própria tela........................................................................
- Conversão de dados..............................................................................................................................................
- Fazendo uma JFrame sumir, morrer e derrubar o programa................................................................................
- Relações com o setDefaultCloseOperation...........................................................................................................
- Ordenando a uma JFrame que abra em modo maximizado.................................................................................
- Redimensionando imagens para caberem dentro da JLabel................................................................................
- Colocando uma imagem de plano de fundo dentro do JDesktopPane.................................................................
- Conexão Java + Banco de Dados........................................................................................................
- Criando a aplicação integrada................................................................................................................................
- Consultando o Banco de Dados.............................................................................................................................
- Gravando no BD (Insert e Update).........................................................................................................................
- Java + MySQL........................................................................................................................................................
- A aplicação Java com MySQL integrado...............................................................................................................
- Nota sobre componentes de conexão baixados da Web......................................................................................
- Criando formulários de impressão com IReport.................................................................................
- Colocando dados no Report...................................................................................................................................
- Montando grupos....................................................................................................................................................
- Testando o Report..................................................................................................................................................
- Botões do IReport...................................................................................................................................................
- Trabalhando com variáveis..................................................................................................................................
- Como integrar o JasperReport ao programa Java............................................................................
- Compilando o projeto depois de pronto............................................................................................
- Extras...................................................................................................................................................
- Como chamar um outro programa EXE...............................................................................................................
- Usando impressoras matriciais diretamente........................................................................................................
- Gerando um relatório com Códigos de Barra......................................................................................................
- Como ler um código de barras.............................................................................................................................
Loucademia de Java – Versão 1.
Nomenclaturas e badulaques
Vamos ver agora um pequeno glossário de coisas que precisamos saber antes de começar.
Java a JavaScript
A primeira confusão que existe no mundo Java é entre a linguagem Java e o JavaScript. Vamos ver isso de forma bem clara e objetiva:
JAVA é uma linguagem completa, enorme e complexa utilizada para montar aplicações completas com acesso a Bancos de Dados constante e fins mais completos. Programar Java exige alguma prática, e é exatamente para ensinar Java que eu escrevi este livro.
O código JAVA deve ser desenvolvido, testado e depois convertido em Byte-Code, em uma operação de compilação. O código torna-se então ilegível e o usuário não tem acesso às fontes que deram origem às funcionalidaes.
JAVASCRIPT é uma pequena linguagem de scripts usados dentro do código HTML de um site e que executam pequenas tarefas a serem executadas do lado do cliente na conexão via Internet. O código é aberto e as funcionalidades raramente passam de pequenas validações de campos em formulários HTML ou efeitos de animação limitados.
A única coisa legal sobre o JavaScript, do ponto de vista do programador Java, é que as sintaxes dos comandos são iguais. Laços de repetição, funções e outros badulaques têm a mesma forma de escrever que os da linguagem Java.
O que é uma API
Uma API é uma coleção de componentes de software que já vêm prontos e o programa só precisa usar. Muita gente fala das APIs do Windows, pois é possível chamar estas APIs nos programas. Nós vamos usar uma API do sistema operacional, lá no final do livro.
Vamos criar um arquivo PDF, e daí vamos rodar uma API que identificará qual o programa que o Windows do usuário está utilizando para abrir este tipo de arquivo.
A API do Java é uma coleção imensa, absurdamente imensa, de classes reutilizáveis com as mais bizarramente variadas utilidades. Temos, por exemplo, as classes da bibliotecas JAVA.AWT e JAVA.SWING, que servem para criarmos telas gráficas de apresentação para o nosso usuário. Temos a JAVA.IO, com suas classe usadas para manipular entrada e saída de dados, por exemplo, para arquivos-texto. Enfim.
As APIs nos economizam tempo, porque não precisamos criar as coisas “do zero”, fazendo um movimento semelhante a reinventar a roda. Não. Nós vamos usar tudo o que já vier pronto e desenvolver nossos softwares sem, por exemplo, ter que reinventar o botão clicável.
J2SE, J2EE e J2ME
São denominações que damos a três caminhos para o desenvolvimento de aplicações na linguagem Java.
J2SE (Standard Edition) consiste em criar classes, montando um programa executável, construindo a interface gráfica do programa nessas classes. No final, compila-se o código e temos um arquivo JAR, que funciona como um executável em qualquer computador devidamente preparado. Usa-se para fazer softwares desktop, que operam na tela do computador normalmente.
J2EE (Enterprise Edition) consiste em criar alguns códigos em arquivos JSP e construir umas classes. Parece muito com a programação J2SE. Porém a interface gráfica é feita com o uso de páginas HTML. Estas páginas têm FORMS cujo botão de ativação aciona as funcionalidades feitas em Java. É usado para desenvolver para a Web.
J2ME (Micro Edition) é parecido com o desenvolvimento J2SE, mas não se pode usar uma série de
WWW.FABIOSALVADOR.COM.BR - Página 8
Loucademia de Java – Versão 1.
Coleta automática de lixo
Java é uma linguagem para lá de inteligente. Surgiu em 1995, e veio com essa história de lixo. O que é isso?
Simples! Nas linguagens de antigamente, nós criávamos a variável X e precisávamos, quando não mais a quiséssemos usar, destruí-la para desocupar memória. No Java, isso não acontece. Quando X deve cair fora, ela cai.
E mais: se antes a variável X ficava com lixo das atribuições de valor anteriores, hoje ao colocar um valor novo nela, ela é automaticamente limpa.
No fim, ficou muito mais fácil gerenciar memória.
WWW.FABIOSALVADOR.COM.BR - Página 10
Não precisa se preocupar
com suas variáveis
fantasmas. Eu guardo elas
para você!
Fábio Burch Salvador
Classes e objetos
O que vem a ser uma classe? Uma classe é aquilo que será instanciado para a criação de objetos. Não entendeu nada? Vamos então à explicação acadêmica para essa coisa toda:
Explicação Wikipédica
Em orientação a objeto, uma classe abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.
Classes não são diretamente suportadas em todas as linguagens, e são necessárias para que uma linguagem seja orientada a objetos. Classes são os elementos primordiais de um diagrama de classes.
Estrutura da classe
Uma classe define estado e comportamento de um Objeto geralmente implementando métodos e atributos (nomes utilizados na maioria das linguagens modernas). Os atributos, também chamados de campos (do inglês fields), indicam as possíveis informações armazenadas por um objeto de uma classe, representando o estado de cada objeto. Os métodos são procedimentos que formam os comportamentos e serviços oferecidos por objetos de uma classe.
Outros possíveis membros de uma classe são:
Construtores - definem o comportamento no momento da criação de um objeto de uma classe.
Destrutor - define o comportamento no momento da destruição do objeto de uma classe. Normalmente, como em C++, é utilizado para liberar recursos do sistema (como memória).
Propriedades - define o acesso a um estado do objeto.
Eventos - define um ponto em que o objeto pode chamar outros procedimentos de acordo com seu comportamento e estado interno.
Encapsulamento
Em linguagens orientadas a objetos, é possível encapsular o estado de um objeto. Em termos práticos, isso se realiza limitando o acesso a atributos de uma classe exclusivamente através de seus métodos. Para isso, as linguagens orientadas a objeto oferecem limitadores de acesso para cada membro de uma classe.
Tipicamente os limitadores de acesso são:
público (public) - o membro pode ser acessado por qualquer classe. Os membros públicos de uma classe definem sua interface.
protegido (protected) - o membro pode ser acessado apenas pela própria classe e suas sub-classes.
privado (private) - o membro pode ser acessado apenas pela própria classe.
Cada linguagem de programação pode possuir limitadores de acesso próprios. Por exemplo, em Java, o nível de acesso padrão de um membro permite que qualquer classe de seu pacote (package) possa ser acessado. Em C#, o limitador de acesso interno (internal) permite que o membro seja acessado por qualquer classe do Assembly (isto é, da biblioteca ou executável).
Página 11 - WWW.FABIOSALVADOR.COM.BR
Fábio Burch Salvador
Bom. Temos então a variável P, armazenando nossa PESSOA, o “Joãozinho”, com 30 anos, Homem.
Agora, vamos fazer o programa executar um método do objeto P:
P.ANIVERSARIO();
Ao executar este método, o P vai auto-aumentar sua idade em 1 ano, ficando com 31 anos.
Acontece que P é um OBJETO do tipo PESSOA. Ele não está armazenado dentro da CLASSE PESSOA, ele foi gerado a partir dela, mas existe de forma independente.
Depois disso, vou criar outro objeto, o P2, que também é uma PESSOA:
P2 = Nova PESSOA;
P2.NOME = “Claudinei”;
P2.IDADE = 20;
P2.SEXO = “Homem”;
Temos então agora:
Joãozinho – Homem – 31 anos
Claudinei – Homem – 20 anos
Se eu mandar que o objeto P2 execute um método:
P2.ANIVERSARIO();
Então agora, P2 aumentou sua idade em 1 ano. Ele tem 21 anos. Mas a idade de P continua em 31.
E se eu ordenar que:
P2.CIRURGIA_NO_MARROCOS();
Então P2 mudará seu sexo para “Transexual”, embora P não sofra conseqüência alguma.
Para entender:
P e P2 são independentes. Eles podem fazer aniversário em épocas diferentes, um deles pôde trocar de sexo, e as funções executadas por um não vão afetar o outro. Eles são, contudo, semelhantes porque ambos têm os mesmos 3 atributos e 2 métodos, embora cada um armazene atributos com valores diferentes e execute seus métodos de forma completamente independente.
Por quê é interessante trabalhar com Orientação a Objetos?
Porque eu posso criar a mesma classe PESSOA que eu criei no exemplo anterior, e criar um VETOR (se você não lembra o que é isso, volte a consultar o material de Lógica da Programação).
Vetor V[100] de PESSOA (vai armazenar até 100 objetos do tipo PESSOA).
V[0].NOME = “Fredegundeson”;
V[1].NOME = “Godofredilson”;
V[2].NOME = “Juvenal Antena”;
V[3].NOME = “Mendigo Pop”;
Página 13 - WWW.FABIOSALVADOR.COM.BR
Loucademia de Java – Versão 1.
E assim por diante...
Aliás, é este o mecanismo usado pelos carrinhos de compras dos sites de e-commerce: existe uma classe PRODUTO que determina que todo produto vai ter certos atributos (preço, tipo, descrição, etc.), e terá alguns métodos (somar_frete, adicionar_ao_carrinho, e assim por diante). E daí o programa alimenta um Vetor de PRODUTOs e vai guardando na memória, sem envolver gravação de Banco de Dados.
No final, quando o usuário resolve efetivar a compra, há a gravação de um dado efetivamente, sendo então os dados armazenados no vetor de objetos dentro da base de dados.
Em Java, tudo é classe e objeto
Em Java, até o próprio programa principal, aquele que roda e faz o resto das classe se mexer, é uma classe ele próprio, e o código central do software é um método. Veremos depois como fazer um programa funcional.
Você vai ter que criar classes para tudo e usar objetos de um monte de classes. A interface gráfica, por exemplo, usa uma classe chamada JFrame. A JFrame é uma classe que vem com a JDK e que monta janelinhas no estilo Windows. Esta classe tem atributos (cor de fundo, tamanho, etc.). Então, eu crio um objeto a partir dela e manipulo estes atributos para obter a aparência que eu quiser para o meu programa.
Se você ainda não entendeu nada
Não fique preocupado. Quem não tem facilidade para a teoria muitas vezes tem para a prática. Vamos então começar a trabalhar.
WWW.FABIOSALVADOR.COM.BR - Página 14
Loucademia de Java – Versão 1.
Comparações
Em Java, faremos algumas comparações de valores entre variáveis. Então, devemos conhecer os sinais usados:
X == Y X é igual a Y X != Y X é diferente de Y X < Y X é menor que Y X > Y X é maior que Y X <= Y X é menor ou igual a Y X >=Y X é igual ou maior do que Y
Concatenando condições
Eu posso exigir que, para alguma coisa ser executada, duas ou mais condições sejam verdadeiras. Para isso, uso a concatenação das condições utilizando principalmente três sinais:
&& If ((Condição1) && (Condição2)) { Será verdadeiro se a primeira condição for verdadeira e a segunda também for. Caso alguma delas falhe, toda a expressão será FALSE.
Exemplo: SE ((TIVER SOL) && (EU ESTIVER COM GRANA)) { VOU À PRAIA }
Ou seja, se fizer sol mas eu estiver “duro”, não vou à praia. Se eu tiver dinheiro e chover, eu também não vou. Só vou se estiver com dinheiro e fizer sol. || If ((Condição1) || (Condição2)) { Será verdadeiro se qualquer das condições for verdadeira, mesmo que a outra não seja.
Exemplo: SE ((HOUVER UM ÔNIBUS) || (ARRUMAR CARONA)) { EU VOU }
Ou seja, se eu arrumar um jeito de viajar, seja ele qual for, eu vou viajar. XOR If ((Condição1) && (Condição2)) { Será verdadeiro se uma, e apenas uma, das condições for verdadeira.
Exemplo: SE ((ELE É GAY) XOR (ELE É MULHER)) { ELE GOSTA DE HOMEM }
Ou seja, para gostar de homem, OU o sujeito é gay, OU é mulher. Se for mulher E gay, nada feito – é lésbica e não gosta de homem. Se não for mulher nem gay, então é homem heterossexual e não gosta de homem.
WWW.FABIOSALVADOR.COM.BR - Página 16
Fábio Burch Salvador
Montando um programa simples
Antes de mais nada, vamos ver um pequeno diagrama que mostra como funciona o esquema que eu tentei explicar nos textos que lemos até agora:
Agora, vamos montar um programa finalmente. Abra a sua IDE e vamos começar a escrever.
Desde os anos 80, há uma tradição que diz que o primeiro software desenvolvido por qualquer pessoa é o famoso “Olá Mundo”. Nós vamos fazer um pouco diferente. Nosso primeiro programa exibirá na tela uma frase que não seja essa tradicional, pois já está muito manjada.
Então, vamos lá:
public class prog { public static void main (String[]args) { System.out.println("Minha vingança será maligna!"); } }
O programa acima é simplíssimo. Na primeira linha, eu crio a classe PROG. Na segunda, inicio o método MAIN, que será o principal do nosso programa. Não se preocupe em entender as palavras PUBLIC, STATIC e VOID pois há um farto material sobre isso mais adiante neste mesmo livro (ver Modificadores). O método chamado MAIN é sempre rodado como principal, por um padrão existente na linguagem Java.
Depois, eu tenho uma chamada à classe SYSTEM.OUT, que lida com saídas de dados para o sistema. Eu rodo o método PRINTLN, que significa “mande essa frase para o prompt e quebre a linha”, sendo que eu passei uma frase para ele exibir. Pronto! Temos um programa funcional!
Página 17 - WWW.FABIOSALVADOR.COM.BR
Fábio Burch Salvador
Estruturas condicionais
IF
O uso da instrução IF nos permite fazer algumas escolhas, o que é bem interessante. Estruturas condicionais equivalem á instrução SE do Português Estruturado que você deve ter visto em Lógica da Programação.
Um IF funciona de forma simples. Eu coloco dentro de parênteses a condição que deve ser verdadeira para que eu execute o código que está dentro do bloco IF.
Um exemplo de código que, executando, não satisfará à condição do IF e portanto não fará nada:
public class prog { public static void main (String[]args) { int x = 5; if (x == 4) { System.out.println("Se esta linha aparecer, algo muito errado foi digitado!"); } } }
ELSE
O Else significa “senão”, e é usado em um IF para dar comandos que acontecerão caso a condição do IF não seja atendida.
No programa de exemplo, eu coloquei o valor FALSE em uma variável boolean que determina se um sujeito é viado ou não. Se ele for, uma mensagem é exibida. SENÃO, outra dizendo “Muy Macho” aparecerá.
public class prog { public static void main (String[]args) { boolean viado = false; if (viado == true) { System.out.println("Ah, viadão!"); } else { System.out.println("HUm, muy macho!"); }
} }
Página 19 - WWW.FABIOSALVADOR.COM.BR
TRUE ou
FALSE, eis a
questão!
Loucademia de Java – Versão 1.
ELSE IF
O Else If é usado para colocarmos uma alternativa dirigida dentro de uma estrutura condicional. É o caso, por exemplo, do seguinte sistema:
Eu vou cadastrar ali, em uma String, que tipo de político um determinado deputado é. Vou ter várias opções listadas com ELSEIF, e finalmente, no finalzinho, um ELSE para servir caso a opção marcada seja “Nenhuma das Anteriores”.
public class prog { public static void main (String[]args) { String falcatrua = "Dossiê"; if (falcatrua == "Mensalão") { System.out.println("Esse é do Mensalão!"); } else if (falcatrua == "Dossiê") { System.out.println("Esse é da turma do Dossiê!"); } else if (falcatrua == "Bolsa-Esmola") { System.out.println("Esse é Populistão!"); } else { System.out.println ("Ainda não descobriram o que o cara faz"); } } }
SWITCH
O SWITCH é um comando usado para descobrir dentre várias opções o que deve acontecer. Um exemplo:
// Antes, o programa pergunta ao usuário qual opção, entre 1 e 3, ele quer ver. Int x = // A escolha do usuário Switch (x) { case 1: System.out.println(“Você escolheu 1”); break; case 2: System.out.println(“Você escolheu 2”); break; case 3: System.out.println(“Você escolheu 3”); break; default: System.out.println(“Nenhuma das anteriores”); } Onde os Breaks fazem a execução parar e o programa passa a executar o que vem imediatamente após o Switch. Já o Default é o que acontece se nenhuma das opções válidas for escolhida.
WWW.FABIOSALVADOR.COM.BR - Página 20
