apostila introducao a linguagem java

Introdução á Linguagem de Programação JAVA

[email protected]

www.primebean.com.brwww.primebean.com.br/joeydecurcio

http://www.primebean.com.br/

mailto:[email protected]

http://Www.primebean.com.br/

http://www.primebean.com.br/joeydecurcio


Introdução á Linguagem de Programação Java por Joey Decurcio

Edição de 31/03/2014

© 2014 Primebean – Soluções em TecnologiaMultiplataforma. Todos os direitos reservados.

O Conteúdo desta apostila foi elaborada através depesquisas realizadas via internet, livros, revistas, etc.

Primebean – Soluções em Tecnologia [email protected]+55 (18) 99111-0896



mailto:[email protected]

http://Www.primebean.com.br/



Sumário1. Introdução.........................................................................................................................................1

1.1 Oque é Java................................................................................................................................11.2 Histórico.....................................................................................................................................11.3. Padronização.............................................................................................................................31.4. Principais Características da Linguagem Java..........................................................................31.5. Máquina Virtual Java................................................................................................................41.6. Extensões..................................................................................................................................61.7. Frameworks..............................................................................................................................71.8. Ambientes de desenvolvimento................................................................................................71.9. Certificações.............................................................................................................................81.10. Comunidade............................................................................................................................91.11. Licença....................................................................................................................................91.12. O que é necessário para programar em JAVA.........................................................................9

2. Desenvolvendo o Primeiro Programa em Java...............................................................................112.1. public class MeuPrimeiroPrograma........................................................................................122.2. public static void main............................................................................................................122.3. (String[ ] args).........................................................................................................................132.4. Inicio e Fim { }.......................................................................................................................132.5. System.out.println...................................................................................................................132.6. ("Bem vindo ao mundo Java!")...............................................................................................13

3. Regras e convenções de nomenclatura...........................................................................................143.1. Nome de Classes.....................................................................................................................153.2. Nome de Pacotes.....................................................................................................................153.3. Criando Pacotes......................................................................................................................163.4. Definindo Pacotes...................................................................................................................173.5. Importando Pacotes.................................................................................................................173.6. importando um pacote usamos o comando import.................................................................183.7. Nome de atributos ou variáveis..............................................................................................193.8. Nome de atributos finais ou constantes..................................................................................193.9. Tipos de dados e declaração de atributos................................................................................203.10. Atribuição de Valores a Variáveis ou Atributos....................................................................223.11. Inicialização de variáveis ou atributos..................................................................................223.12. Método de Saída Padrão.......................................................................................................253.13. Controle de Texto..................................................................................................................263.14. Apresentando valores de variáveis ou atributos....................................................................273.15. Concatenação........................................................................................................................28

3.15.1. Cuidados ao concatenar.................................................................................................30





3.16. Operadores e Processos........................................................................................................314. Controle de Fluxo...........................................................................................................................32

4.1. Execução condicional - IF e ELSE.........................................................................................334.2.1. Usando IF........................................................................................................................334.2.2. Usando ELSE..................................................................................................................34

4.3. Switch, Case e Default............................................................................................................354.3.1. Default.............................................................................................................................36

4.4. Break e Continue....................................................................................................................374.4.1. Break...............................................................................................................................384.4.2. Continue..........................................................................................................................38

4.3. Estruturas de Repetição..........................................................................................................394.3.1. While....................................................................................................................................404.3.2. Do While..............................................................................................................................414.3.3. For........................................................................................................................................41

5. O que são e para que servem as Classes e Objetos.........................................................................435.1. O que são Classes e Objetos em Java.....................................................................................435.2. Utilidade das Classes e Objetos em Java................................................................................44

5.2.1. Agrupar coisas semelhantes............................................................................................445.2.2. Crie uma vez, use quantas vezes quiser..........................................................................455.2.3. Altere uma parte do código, e a mudança se propagará em todo o código.....................455.2.4. Classe à parte, vida à parte..............................................................................................455.2.5.Como saber quando usar Classes e Objetos em Java.......................................................46

5.3. Criação de Classe....................................................................................................................475.4. Métodos Construtores.............................................................................................................48

6. Estrutura de Dados.........................................................................................................................496.1. Vetores e Matrizes...................................................................................................................526.2. Vetor........................................................................................................................................53

6.2.1 Inicialização direta de Vetor.............................................................................................556.3. Matrizes..................................................................................................................................556.4. ArrayList.................................................................................................................................56

6.4.1. O que são ArrayList em Java..........................................................................................576.4.2. Como declarar e usar ArrayList em Java........................................................................586.4.3. Exemplo de uso do ArrayList..........................................................................................58

7. Constantes.......................................................................................................................................618. Funções...........................................................................................................................................63

8.1. Criando funções sem argumentos...........................................................................................638.2. Funções com argumentos........................................................................................................648.3. Funções que retornam valores................................................................................................65

9. Igualdade de Objetos em java - equals() e hashCode()..................................................................679.1. Equals:....................................................................................................................................699.2. HashCode:...............................................................................................................................71

10. Representação textual de objetos - método toString()..................................................................73





11. Instanciando Objetos....................................................................................................................7612. Auto Referencia de Objetos - This...............................................................................................7713. Sobrecarga de métodos.................................................................................................................7814. Acesso a Membros e Métodos......................................................................................................8115. Encapsulamento - public, private e protected...............................................................................84

15.1. Public....................................................................................................................................8515.2. Private...................................................................................................................................8615.3. Protected...............................................................................................................................8615.4. Sem Modificador (Padrão)....................................................................................................8615.5. Métodos Acessores - Getters e Setters..................................................................................87

15.5.1. Set..................................................................................................................................8715.5.2. Get.................................................................................................................................8815.5.3. Is....................................................................................................................................88

16. Herança.........................................................................................................................................8917. Enum.............................................................................................................................................9318. Interfaces......................................................................................................................................98

18.1. Usando uma Interface em uma Classe..................................................................................9819. Annotations.................................................................................................................................102

19.1. Uso de Annotations.............................................................................................................10219.2. Criando uma Annotation.....................................................................................................10319.3. Adicionar Annotations ao Javadoc......................................................................................105

20. Classes Abstratas e Métodos Abstratos......................................................................................10521. Polimorfismo..............................................................................................................................11022. Typecast - Casting.......................................................................................................................112

22.1. Typecast de Dados Primitivos.............................................................................................11322.2. Typecast de Classes e Objetos.............................................................................................114

23. Instanceof....................................................................................................................................11624. Generics......................................................................................................................................117

24.1.Criando classes usando generics..........................................................................................11724.2. Instanciar uma classe genérica............................................................................................119

25. Exceções.....................................................................................................................................12125.1. Try e Catch..........................................................................................................................12125.2. Finally.................................................................................................................................122

26. Classes Numéricas......................................................................................................................12426.1. Obtendo Tipo Primitivo de um Objeto Numérico..............................................................12526.2. Comparando Números........................................................................................................12626.7. Classes Integer, Float, Short, Byte, Long e Double............................................................126

26.7.1. Análise de Dados.........................................................................................................12626.7.2. Conversão Para String.................................................................................................128

26.8. Classe Math.........................................................................................................................12826.8.1. Constantes...................................................................................................................12926.8.2. Máximo e Mínimo......................................................................................................130





26.8.3. Potências e raízes........................................................................................................13026.8.4. Logaritmo....................................................................................................................13126.8.5. Arredondamentos e Valores Absolutos........................................................................13226.8.6. Trigonometria..............................................................................................................13326.8.7. Números Randômicos.................................................................................................134

27. String..........................................................................................................................................13527.1. Concatenação de Strings.....................................................................................................13727.2. Tamanho da string - length()...............................................................................................13724.3. Letras Maiúsculas e Minúsculas.........................................................................................13824.4. Comparação........................................................................................................................13824.5. Início e fim..........................................................................................................................14024.6. Caracter na posição.............................................................................................................14124.7. Índice da String...................................................................................................................14124.8. Substituir string ou parte dela.............................................................................................14224.9. Verificar conteúdo da string................................................................................................14324.10. Dividindo em vários vetores ou arrays.............................................................................14324.11. Substring...........................................................................................................................144

25. Manipulando datas em Java........................................................................................................14525.1. Date(java.util.Date).............................................................................................................14625.3. DateFormat(java.text.DateFormat).....................................................................................148

26. Uma Introdução à API Swing.....................................................................................................15126.1. JoptionPane.........................................................................................................................15126.2. Caixas de Diálogo Input Text.............................................................................................15226.3. Caixas de Diálogo Confirm................................................................................................15326.4. Caixa de Diálogo de Mensagem.........................................................................................15426.5. Input Dialogs.......................................................................................................................156

26.5.1. Obter valor de showInputDialog.................................................................................15826.5.2. Input Dialog com lista de opções................................................................................159




Introdução á Linguagem de Programação JAVA 1

1. Introdução

1.1 Oque é Java

Java é uma linguagem de programação orientada a objeto desenvolvida na década

de 90 por uma equipe de programadores chefiada por James Gosling, na empresa Sun

Microsystems. Diferentemente das linguagens convencionais, que são compiladas para

código nativo, a linguagem Java é compilada para um "bytecode" que é executado por

uma máquina virtual. A linguagem de programação Java é a linguagem convencional

da Plataforma Java, mas não sua única linguagem.

1.2 Histórico

Em 1991, na Sun Microsystems, foi iniciado o Green Project, o berço do Java, uma

linguagem de programação orientada a objetos. Os mentores do projeto eram Patrick

Naughton, Mike Sheridan, e James Gosling. O objetivo do projeto não era a criação de

uma nova linguagem de programação, mas antecipar e planejar a “próxima onda” do

mundo digital. Eles acreditavam que, em algum tempo, haveria uma convergência dos

computadores com os equipamentos e eletrodomésticos comumente usados pelas

pessoas no seu dia-a-dia.

Para provar a viabilidade desta idéia, 13 pessoas trabalharam arduamente durante

18 meses. No verão de 1992 eles emergiram de um escritório de Sand Hill Road no Menlo

Park com uma demonstração funcional da idéia inicial. O protótipo se chamava *7 (leia-se

“StarSeven”), um controle remoto com uma interface gráfica touchscreen. Para o *7, foi

criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho do

Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o

equipamento.





O *7 tinha a habilidade de controlar diversos dispositivos e aplicações. James

Gosling especificou uma nova linguagem de programação para o *7. Gosling decidiu

batizá-la de “Oak”, que quer dizer carvalho, uma árvore que ele podia observar quando

olhava pela sua janela. O próximo passo era encontrar um mercado para o *7. A equipe

achava que uma boa idéia seria controlar televisões e vídeo por demanda com o

equipamento. Eles construíram um demo chamado MovieWood, mas infelizmente era

muito cedo para que o vídeo por demanda bem como as empresas de TV a cabo

pudessem viabilizar o negócio.

A idéia que o *7 tentava vender, hoje já é realidade em programas interativos e

também na televisão digital. Permitir ao telespectador interagir com a emissora e com a

programação em uma grande rede cabos, era algo muito visionário e estava muito longe

do que as empresas de TV a cabo tinham capacidade de entender e comprar. A idéia

certa, na época errada.

Entretanto, o estouro da Internet aconteceu e rapidamente uma grande rede

interativa estava se estabelecendo. Era este tipo de rede interativa que a equipe do *7

estava tentando vender para as empresas de TV a cabo. E, da noite para o dia, não era

mais necessário construir a infra-estrutura para a rede, ela simplesmente estava lá.

Gosling foi incumbido de adaptar o Oak para a Internet e em janeiro 1995 foi lançada uma

nova versão do Oak que foi rebatizada para Java. A tecnologia Java tinha sido projetada

para se mover por meio das redes de dispositivos heterogêneos, redes como a Internet.

Agora aplicações poderiam ser executadas dentro dos browsers nos Applets Java e

tudo seria disponibilizado pela Internet instantaneamente. Foi o estático HTML dos

browsers que promoveu a rápida disseminação da dinâmica tecnologia Java. A velocidade

dos acontecimentos seguintes foi assustadora, o número de usuários cresceu

rapidamente, grandes fornecedores de tecnologia, como a IBM anunciaram suporte para

a tecnologia Java.

Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais

rapidamente do que qualquer outra linguagem de programação na história da





computação. Em 2003 Java atingiu a marca de 4 milhões de desenvolvedores em todo

mundo. Java continuou crescendo e hoje é uma referência no mercado de

desenvolvimento de software. Java tornou-se popular pelo seu uso na Internet e hoje

possui seu ambiente de execução presente em web browsers, mainframes, SOs,

celulares, palmtops e cartões inteligentes, entre outros.

1.3. Padronização

Em 1997 a Sun Microsystems tentou submeter a linguagem a padronização pelos

orgãos ISO/IEC e ECMA, mas acabou desistindo. Java ainda é um standard de fato, que

é controlada através da JCP Java Community Process. Em 13 de Novembro de 2006, a

Sun lançou a maior parte do Java como Software Livre sob os termos da GNU General

Public License (GPL). Em 8 de Maio de 2007 a Sun finalizou o processo, tornando

praticamente todo o código Java como software de código aberto, menos uma pequena

porção que a Sun não possui copyright.

1.4. Principais Características da Linguagem Java

A linguagem Java foi projetada tendo em vista os seguintes objetivos:

• Orientação a objeto - Baseado no modelo de Smalltalk e Simula67;

• Portabilidade - Independência de plataforma - "write once run anywhere";

• Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperação com

protocolos TCP/IP, como HTTP e FTP;

• Segurança - Pode executar programas via rede com restrições de execução;

Além disso, podem-se destacar outras vantagens apresentadas pela linguagem:





• Sintaxe similar a Linguagem C/C++.

• Facilidades de Internacionalização - Suporta nativamente caracteres Unicode;

• Simplicidade na especificação, tanto da linguagem como do "ambiente" de execução

(JVM);

• É distribuída com um vasto conjunto de bibliotecas (ou APIs);

• Possui facilidades para criação de programas distribuídos e multitarefa (múltiplas linhas

de execução num mesmo programa);

• Desalocação de memória automática por processo de coletor de lixo (garbage collector);

• Carga Dinâmica de Código - Programas em Java são formados por uma coleção de

classes armazenadas independentemente e que podem ser carregadas no momento de

utilização.

1.5. Máquina Virtual Java

Programas Java não são traduzidos para a linguagem de máquina,como outras

linguagens estaticamente compiladas e sim para uma representação intermediária,

chamada de bytecodes.

Os bytecodes são interpretados pela máquina virtual Java (JVM - Java Virtual

Machine). Muitas pessoas acreditam que por causa desse processo, o código interpretado

Java tem baixo desempenho. Durante muito tempo esta foi uma afirmação verdadeira.

Porém novos avanços têm tornado o compilador dinâmico (a JVM), em muitos

casos, mais eficiente que o compilador estático.

Java hoje já possui um desempenho próximo do C++. Isto é possível graças a

otimizações como a compilação especulativa, que aproveita o tempo ocioso do

processador para pré-compilar bytecode para código nativo. Outros mecanismos ainda

mais elaborados como o HotSpot da Sun, que guarda informações disponíveis somente

em tempo de execução (ex.: número de usuários, processamento usado, memória

disponível), para otimizar o funcionamento da JVM, possibilitando que a JVM vá





"aprendendo" e melhorando seu desempenho. Isto é uma realidade tão presente que hoje

é fácil encontrar programas corporativos e de missão crítica usando tecnologia Java. No

Brasil, por exemplo, a maioria dos Bancos utiliza a tecnologia Java para construir seus

home banks, que são acessados por milhares de usuários diariamente.

Grandes sítios como o eBay utilizam Java para garantir alto desempenho. E a cada

ano Java tem se tornado mais rápido, na medida que se evolui o compilador dinâmico.

Essa implementação no entanto tem algumas intrínsecas. A pré-compilação exige

tempo, o que faz com que programas Java demorem um tempo significativamente maior

para começarem a funcionar. Soma-se a isso o tempo de carregamento da máquina

virtual. Isso não é um grande problema para programas que rodam em servidores e que

deveriam ser inicializados apenas uma vez. No entanto isso pode ser bastante indesejável

para computadores pessoais onde o usuário deseja que o programa rode logo depois de

abri-lo.

A próxima versão da máquina virtual produzida pela Sun promete novos recursos

que irão minimizar este fato. O Java ainda possui uma outra desvantagem considerável

em programas que usam bastante processamento numérico. O padrão Java tem uma

especificação rígida de como devem funcionar os tipos numéricos. Essa especificação

não condiz com a implementação de pontos flutuantes na maioria dos processadores o

que faz com que o Java seja significativamente mais lento para estas aplicações quando

comparado a outras linguagens.

Os bytecodes produzidos pelos compiladores Java podem ser usados num

processo de engenharia reversa para a recuperação do programa-fonte original. Esta é

uma característica que atinge em menor grau todas as linguagens compiladas. No entanto

já existem hoje tecnologias que "embaralham" e até mesmo criptografam os bytecodes

praticamente impedindo a engenharia reversa.





1.6. Extensões

Extensões em Java:

• J2SE (Standard Edition)

• J2EE (Enterprise Edition)

• J2ME (Micro-Edition for PDAs and cellular phones)

• JCE (Java Cryptography Extension)

• JMF (Java Media Framework)

• JNDI (Java Naming and Directory Interface)

• JSML (Java Speech API Markup Language)

• JDBC (Java Database Connectivity)

• JMS (Java Message Service)

• JAAS (Java Authentication and Authorization Service)

• JDO (Java Data Objects)

• JAIN (Java API for Integrated Networks)

• JDMK (Java Dynamic Management Kit)

• Jini (a network architecture for the construction of distributed systems)

• Jiro

• JXTA (open source-based peer-to-peer infrastructure)

• Java Card

• JavaSpaces

• JMI (Java Metadata Interface)

• JMX (Java Management Extensions)

• JSP (JavaServer Pages)

• JSF (JavaServer Faces)

• JNI (Java Native Interface)

• J3D (A high level API for 3D graphics programming)





• JOGL (A low level API for 3D graphics programming, using OpenGL)

• OSGi (Dynamic Service Management and Remote Maintenance)

• SuperWaba (JavaVMs for handhelds)

• MARF (Modular Audio Recognition Framework)

• JavaFX

1.7. Frameworks

É possível utilizar frameworks para facilitar o desenvolvimento de aplicações.

Dentre os mais utilizados pode-se destacar:

• Hibernate ferramenta para ORM;

• Spring ferramenta que auxilia principalmente implementação de injeção de

dependências e inversão de controle;

• Log4j ferramenta para facilitar a criação de logs na aplicação;

• Junit ferramenta para auxiliar na criação de testes unitários;

• Struts controlador MVC (Model 2) web.

• JSF – Framework para desenvolvimento WEB MVC – Atual Especificação Java

1.8. Ambientes de desenvolvimento

É possível desenvolver aplicações em Java através de vários ambientes de

desenvolvimento integrado (IDE's). Dentre as opções mais utilizadas pode-se destacar:

• Eclipse — um projeto aberto iniciado pela IBM;

• NetBeans — um ambiente criado pela empresa Sun Microsystems;





• JBuilder — um ambiente desenvolvido pela empresa Borland;

• JDeveloper — uma IDE desenvolvida pela empresa Oracle;

• JCreator — um ambiente desenvolvido pela Xinox.

• BlueJ — um ambiente desenvolvido por uma faculdade australiana(muito bom para

iniciantes).

• Greenfoot — bem parecido com o BlueJ

• JGRASP — bom para intermediários, feito pela equipe do projeto GRASP.

• IntelliJ IDEA — uma IDE desenvolvida pela JetBrains (considerada por muitos a melhor

IDE do mercado).

1.9. Certificações

A linguagem Java está consolidada entre as mais utilizadas em todo mundo, com

ela podemos desenvolver diversos tipos de sistemas, dos mais simples aos mais robustos

funcionando em diferentes plataformas. Uma ótima maneira conseguir uma oportunidade

nesse mercado tão promissor é conhecendo a fundo como a linguagem funciona, e uma

certificação Java com certeza é um ótimo caminho para isso.

Os benefícios que uma certificação pode trazer são muitos, na visão do mercado

um profissional certificado comprova não só proficiência na tecnologia, mas também

outras qualidades como disciplina, autodidatismo e dedicação além de é claro

diferenciação em relação a outros candidatos com experiência equivalente.

Embora a valorização do seu currículo no mercado seja muito importante, o

benefício maior será o aprendizado que você será capaz de adquirir para ser um bom

profissional. Alguns pontos que podem ser destacados em relação ao aprendizado que





essa certificação pode trazer são:

•Melhor entendimento de orientação a objetos;

•Melhor capacidade de analisar e resolver problemas;

•Melhor qualidade de código;

•Conhecimento diferenciado da linguagem Java.

1.10. Comunidade

A comunidade de desenvolvedores Java reúne-se em grupo denominados JUGs

(Java User Groups). No Brasil o movimento de grupos de usuários expandiu-se bastante

e tem formado alguns dos maiores grupos de usuários Java do mundo, como por exemplo

o PortalJava e o GUJ.

1.11. Licença

A Sun disponibiliza a maioria das distribuições Java gratuitamente e obtém receita

com programas mais especializados como o Java Enterprise System. Em 13 de novembro

de 2006, Sun liberou partes de Java como software livre, sob a licença GNU General

Public License (GPL).

1.12. O que é necessário para programar em JAVA

Para programar em Java, não é necessário ter programado antes. Porém, ficaria

mais fácil se tiver conhecimento em linguagem Orientada a Objeto, porque Java é

totalmente estruturada em objetos (Classes, métodos, abstração, etc).





Para começar a programar será necessário fazer o download do JDK (Java

Development Kit - Kit de desenvolvimento Java) que é gratuito e pode ser obtido direto do

site da Oracle, a Oracle comprou a Sun Microsystem e atualmente mantém a tecnologia

Java.

Além disso, também, um compilador de Java. Existem vários tipos, uns mais leves

e simples e outros mais pesados e complexos de usar. Se não souber qual usar, verifique

a lista abaixo.

Para baixar os compiladores ou para mais informações, clique no nome do compilador.

Nome Gratuito Descrição

Eclipse sim

Eclipse é uma IDE de código aberto desenvolvido inicialmentepela IBM e posteriormente doada para a comunidade do sofwarelivre. Utilizada largamente, tem grandes diferenciais como apossibilidade de instalação de vários plug-ins. Uma versão emportuguês é mantida no site oficial que é conhecida como EclipseEuropa.

JBuilder sim

JBuilder é uma IDE para desenvolvimento de aplicações maisgráficas, a partir de JFames. O JBuilder foi desenvolvido pelaBorland (a mesma que produz o C++ Builder) utilizandotecnologias da comunidade do Eclipse Europa. O site CodeGearque faz a distribuição dos softwares da Borland mantém duasversões: uma Enterprise (pago) e a versão trial (mais básica,porém gratuita). O problema maior do JBuilder é para quem nãotem internet de banda larga, pois os arquivos de downloadschegam a exagerados 1,8 Gb.

JEdit sim

JEdit é um Ambiente de Desenvolvimento Integrado criado pela Xinox Software com o núcleo desenvolvido por Slava Pestov. Atualmente, distribuído sobre a licença GPL 2.0 (software livre) tem uma interface mais limpa e simples que outras IDEs, bom para quem está começando.

JDeveloper sim

IDE desenvolvido pela Oracle. Cobre todo processo de produçãodo software em java, desde o desenvolvimento do código até aimplantação do software. Oferece uma ótima estrutura de UMLcom diagramação do código.


http://www.oracle.com/technetwork/developer-tools/jdev/downloads/index.html

http://www.jedit.org/index.php?page=download

http://www.codegear.com/products/jbuilder

https://www.eclipse.org/downloads/

http://www.oracle.com/

http://www.oracle.com/technetwork/pt/java/javase/downloads/jdk7-downloads-1880260.html




NetBeans sim

O compilador que faz parte da própria gama de produtos da SunMicrosystems. Com capacidade de programação em váriosambientes como C++, Desenvolvimento para sofwares de celular(mobile), Ruby on Rails e vários outros. Netbeans é umaferramenta de desenvolvimento Java poderosa, mas todo estepoder requer uma máquina não muito modesta.

Então, mãos à obra, instale um compilador e comece seu projeto.

2. Desenvolvendo o Primeiro Programa em Java

Veremos aqui o nosso primeiro código em linguagem Java. A única coisa que esse

programa faz é imprimir (mostrar) na tela uma mensagem dizendo: Bem vindo ao mundo

Java!.

//Primeiro programa em Java public class MeuPrimeiroPrograma { public static void main(String[] args) { System.out.println("Olá, Mundo!"); } }

Primeiramente, iremos entender algumas estruturas básicas da linguagem.

//

Usamos // para indicar que foi iniciado um comentário. Um comentário serve

apenas para documentar o código. Isso quer dizer que, ao ser executado este programa,

as linhas marcadas como comentário serão ignoradas.

Este tipo de comentário é de linha única, ou seja, começa nas barras e termina no

final da linha. Se quisermos criar comentário de várias linhas podemos utilizar /* */, no


https://netbeans.org/downloads/




qual /* inicia o comentário e */ termina.

Por exemplo:

//Este é um comentário de uma linha

/*Este um é um comentário

de várias

linhas*/

2.1. public class MeuPrimeiroPrograma

public class MeuPrimeiroPrograma é a criação da classe. Como Java é totalmente

orientado a objeto, sua programação é feita dentro de classes e mais classes. O assunto

de classes será abordado mais afrente. O importante a princípio é entender que o

programa para funcionar deve ter pelo menos uma classe com o método principal (main).

2.2. public static void main

public static void main é o método principal do código. Quando executamos um

programa é esse método que é chamado. Em outras palavras, sem ele não há programa.





2.3. (String[ ] args)

(String[] args) é o argumento passado ao método main. Qualquer programa pode

ser iniciado ou não com argumentos que modificam sua execução, trataremos

futuramente de argumentos com programas.

2.4. Inicio e Fim { }

As chaves são usadas para marcar o inicio e o fim de um bloco de dados. No caso

deste algorítmo, ele marca o código que será executado na classe MeuPrimeiroPrograma

e também todo o código que será executado quando o método main for chamado.

2.5. System.out.println

System.out.println é a saída padrão de Java. É este método que indica o que deve

aparecer na tela.

2.6. ("Bem vindo ao mundo Java!")

("Bem vindo ao mundo Java!") é o argumento do método System.out.println. Neste

caso é o que deve ser apresentado na tela.

Toda linha de comando em Java termina com um ponto-e-vírgula (;).





Bem, isso é o necessário para começarmos a programar em Java. Logicamente,

muitos conceitos foram deixados de lado nesta pequena prévia, mas veremos mais

aprofundadamente nas próximas páginas.

3. Regras e convenções de nomenclatura

Quando programamos em Java, devemos levar em consideração as convenções

de nomenclatura para deixar nosso código o mais legível e documentável possível, pois

um dos objetivos da programação orientada a objetos é o reaproveitamento do código.

É muito provável que quem não tenha experiência com programação sinta

dificuldade de identificar todos os termos utilizados neste artigo, mas garantimos que tudo

que será visto aqui será detalhado mais adiante, embora que este artigo se torna trivial a

medida que programamos. Portanto, quem já conhece programação em algum outro tipo

de linguagem (como Delphi ou C++) aconselhamos que prossiga para a próxima página.

Porém, se nunca programou antes, com certeza, este artigo será didático o

suficiente para que entenda essas regras. Muitos compiladores como Eclipse e NetBeans

dão um grande auxilio na hora de criarmos nosso projeto nos informando sobre as

convenções de nomenclatura no momento que estamos criando os pacotes, classes,

etc...





3.1. Nome de Classes

Por convenção, toda classe deve começar com uma letra maiúscula e, de

preferência, não pode conter letras não ASCII (caracteres de língua de origem latina,

como caracteres acentuados). Portanto, não é possível declarar uma classe com qualquer

caracter especial (@, #, $, %, &, *, _, etc...) ou número.

Caso o nome de uma classe seja composto por mais de uma palavra, a primeira

letra de cada palavra deve ser em maiúscula. O nome da classe deve ser exatamente o

mesmo nome de seu arquivo fonte ( .java ).

O nome da classe deve fazer referência total ao seu objeto (atributos e métodos

contidos dentro da classe).

Por exemplo: se tivermos uma classe com os atributos canal, volume e sintonia; e

os métodos mudarCanal (), aumentarVolume () e diminuirVolume (); então, possivelmente

chamaríamos esta classe de TV ou Televisao. Contudo, em uma classe que contivesse o

atributo corDasPenas e o método voar () jamais chamaríamos de Pessoa (por que

pessoas não tem penas e nem voam).

Exemplos de nomes de classes: Pessoa, ImpostoDeRenda, Conta,

AgenciaDeEmprego, ...

3.2. Nome de Pacotes

O padrão da sun para dar nome aos pacotes é relativo ao nome da empresa que

desenvolveu a classe:

br.com.nomedaempresa.nomedoprojeto.subpacote

br.com.nomedaempresa.nomedoprojeto.subpacote2





br.com.nomedaempresa.nomedoprojeto.subpacote2.subpacote3

Os pacotes só possuem letras minúsculas, não importa quantas palavras estejam

contidas nele. Esse padrão existe para evitar ao máximo o conflito de pacotes de

empresas diferentes.

Usamos pacotes para organizar as classes semelhantes. Pacotes, a grosso modo,

são apenas pastas ou diretórios do sistema operacional onde ficam armazenados os

arquivos fonte Java e são essenciais para o conceito de encapsulamento, no qual são

dados níveis de acesso as classes.

PS: Java possui um pacote padrão que é utilizado quando programamos. As classes do

pacote padrão de bibliotecas não seguem essa nomenclatura, que foi dada para

bibliotecas de terceiros.

O nome do pacote deve fazer referência total às funções exercidas pelas classes

dentro do pacote, pois pacotes servem basicamente para organizar os arquivos de código

fonte de nosso projeto.

Exemplos de nomes de pacotes:

br.com.nomedaempresa.nomedoprojeto.criptografia;

br.com.nomedaempresa.nomedoprojeto.entidade;

br.com.nomedaempresa.nomedoprojeto.dao;

3.3. Criando Pacotes

Muitas IDE's criam automaticamente os pacotes como uma forma eficaz de

organização, mas a criação de pacote pode ser feita diretamente no sistema operacional.

Basta que criemos uma pasta e lhe demos um nome. Após isso, devemos gravar todos os

arquivos fonte de java dentro desta pasta.





3.4. Definindo Pacotes

Agora que já possuímos a pasta que será nosso pacote, devemos definir em nossa

classe a qual pacote ela pertence. Isso é feito pela palavra reservada package. Package

deve ser a primeira linha de comando a ser compilada de nossa classe.

Portanto, se tivéssemos criado uma sequencia de pastas: br.com.primebean e

fossemos criar uma classe nesta pasta (pacote), o começo de nosso código seria:

br.com.primebean;.

3.5. Importando Pacotes

Java possui vários pacotes com outros pacotes internos e várias classes já prontas

para serem utilizadas. Dentre os pacotes Java podemos determinar dois grandes pacotes:

o pacote java, que possui as classes padrões para o funcionamento do algorítmo; e o

pacote javax, que possui pacotes de extensão que fornecem classes e objetos que

implementam ainda mais o pacote java.

Exemplo: o pacote AWT (Abstract Windowing Toolkit) possui as classes necessárias para

se criar um ambiente gráfico API (Janelas) e está fortemente ligado as funções nativas do

Sistema Operacional, ou seja, ele pertence ao pacote java. Mas, o pacote SWING não é

ligado fortemente as funções nativas do Sistema Operacional, mas as funções do AWT, ou

seja, SWING complementa o AWT, portanto SWING faz parte do pacote de extensão

javax.

Para utilizar as milhares de classes contidas nos inúmeros pacotes de Java

devemos ou nos referenciar diretamente a classe ou importá-la.





3.6. importando um pacote usamos o comando import.

Para separar um pacote de seu sub-pacote usamos um ponto (como no acesso a

membros de classe). Ao importarmos um pacote podemos utilizar um coringa, o asterísco

(*). O asterísco serve para importar todos os sub-pacotes e classes do pacote que está

definido.

Ex.: import java.awt.*;. Isso importará todos os sub-pacotes pertencentes ao pacote AWT.

Ou podemos definir diretamente qual pacote desejamos.

Ex.: import javax.swing.JoptionPane;.

Isso irá importar apenas o sub-pacote JOptionPane do pacote SWING.

A diferença entre as duas formas de importação de pacotes é o consumo de

recursos do computador. Como o asterisco importa todos os sub-pacotes, o consumo de

memória será alto e, muito provavelmente, não usaremos todas as classes de todos os

pacotes importados. Por isso, o recomendado é sempre importar apenas o pacote que

será utilizado.

Para consolidar o que foi visto até aqui, o código abaixo ilustra o uso de pacotes.

package br.com.primebean.mensagem; import javax.swing.JOptionPane;

public class Mensagem { public static void main (String args[]){ JoptionPane.showMessageDialog(null, "Bem vindo ao mundo de Java!"); }}

A classe acima está no pacote br.com.primebean.mensagem. No nosso programa

estamos utilizando o método showMessageDialog que pertence à classe JOptionPane

que está no pacote de extensão SWING que tivemos que importar.





3.7. Nome de atributos ou variáveis

Para quem já programou antes em alguma linguagem de programação não

orientada a objetos, deve achar estranho o termo atributo porque, na verdade, está mais

acostumado com o termo variável.

Mas, qual a diferença entre atributos e variáveis? Nenhuma.

Atributos e variáveis são a mesma coisa em questão de funcionalidade. Ambos são

endereços de memória que tem um espaço ou tamanho definido de acordo com o tipo de

dado que será guardado, por exemplo:

caracter, número, número decimal, etc. Em Java, costumamos utilizar o termo atributo,

que é nada além do que uma variável que está dentro de uma classe. Como tudo que

fazemos em Java está contido dentro de uma classe, então usamos o termo atributo ao

invés de variável.

Os atributos (variáveis) podem começar com qualquer letra e os caracteres $ ou _,

porém não podem começar com números. Caso o nome de um atributo (variável) seja

composto por mais de uma palavra, a primeira letra de cada palavra deve ser em

maiúscula.

Exemplos de nomes de atributos ou variáveis: x, y, resultado, valorDeX, valorDeY,

ligado, ...

3.8. Nome de atributos finais ou constantes

Os atributos finais (constantes) devem ser escritos em letras maiúsculas. Usamos

underline (_) para separar nomes compostos de atributos finais (constantes).

Exemplos de nomes de atributos finais ou constantes: TAMANHO,

PARAR_DE_EXECUTAR, …





3.9. Tipos de dados e declaração de atributos

Todo programa de computador deve ser capaz de lidar com dados para conseguir

fazer seus processos como, por exemplo, somar, multiplicar, dividir, etc... Usar atributos é

a melhor forma de manipular os dados. Os tipos de dados são o que definem a

quantidade de memória do computador que será utilizado para guardar tal dado. Cada

tipo de dado tem um tamanho diferente e por consequência seu alcance também.

O que queremos dizer é que se declararmos um atributo para guardar um número

inteiro, jamais poderemos guardar um número decimal, porque um número decimal ocupa

mais espaço de memória que um inteiro. Para declararmos qualquer tipo de atributo,

usamos a seguinte ordem: primeiro o tipo de dado e depois o nome do atributo. Se não

souber como nomear um atributo, veja as regras e convenções de nomenclatura.

Vamos iniciar com os tipos de dados inteiros que são os mais simples. Em Java, os

números inteiros são divididos em quatro tipos: byte, short, int e long. Esses quatro

guardam o mesmo tipo de dado, mas ocupam espaços de memória diferente, o que afeta

em seu alcance.

O tipo byte é o de menor alcance entre os inteiros. Como o próprio nome sugere,

ele consome apenas um byte (8 bits) e pode guardar valores entre -128 e 127. O tipo

short guarda inteiros de 2 bytes (16 bits) e pode guardar números entre -32.768 a 32.767.

O tipo int é o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda

valores entre -2.147.483.648 e 2.147.483.647. Long é o tipo de dado com maior alcance

entre os inteiros. Consequentemente, também é o que ocupa mais espaço (8 bytes ou 64

bits). Tem um grande alcance que fica entre -9,22E+18 (exatos

-9.223.372.036.854.775.808) e 9,22E+18 (exatos 9.223.372.036.854.775.807).

Existe os tipos de dados próprios para caracteres que é o char.

O tipo char ocupa 2 bytes, o que torna Java ideal para programar em língüas

latinas, asiáticas ou qualquer outra que utilize caracteres diferentes do padrão ASCII. O





padrão ASCII utiliza apenas um byte que fornece 256 letras diferentes, mas o padrão

utilizado em Java (ISO) nos dá a possibilidade de até 65.536 caracteres diferentes. Para

números decimais utilizamos dois tipos de dados, dependendo da necessidade de seu

alcance e precisão (números após a vírgula).

O tipo de dado mais comum para número decimal é o float. Em um tipo de dado

float, podemos guardar números grandes que vão desde 1,4E-45 até 3,4028235E+38.

Para número decimais com grande precisão ou valores extraordinários (geralmente

utilizados em matemática aplicada e complexa como cálculos físicos, químicos,

astrológicos, meteorológicos, etc) utilizamos o tipo de dado double. Double é o tipo de

dado mais complexo que há em Java e o maior valor possível de se armazenar é

1,797.693.134.862.315.7E+308. Muito mais do que qualquer programador precisa.

Para ilustra melhor essa explicação, abaixo está um pequeno algorítmo com alguns

atributos e seus valores mínimos e máximos.

public class TiposDeDados {

public static void main(String[] args) { System.out.println("Tipos de dados em Java: \n" + "\nMenor Byte: " + Byte.MIN_VALUE + "\nMaior Byte: " + Byte.MAX_VALUE + "\nMenor Short Int: " + Short.MIN_VALUE + "\nMaior Short Int: " + Short.MAX_VALUE + "\nMenor Int: " + Integer.MIN_VALUE + "\nMaior Int: " + Integer.MAX_VALUE + "\nMenor Long: " + Long.MIN_VALUE + "\nMaior Long:" + Long.MAX_VALUE + "\nMenor Float: " + Float.MIN_VALUE + "\nMaior Float: " + Float.MAX_VALUE + "\nMenor Double: " + Double.MIN_VALUE + "\nMaior Double: " + Double.MAX_VALUE); } }





3.10. Atribuição de Valores a Variáveis ou Atributos

Como vimos, há vários tipos de dados em Java, cada um com um consumo de

memória determinado que afeta diretamente o seu alcance. Veremos agora como atribuir

valores a esses endereços de memória (atributo ou variável).

Para atribuirmos valor a uma variável ou atributo usamos o operador =. Neste caso,

o sinal de igual não significa igualdade, mas que um valor será atribuído. A regra básica é

que sempre o que estiver à esquerda do "=" receberá o valor que estiver à direita.

Por exemplo: se expressarmos var1 = 10 queremos dizer que a variável var1

receberá o número 10. Pronto!

Agora, temos o número 10 gravado na memória.

Podemos também atribuir valores contidos em outras variáveis. Por exemplo:

var1 = 20;

var2 = var1;

A variável var1 recebe o número 20, depois a variável var2 recebe o valor de var1 (que é

20). Pronto! Agora,

temos duas variáveis guardando o mesmo número (20).

3.11. Inicialização de variáveis ou atributos

Muitas vezes, precisamos inicializar as variáveis ou atributos para que possuam um

valor desde o início do programa. Como há muitos tipos de dados em Java, seus

criadores desenvolveram formas de escrita para que diferenciam os vários tipos de dados.

Primeiramente, começaremos com os mais simples: os inteiros.





Os número inteiros comuns e do tipo byte são os mais simples de se inicializar,

pois basta atribuirmos seu valor diretamente. Logicamente, precavendo-se dos limites de

alcance do tipo inteiro vistos na página de tipos de dados. Por exemplo:

int var1 = 10;

int var2 = 500;

int var3 = 65000;

byte var1 = -100;

byte var2 = 50;

Os números inteiros longos têm duas formas de serem inicializados. Podemos

escrevê-lo diretamente se, e somente se, seu valor for menor que o alcance de um inteiro

comum. Mas se o valor atribuído for maior que o valor permitido por um inteiro comum,

então, no final deve ser acrescentado uma letra L (maiúscula ou minúscula, não há

diferença aqui).

Exemplo:

long var1 = -65000;

long var2 = 3590;

long var3 = 15000000000L;

long var4 = -6740000000L;

A inicialização do tipo double e float é um pouco diferente. É possível apenas

digitar um número como sendo inteiro que o compilador entenderá facilmente, porém, se

quisermos utilizar as casas decimais, devemos utilizar um ponto para separar a parte

inteira da decimal. Outro fato ao utilizar casas decimais é que o tipo float deve ser

diferenciado do tipo double. Conseguimos fazer isso facilmente digitando uma letra F ao

final do número (não importa se a letra é maiúscula ou minúscula).





Exemplo:

double var1 = 12045741359;

float var1 = 745621;

double var2 = 10.658745965;

float var2 = 0.5f;

Char deve ser inicializado com uma letra entre aspas simples. O importante é

entender que em uma variável do tipo char só pode ser colocada uma letra, não uma

frase. Além do mais, neste caso há diferença entre maiúsculas e minúsculas.

Exemplo:

char var1 = 'a';

char var2 = 'A';

Se quisermos criar uma frase devemos guarda-la em uma string. Apesar de String

não ser um tipo de dado em Java, mas sim uma classe, este é com certeza o elemento

mais utilizado. Uma cadeia de caracteres (string) pode ser inicializada de três formas: 1)

Como uma string inexistente, ou seja, sem valor algum. Para isso utilizamos a

palavra reservada null; 2) Como uma frase vazia; 3) Como uma string completa. Com

exceção da inexistente, toda string deve estar dentro de aspas duplas ( " " ). Se por

acaso, precisarmos digitar uma aspas dentro de uma string, estas aspas devem vir

precedidas de uma barra invertida (\).

Exemplo:

String var1 = null;

String var2 = "";

String var3 = "Cadeia de caracteres";





String var4 = "entre aspas: \"String em Java\".";

O tipo booleano possui apenas dois valores: verdadeiro e falso. True para

verdadeiro e False para falso.

Exemplo:

boolean var1 = true;

boolean var2 = false;

Neste tipo de dado não há possibilidade de ter outro valor.

3.12. Método de Saída Padrão

Um método de saída é utilizado para mostrar alguma coisa ao usuário. No caso de

Java, existe um método padrão que utiliza uma saída padrão (monitor de vídeo) para criar

a comunicação com o usuário – estamos falando de println. O método println faz parte da

classe System que controla a maioria das funcionalidades do computador, e se tratando

de uma saída, mais especificamente de out.

Basicamente, o método println imprime na tela uma string (cadeia de caracteres -

frase) que é passada ao método como argumento entre parênteses. A saída padrão é

exibida sempre no console e não em uma janela. O importante é saber que o método

PRINTLN sempre pulará uma linha quando seu argumento chega ao final.

Então, procedemos da seguinte maneira: 1) A classe ao qual pertence (System); 2)

o membro que indica a saída (out); 3) o método (println); 4) O argumento contendo a

string que deve ser apresentada na tela. O método, resumidamente, ficaria assim:

System.out.println ("string")





public class ExemploDeSaidaPadrao { public static void main(String[] args) { System.out.println("Saída Padrão em Java"); System.out.println("Linha 1"); System.out.println("Linha 2"); System.out.println("Linha 3"); } }

Uma outra forma de saída padrão é o print. A única diferença entre println e print é

que ao final de seu argumento ele não irá pular nenhuma linha. Dessa forma podemos

criar uma linha contínua com vários print em linhas diferentes.

public class ExemploDeSaidaComPrint { public static void main(String[] args) { System.out.print("Saída Padrão "); System.out.print("usando "); System.out.print("o método "); System.out.print("print"); } }

3.13. Controle de Texto

Outra possibilidade interessante nos métodos de saída são os controles de texto.

Os controles de texto são dados por caracteres chaves que são indicados com uma barra

invertida antes dele. Veja a lista abaixo:

\n - pula uma linha

\t - cria uma tabulação (o mesmo que apertar a tecla TAB)

\b - retorna o cursor um carácter





\r - retorna o cursor ao início da linha

public class ExemploDeControleDeTexto{ public static void main(String[] args) { System.out.print("Empresa:\t"); // cria uma tabulação System.out.print("primebean\n"); //pula uma linha System.out.print("Soluções em Tecnologia Multiplataforma\r"); // põe o cursor no início da linha } }

3.14. Apresentando valores de variáveis ou atributos

Podemos facilmente demonstrar o valor de uma variável ou atributo bastando

apenas dar como argumento a variável. O próprio método println ou print se encarrega de

converter o valor em uma string, ou seja, ele transforma o valor número em um texto que

o representa. Veja o exemplo:

public class ApresentandoVariaveis{ public static void main(String[] args) { int inteiro = 200; float decimal = 0.5f; char letra = 'J'; System.out.println (inteiro); System.out.println (decimal); System.out.println (letra); } }

Também é possível exibir o resultado de uma operação matemática (processo)

executado dentro da própria saída padrão.

public class ApresentandoResultados{ public static void main(String[] args) { int inteiro = 200; float decimal = 0.5f;





System.out.println (inteiro + decimal); } }

Obs.: Tenha cuidado ao apresentar resultados de números junto com texto, pois nesse

caso haverá a concatenação de string, ou seja, a junção de duas ou mais cadeias de

caracteres.

3.15. Concatenação

Concatenação é o ato de unir duas ou mais cadeias de caracteres (strings). Por

muito tempo, operações envolvendo strings eram os pesadelos de qualquer programador,

pois havia a necessidade de tratar o elemento pelo seu dado bruto, ou seja, carácter por

carácter. Então, juntar por exemplo, duas frases era um trabalho árduo.

Com o surgimento da orientação a objeto e o advento do Java, as operações

envolvendo strings foram muito simplificadas. A melhoria mais significativa nesse assunto,

sem sombra de dúvidas, foi utilizar a concatenação de strings.

A concatenação de strings é dada pelo operador +, mas não o confunda com o

operador de adição que utiliza o mesmo símbolo. Dessa forma, com apenas este símbolo,

podemos unir duas cadeias de caracteres diferentes em apenas uma.

Veja este exemplo, que apesar de bobo, ilustra exatamente o que acontece na

concatenação:

João + zinho = Joãozinho; Passa + tempo = Passatempo; beija + - + flor = beija-flor.

Acredite, simples desse jeito.





Colocando isso em um código ficaria:

public class ConcatenacaoSimples { public static void main(String[] args) { String palavra1 = "tele"; String palavra2 = "fone"; System.out.println(palavra1 + palavra2); } }

O melhor da concatenação é que não precisa ser uma palavra que faça sentido

porque o computador não verifica se faz sentido, ele simplesmente junta a cadeia de

caracteres. Portanto, poderíamos muito bem fazer isso:

public class ConcatenacaoComposta {

public static void main(String[] args) { String part1 = "De"; String part2 = "se"; String part3 = "nc"; String part4 = "or"; String part5 = "aj"; String part6 = "ad"; String part7 = "o"; System.out.println(part1+part2+part3+part4+part5+part6+part7); } }

A concatenação de strings ajuda muito no momento que usamos o método de

saída padrão println, porque ao invés de utilizarmos várias vezes o mesmo método,

podemos apenas concatenar a string anterior com a string posterior, ou seja, juntar a

string de cima com a string da linha de baixo. Veja o exemplo:

public class ConcatenacaoComPrintln {

public static void main(String[] args) { System.out.println("Bem vindo ao mundo Java!\n\n" +





"Este é um exemplo prático de concatenação de string.\n" + "Aqui, a string da linha de cima é " + "sempre concatenada com a string da linha de baixo" ); } }

3.15.1. Cuidados ao concatenar

Apesar da concatenação ser algo bem simples de ser feito, devemos ter alguns

cuidados. Pois como podemos perceber, ele também é o símbolo utilizado para fazer

operações de adição. O que queremos dizer é que, se por exemplo, quisermos marcar um

número de telefone em uma única string e tivermos na verdade dois números inteiros

distintos, o resultado será desastroso. Veja:

Telefone: 998 + 1234, resultaria em Telefone: 2232. Acabamos de perder o número de

telefone. Então, o mais sensato é se lembrar que concatenação só ocorre entre uma

string e outro dado (não necessariamente precisa ser uma string também).

Então, para conseguirmos juntar os dois números acima, pelo menos um deles

deve ser uma string. Telefone: "998" + 1234, ou Telefone: 998 + "1234".

Esse pensamento se torna mais complicado a medida que temos que concatenar

uma uma operação no meio da string.

Exemplo:

"CCXXVI em algarismos romanos são " + 200 + 20 + 6. Aqui, ao invés de representar a

soma de 200 + 20 + 6, que seria 226, é representada a total concatenação de todos os

elementos. O que resultaria em "CCXXVI em algarismos romanos são 200206".

Mas este problema é fácil de resolver, basta indicarmos com os parênteses que a

operação matemática deve ser executada primeiro. Representando ficaria:

"CCXXVI em algarismos romanos são " + (200 + 20 + 6). O que consequentemente,





representaria "CCXXVI em algarismos romanos são 226".

3.16. Operadores e Processos

Os processos são contas matemática (cálculos) que podem ser feitos com

números, variáveis ou ambos. Abaixo está uma tabela com os operadores mais comuns.

+ adição ou concatenação

- Subtração

* Multiplicação

/ Divisão

% Módulo (divisão no qual é obtido o resto)

++ Incremento de 1

-- Decremento de 1

Java segue a convenção de expressões matemáticas. Por exemplo:

Se você fizer 10-2/4, o resultado será -9,5 e não 2, pois a divisão deve ser

calculada primeiro. Para esta conta dar 2 devemos indicar que a subtração deve ser feita

antes da divisão. Ela ficaria assim, (10-2)/4.

O que está entre parênteses deve ser calculado primeiro. Em Java, podemos

facilmente simplificar operações que envolvam a própria variável. Por exemplo, vamos

imaginar que o novo valor de var1 seja o valor da própria variável var1 mais o valor da

variável var2.

Podemos construir, então, a seguinte sentença -> var1 = var1 + var2, ou podemos

simplificá-la em -> var1 += var2.

Veja abaixo a tabela de todas as operações possíveis:

Símbolo Operação





+= somar (quando os dados forem algum número)

+= concatenar (quando um dos dados for String)

-= subtração

*= multiplicação

/= divisão

%= módulo (a variável à esquerda recebe o resto da divisão dele com a

variável à direita)

4. Controle de Fluxo

Controle de fluxo é a habilidade de ajustar a maneira como um programa realiza

suas tarefas. Por meio de instruções especiais, chamadas comandos, essas tarefas

podem ser executadas seletivamente, repetidamente ou excepcionalmente. Não fosse o

controle de fluxo, um programa poderia executar apenas uma única seqüência de tarefas,

perdendo completamente uma das características mais interessantes da programação: a

dinâmica. Podemos classificar os comandos aceitos pela linguagem Java em

basicamente quatro categorias:

Comando Palavras-chave

Tomada de decisões If-else, switch-case

Laços ou repetições For, while, do-while

Apontamento e tratamento de excessões Try-catch-finally, throw

Outros break,continue,label:,return





4.1. Execução condicional - IF e ELSE

Uma ação muito importante que o processador de qualquer computador executa, e

que o torna diferente de qualquer outra máquina, é a tomada de decisão definindo o que é

verdadeiro e o que é falso.

Se quisermos fazer um bom programa, esse programa deve ser capaz de definir

caminhos diferentes de acordo com decisões que o próprio programa toma. Para isso,

precisamos de uma estrutura seletiva da qual o único valor possível é o bit 1 ou 0,

resumindo: retornar o valor VERDADEIRO ou FALSO.

Em Java, como em muitas linguagens de programação, quem faz isso é o IF (SE

traduzindo). O ELSE é o que chamamos de caso contrário, ou seja, se for falso execute o

que está no ELSE.

Exemplificando: Se (IF) for tal coisa, faça isso! Caso contrário (ELSE), faça aquilo!

4.2.1. Usando IF

Para usar o IF basta digitar entre parênteses o que deve ser comparado.

IMPORTANTE: IF é uma palavra reservada que não aceita ponto-e-vírgula (;) no final. Se

for verdadeiro, o programa executará a primeira linha logo abaixo do if. Mas, e se

quisermos executar várias linhas se if for verdadeiro?

Se o if tiver que executar várias linhas, todas as linhas que devem ser enquadradas

dentro do bloco de dados - as chaves ({}).





4.2.2. Usando ELSE

O ELSE só existe se tiver um IF. O else só será executado se o IF for falso. Else

executará só a primeira linha abaixo dele. Se o else tiver que executar várias linhas, vale

a mesma regra de if. Todas as linhas a ser executadas deverão estar contidas dentro do

bloco de dados ({}).

Para que IF chegue a uma decisão de falso e verdadeiro são necessários

operadores lógicos. Dos quais destacam-se 6:

• > - maior que

• < - menor que

• >= - maior ou igual a

• <= - menor ou igula a

• == - igual a

• != - diferente de

Importante

O operador lógico ! (negação) serve para inverter o valor, ou seja, se algo for falso,

irá se tornar verdadeiro e vice-e-versa.

Uma construção sem comparação entre duas variáveis é sempre entendida como

sendo verdadeira. Ex.: if (var1) -> entenda como: se var1 for verdadeiro.

Uma construção sem comparação entre duas variáveis será entendida como false

se usarmos o operador de negação antes da variável. Ex.: if (!var1) -> entenda como: se

var1 for falso.

public class UsandoIf { public static void main(String args[]) {





boolean var1 = true; // Se var1 for verdadeiro if (var1) { System.out.println("var1: Verdadeiro"); } else { System.out.println("var1: Falso"); } // Se var1 for falso if (!var1) { System.out.println("!var1: Verdadeiro"); } else { System.out.println("!var1: Falso"); } } }

4.3. Switch, Case e Default

Uma estrutura muito utilizada em programação é o switch. A estrutura switch

verifica uma variável e age de acordo com seus cases. Os cases são as possibilidades de

resultados que são obtidos por switch. Basicamente, o switch serve para controlar várias

ações diferentes de acordo com o case definido dentro dele.

A estrutura do Switch é:

SWITCH (variável) {

CASE valor :

Código a ser executado caso o valor de case seja o mesmo da variável de switch

}

Então, detalhadamente, switch recebe uma variável e abre um bloco de dados

( { } ), dentro desse bloco de dados há os cases. Cada case recebe um valor único, ou





seja, que não pode ser repetido no mesmo bloco de dados. Então, marcamos cada case

com dois pontos ( : ). Após os dois pontos colocamos todo código que deverá ser

executado que pode conter quantas linhas nós quisermos.

Dica importante: É um bom costume sempre terminar um código após o case com um

comando break. Assim, nós evitamos que o resto do código seja executado por acidente.

E vale também ressaltar que case não gera resultados booleanos, portanto, não há a

possibilidade de fazer comparações (Ex. Isso está totalmente errado-> case var1 > var2:).

4.3.1. Default

Como switch pode receber várias possibilidades, pode ocorrer de algum caso estar

fora do alcance ou não definido. Nesse momento, default faz seu papel. Default pega

qualquer resultado que não esteja definido no case. Ou seja, ele é o bloco de código

padrão que deve ser executado quando nenhum case for satisfeito.

Podemos colocá-lo onde quisermos dentro de switch , mas, geralmente, o

colocamos no final. Para exemplificar, vamos ver o código abaixo.

public class ExemploSwitch { public static void main(String args[]) { int diaDaSemana = 1; switch (diaDaSemana) { case 1: System.out.println("Domingo"); break; case 2: System.out.println("Segunda-feira"); break; case 3: System.out.println("Terça-feira"); break; case 4: System.out.println("Quarta-feira");





break; case 5: System.out.println("Quinta-feira"); break; case 6: System.out.println("Sexta-feira"); break; case 7: System.out.println("Sábado"); break; default: System.out.println("Este não é um dia válido!"); } }}

Como podemos perceber, existe uma variável inteira chamada diaDaSemana. Essa

variável é passada ao switch e dentro desse switch há 7 cases que correspondem aos

dias da semana. Como o valor inicial é 1, então, o bloco logo abaixo de case 1 é

executado, ou seja, ele imprimirá Domingo no monitor. Para evitar que o código dos

outros cases sejam executados, logo após o método println há um comando BREAK;

Se quiser, copie este código e modifique o valor inicial de diaDaSemana para

verificar os possíveis resultados e como este algoritmo funciona.

4.4. Break e Continue

Break e Continue são dois comandos de controle de estruturas largamente

utilizados em loops (repetições) como for e while.





4.4.1. Break

O comando break serve para determinar uma quebra de estrutura, ou seja, ele faz

com que, por exemplo, um loop (repetição) pare. No comando switch, por exemplo, ele

determina que não pode ser executado o case seguinte, e assim por diante.

No exemplo abaixo, temos uma repetição que se inicia em 1 e deve terminar em

mil (1.000), mas dentro desta estrutura há uma condição: se a variável for igual a 10 saia

da estrutura de repetição. Vejamos:

public class ExemploBreak {

public static void main (String args []){ for (int contador=1; contador<=1000; contador++){ System.out.println("Esta é a repetição nr: "+contador); if (contador==10) break; } } }

Como podemos observar, mesmo a estrutura de repetição for determinando que a

repetição deve ir até 1000, ao executarmos esse código, apenas conseguimos chegar até

a repetição número 10. Isso ocorre porque quando if for verdadeiro ele executa o break.

Dessa forma, conseguimos sair do loop sem ele ter terminado.

4.4.2. Continue

Continue também é muito utilizado em estruturas e repetição e sua função é

ignorar o código, e não sair como acontece com o break.





Exemplificando, faremos um código contendo uma estrutura de repetição que irá contar

de 1 a 100, mas sempre que o número não for múltiplo de 5 o código para apresentar o

número na tela será ignorado e a repetição continuará com o número seguinte.

public class ExemploContinue {

public static void main (String args []){

for (int contador=1; contador<=100; contador++){ if (contador%5!=0) continue; /* Se o contador não for múltiplo de 5 * Todo o código abaixo será ignorado * e o loop continua com o próximo nr */ System.out.println("Contador: "+contador); } } }

Ou seja, desta forma, apenas os múltiplos de 5 entre 1 e 100 aparecem na tela.

4.3. Estruturas de Repetição

Trata-se de comandos que permitirão a execução repetida de vários outros

comandos descritos no algoritmo. Usaremos uma estrutura de repetição para executar

repetidas vezes comandos, em função de uma condição que determinará o numero de

repetição a serem executadas .

As repetições poderão ser controladas de varias formas diferentes . Em geral

aparecerá a figura de uma variável que será utilizada como elemento de controle das

repetições. A está variável daremos o nome de contador.





4.3.1. While

While é uma estrutura de repetição. O mesmo executa uma comparação com a

variável. Se a comparação for verdadeira, ele executa o bloco de instruções ( { } ) ou

apenas a próxima linha de código logo abaixo.

Procedemos da seguinte maneira:

While(comparação)

O problema com estruturas de repetição, principalmente com while, é o que

chamamos de looping infinito.

Damos esse nome ao fato de que o programa fica repetindo a mesma sequência

de códigos esperando por um resultado que nunca irá acontecer. Portanto, é

imprescindível que uma determinada variável seja modificada de acordo com cda loop.

Veja o exemplo

public class ExemploWhile {

public static void main(String args[]) { int contador = 0; while (contador < 50) { System.out.println("Repetição nr: " + contador); contador++; } } }

Como podemos ver, existe a variável contador que é iniciada valendo 0, a cada





loop executado (repetição) é somado 1 ao contador. Perceba que o while irá manter a

repetição enquanto a variável contador for menor que 50.

Outro ponto importante é que a variável contador é inicializada antes de chegar ao

while, porque o while irá comparar a sentença e só depois permitirá a execução do bloco.

Se quisermos fazer todo o bloco primeiro e só depois fazer a comparação, devemos

utilizar o comando do While

4.3.2. Do While

Do While é uma estrutura de repetição, tal como o próprio while. A principal

diferença entre os dois é que Do While irá fazer a comparação apenas no final do bloco

de código, sendo representado da seguinte forma:

DO { código } WHILE (comparação);

Neste caso, devemos ter as mesmas precauções quanto while, no que diz respeito

a looping infinito. Mas não é necessário inicializar a variável antes do bloco de código

como acontece com while, pois a comparação só será feita após todo o código ter sido

executado.

4.3.3. For

For é uma estrutura de repetição que exerce a mesma função que WHILE e DO

WHILE. A principal diferença entre eles é a sintaxe e também a forma de trabalhar.

O For necessita de três parâmetros: a inicialização da variável, a condição que irá

manter o looping (repetição) e o modificador da variável inicializada que pode ser

incrementada ou decrementada, ou seja, pode aumentar seu valor ou diminuir. Um ponto





importante é que todos os parâmetros devem ser separados por ponto-e-vírgula ( ; ).

Dessa forma, temos resumidamente a seguinte construção: FOR (inicialização ;

condição ; incremento ou decremento).

Por exemplo, vamos criar um código que nos dá o resultado do fatorial de 5. Como

sabemos para calcular o fatorial de algum número basta multiplicarmos ele pelo número

anterior regressivamente até 1, ou seja, seria algo como 5 × 4 × 3 × 2 × 1. Dessa forma,

sabemos exatamente em quanto devemos começar nossa conta (5), sabemos por quanto

tempo o looping irá continuar executando (enquanto a variável for maior que 1) e

sabemos quanto devemos modificar essa variável (para cada repetição irá subtrair -

decrementar - 1).

Em um código ficaria:

public class Fatorial {

public static void main (String args[]){ int fator, resultado=1; for (fator=5; fator>1; fator--) resultado*=fator; System.out.println(resultado); }

}

Observemos apenas um detalhe, como toda variável é automaticamente

inicializada como nulo (NULL), então, necessitamos inicializar a variável resultado em 1,

porque seria impossível multiplicar a variável resultado pela variável fator (ex. NULL × 5

= ?).





5. O que são e para que servem as Classes e Objetos

O conceito de orientação a objetos, é, sem dúvida, o mais importante em Java.

Por ser um conceito um pouco abstrato, é normal que demore um pouco até entender

tudo.

E até entender bem, vai demorar mais ainda. Porém, vamos ensinar, ao longo de

vários exemplos, divididos em várias seções, estes tão importantes detalhes.

Até este momento só vimos o básico e laços da programação Java, vamos apenas

ensinar como declarar as classes, instanciar os objetos (com e sem construtores) e como

usar testes condicionais dentro das classes que criamos.

Isso dará uma idéia do que são classes e objetos, e é importante que se habitue a estas

idéias.

5.1. O que são Classes e Objetos em Java

Classes podem ser vistas como abstrações ou definições maiores das coisas , já

um objeto já é algo mais real, mais concreto, é um elemento ou tipo daquela classe.

Usando essas definições, é realmente difícil entender os conceitos, por isso vamos usar

exemplos.

Por exemplo, podemos ver "Pessoa" como uma classe. É uma classe que

representa seres humanos, que possuem cabeça, coração, cérebro etc. É uma

generalização maior.

Podemos declarar você, caro leitor, como um objeto dessa classe, com seu nome e

características específicas de uma "Pessoa". Você pertence a classe "Pessoa". Eu

também, pois possuímos cabeça, coração, cérebro etc.

Nós temos essas características gerais, que todos da classe "Pessoa" possuem. Ou seja,





em Java, dizemos que somos instâncias da classe "Pessoa".

5.2. Utilidade das Classes e Objetos em Java

Esse tipo de representação vai nos ajudar muito em programação Java. Por

exemplo, imagine que você foi contratado para criar um aplicativo Java para uma

empresa.

Você precisará cadastrar os milhares de funcionários da empresa.

É claro que você não vai declarar milhares de strings para armazenar o nome de cada

um, nem de inteiros para armazenar seus números nem de floats para armazenar seus

salários. Seria humanamente impossível fazer isso.

5.2.1. Agrupar coisas semelhantes

Aí que entra a vantagem da programação orientada a objetos. Podemos ver todos

esses funcionários de uma mesma maneira: como a classe Funcionario. O que a classe

"Funcionario" tem em comum?

Tem um nome, uma idade, uma data de contratação, um salário, um setor em que

trabalham e outras coisas específicas da empresa. Pronto.

Você pode ver essa classe como um tipo de dado.

Assim como 'int' ou 'float', agora existe o tipo 'Funcionario'. Toda vez que entrar

alguém novo na empresa, você declara esse elemento como fazendo parte do tipo

'Funcionario'. Ou seja, estará criando um objeto dessa classe.

O objeto, diferente da classe, é algo mais específico, ele que terá as informações

pessoais de cada funcionário.





5.2.2. Crie uma vez, use quantas vezes quiser

A grande vantagem desse tipo de 'visão', é que, ao declarar a classe, você declara

dentro dela os tipos: string, float, int etc, que estão dentro da classe. Então, quando for

criar um objeto, automaticamente esses dados estarão criados!

Aí que reside a beleza do Java e da orientação a objetos. É muito, mas muito útil e

prático. É um novo jeito de pensar e ver o mundo.

5.2.3. Altere uma parte do código, e a mudança se propagará em todo o código

Ok, você criou seu aplicativo usando a classe "Funcionario". Porém, a pessoa que

te contratou - que muitas vezes não são da área de TI - esqueceu de te informar que os

funcionários devem ter uma informação no cadastro: se possuem carro ou não.

E aí? Alterar tudo? Começar do zero?

Claro que não. Simplesmente vá na classe e coloque esse atributo (informação), e

automaticamente todos os objetos passarão a ter esse dado, "carro". Então é só pedir

para os funcionários preencherem esse dado no seu aplicativo de cadastro.

5.2.4. Classe à parte, vida à parte

Uma coisa interessante que a programação orientada a objetos nos proporciona é

a divisão das partes do programa. Dois programadores podem programar duas classes de

forma totalmente independente e fazer com que elas funcionem perfeitamente. Coisa que

em outros paradigmas de programação é quase impossível.

Por exemplo, você criou a classe "Funcionario".





Nessa classe você precisa a informação do salário de cada funcionário, porém

você não tem acesso aos detalhes financeiros da empresa. Ora, nem precisa e nem deve

ter, é algo mais restrito.

Outro programador, responsável pelo setor financeiro, pode ter criado a classe

"Salario" que recebe os dados de cada pessoa, sua posição na empresa, bônus, horas

extras etc etc, e te dá somente o resultado final: o número. Esse dado é o que você vai

usar na sua classe "Funcionario".

Isso tudo pode ser feito de uma maneira totalmente eficiente, segura e

independente, tanto por você como pelo programador que fez a outra classe. A única

troca de informação é que você pega um float dele e ele pega o nome do seu funcionário

ou código dele da empresa. O mais importante disso é: em nenhum momento foi

necessário um ver o código do outro!

Na hora de trabalhar, isso nos diz muito em termos de rendimento!

5.2.5.Como saber quando usar Classes e Objetos em Java

Como você pode notar, através dos exemplos dos Carros, das Pessoas e dos

Funcionários, as Classes são nada mais que um grupo de informações. Sempre que

quiser usar essas informações, declare um Objeto daquela classe.

Ou seja, sempre que quiser generalizar ou criar um grupo com características

parecidas, não tenha dúvida, use Classe e Objetos.

Em um jogo, Worms Armageddon ou Counter-Strike, por exemplo. Existem vários

jogadores. Ora, eles são parecidos, tem semelhanças e características em comum. Não

perca tempo declarando seus atributos individualmente, use classes e objetos.

Na verdade, em Java, tudo são classes e objetos, então não há muito essa

preocupação.





Em C, não existe Orientação a Objetos.

Em C++, você escolhe se usa ou não.

Adiante, veremos que uma classe pode se parecer com uma e outra, pegar

'emprestado' detalhe de outras, implementar ou estender outras. Existem vários recursos

para serem usados nas Classes, inclusive de segurança, que permitem que alguns

objetos tenham acesso a alguns dados, outros não.

Recursos gráficos: por exemplo, as janelas dos aplicativos Java, botões, menu e

tudo mais são classes. Como dissemos, Java gira em torno de orientação a objetos, e

Java é uma linguagem de programação riquíssima e ilimitada. Logo, o que é possível

fazer com as classes e objetos também é bem vasto.

5.3. Criação de Classe

Começaremos agora a ver a alma da programação Java que é a orientação a

objeto. Sempre que programamos em Java, devemos pensar em como montar as

definições de nosso objeto. Ou seja, quais atributos uma classe deve conter,

simplificando, quais características tem tal objeto.

É como pensar em alguma coisa. Por exemplo, se pensarmos em relógio, a

primeira coisa que nós vem a cabeça é hora, minuto, segundo e assim por diante. Nós

também podemos ajustar as horas, ajustar o alarme, etc.

A princípio, vamos nos ater aos detalhes técnicos da programação de uma classe.

Para criar uma classe usamos a palavra chave class, e após a definição do nome de

nossa classe, nós definimos seus atributos. Para exemplificar, criaremos uma classe que

terá as características mais simples de uma televisão.





pubic class TV{ int tamanho; int canal; boolean ligada; }

Pronto, esses são os atributos de uma classe, ou seja, nós definimos que existe um

objeto chamado TV e que ele tem três características: uma dessas características é o

tamanho, outra é um valor inteiro identificado por canal e mais outra característica que

determina se ele está ligado ou não.

Como podemos perceber, isso é mais um conceito (paradigma) de como devemos

pensar. Uma classe (ou objeto) pode ser muito implementado, tornando-se um objeto com

várias características que pode ser facilmente manipulado e incorporado por outros

objetos. Isso é o que chamamos de reutilização de código, que envolve vários aspectos

importantes da orientação a objeto como herança, interface, enumeradores, sobrecarga

de métodos entre outros que nós estudaremos nas próximas páginas.

5.4. Métodos Construtores

Vimos anteriormente que é simples criar uma classe. Mas, para realmente

conseguirmos utilizar a classe, ela deve conter pelo menos um método construtor.

O método construtor é desenvolvido da mesma forma que uma função, a única

diferença é que ele tem o mesmo nome da classe. Isso se deve ao fato de que um objeto

deve ser construído cada vez que chamamos a classe.

E a responsabilidade de fazer isso é do construtor. Isso parte do princípio que

podemos ter dois objetos com a mesma característica, mas que não são os mesmos

objetos. Ou seja, nós podemos ter uma TV de 29" ligada no canal 15 e nosso amigo tem





uma outra TV que também é de 29" e está ligada no canal 15. Perceba que ambas as TVs

têm as mesmas características, mas continuam sendo duas TVs diferentes.

Sempre que criamos uma classe, Java automaticamente vincula um método

construtor padrão interno com o mesmo nome da classe, mas sem inicializar nenhum

atributo. Para demonstrar um método construtor, criaremos um construtor padrão sem

argumentos no qual já contém os valores dos atributos definidos por nós mesmos.

Então, vamos imaginar que sempre que uma TV é construída, o seu padrão é

tamanho 21", desligada e no canal 0. Então, podemos defini-lo como:

public class TV { int tamanho; int canal; boolean ligada;

TV(){ tamanho=21; canal=0; ligada=false; }}

6. Estrutura de Dados

Hoje em dia, a grande maioria das pessoas utilizam a agenda do celular paraarmazenar seus contatos. As tarefas de uma agenda de contatos são basicamente duas:

1.Definir como as informações dos contatos serão armazenadas. Uma informação

armazenada em algum lugar (pedaço de papel, livro, computador, etc) é um dado.

2.Disponibilizar operações para criar, recuperar, ordenar, atualizar e remover

contatos. Além de operações para informar o estado da agenda (a quantidade de

contatos existentes na agenda ou a quantidade de espaço disponível para novos





contatos).

A primeira tarefa é crucial para o desempenho. Se a agenda armazena as

informações de uma forma desorganizada então será muito mais complicado manipular

os dados de forma eficiente. A escolha de como guardar as informações deve levar em

consideração as operações que serão disponibilizadas pela agenda. Por exemplo, seria

interessante manter os contatos em ordem alfabética para facilitar a busca.

Mas, apesar da importância de como os contatos são armazenados, a organização

interna da agenda não precisa e não deve ser exposta ao usuário. Afinal de contas, o que

o usuário deseja é usar a agenda através das operações e que tudo seja feito o mais

rápido possível.

A única coisa que precisa ser mostrada para o usuário são as operações que ele

pode fazer na agenda (inserir, recuperar, atualizar, remover contato, saber quantos

contatos estão na agenda, etc). Este conjunto de operações é interface que o usuário

tem com a agenda.

Cada celular pode implementar a sua agenda de contatos de uma forma totalmente

diferente um do outro, na tentativa de obter mais performance, ser mais confiável ou

gastar menos memória. Porém o conjunto básico de operações oferecidas pelas agendas

é sempre o mesmo. Isso facilita a vida do usuário pois se ele tiver que trocar de celular

não vai ter que aprender novamente como usar uma agenda de contatos.

Essa é a grande vantagem em se pensar em interface. Mantida a interface,

podemos trocar uma agenda que não é tão eficiente ou que já não atende mais as nossas

necessidades por outra mais eficiente ou adequada, sem problemas em ter de aprender a

usar a nova agenda: troca-se a implementação, mas não mudamos a interface.





Uma agenda de celular pode ser vista como uma estrutura de dados. Uma

estrutura de dados mantém os dados organizados seguindo alguma lógica e disponibiliza

operações para o usuário manipular os dados.

É importante, quando programar, não misturar dado e estrutura de dados em uma

coisa só. Um dado é uma informação armazenada e estrutura de dados é quem

administra os dados. O ideal é que a estrutura de dados seja o mais independente

possível dos dados que ela vai armazenar. Desta forma pode-se aproveitar a mesma

estrutura de dados para diversos tipos de dados. Por exemplo, é melhor ter uma agenda

genérica do que uma agenda de telefones. Uma agenda genérica pode ser utilizada para

guardar telefones, ou emails, ou até mesmo guardar uma outra estrutura dentro dela:

contatos, que seriam compostos por nome, telefone e email.

Algumas estruturas de dados são apenas agrupamentos de dados sem um objetivo

de aplicar algum algoritmo ou tirar proveito de sua estrutura. Um exemplo seria a estrutura

Contato. Algumas outras estruturas são mais espertas e trabalhosas, como a Agenda,

assim como Listas Ligadas, Vetores, Tabelas de Espalhamento e outras que veremos no

decorrer da apostila.

Estas estruturas, por sua característica mais complexa e de poder ser reutilizada

em outros contextos, devem ser criadas da forma mais independente possível dos dados

que estarão dentro dela. Em outras palavras, não devemos misturar a Agenda e o

Contato de maneira rígida, para que com isso possamos criar outras Agendas, como por

exemplo uma Agenda de Fornecedor.





6.1. Vetores e Matrizes

Vetores e Matrizes são estruturas de dados muito simples que podem nos ajudar

muito quando temos muitas variáveis do mesmo tipo em um algoritmo. Imagine o seguinte

problema: Você precisa criar um algoritmo que lê o nome e as 4 notas de 50 alunos,

calcular a média de cada aluno e informar quais foram aprovados e quais foram

reprovados.

Conseguiu imaginar quantas variáveis você vai precisar? Muitas né? Vamos fazer

uma conta rápida: 50 variáveis para armazenar os nomes dos alunos, (4 * 50 = ) 200

variáveis para armazenar as 4 notas de cada aluno e por fim, 50 variáveis para armazenar

as médias de cada aluno.

300 variáveis no total, sem contar a quantidade de linhas de código que você vai

precisar para ler todos os dados do usuário, calcular as médias e apresentar os

resultados. Mas eu tenho uma boa notícia pra você. Nós não precisamos criar 300

variáveis! Podemos utilizar Vetores e Matrizes (também conhecidos como ARRAYs).

Vetor (array uni-dimensional) é uma variável que armazena várias variáveis do mesmo

tipo. No problema apresentado anteriormente, nós podemos utilizar um vetor de 50

posições para armazenar os nomes dos 50 alunos.

Matriz (array multi-dimensional) é um vetor de vetores. No nosso problema, imagine

uma matriz para armazenar as 4 notas de cada um dos 50 alunos. Ou seja, um vetor de

50 posições, e em cada posição do vetor, há outro vetor com 4 posições. Isso é uma

matriz. Cada item do vetor (ou matriz) é acessado por um número chamado de índice.





6.2. Vetor

Vetores, também muito conhecidos como arrays, são variáveis que servem para

guardar vários valores do mesmo tipo de forma uniforme na memória. Por exemplo, se

tivemos que criar 20 variáveis do mesmo tipo que querem dizer a mesma coisa, nós não

criaríamos -> int var1, var2, var3, var4, var5, ... ao invés disso, criaríamos apenas uma

variável de vetor para guardar todos os 20 números de uma vez.

Como um vetor pode guardar vários valores temos que definir quantos valores ele

deve guardar para que seja reservado o espaço necessário em memória. Primeiramente,

vamos aprender como declarar um vetor. Para declarar um vetor devemos especificar o

tipo ou classe de dado que será armazenado nele. Após isso, damos um nome a esse

vetor. E, para finalizar, indicamos que ele é um vetor, simplesmente abrindo e fechando

colchetes ( [ ] ).

Portanto, se quiséssemos um vetor de números inteiros chamado meu vetor,

declararíamos da seguinte forma:

int meuVetor [ ];

Agora que já declaramos o vetor, devemos dar um tamanho a ele, para que seja

reservado espaço suficiente em memória. Para fazermos isso, utilizaremos um

instanciador chamado new.

New é muito importante, pois ele irá criar de fato o vetor. Para indicarmos o

tamanho usamos o instanciador new, depois o tipo de dado do vetor e entre colchetes o

tamanho do vetor.

Tomando o exemplo acima, vamos indicar que meuVetor terá o tamanho 4. Então,

a linha de cima ficaria:

int meuVetor[ ] = new int [4];





Na memória é representado da seguinte forma:

Uma única variável com 4 espaços nos quais podem ser guardados números

inteiros. Acessando uma posição no Vetor Agora, para acessarmos um local específico

dessa memória devemos indicar entre colchetes a posição desejada no vetor que

chamamos de index.

O importante mesmo é saber que não importa o tamanho do vetor, o index (número

que indica a posição) sempre começa em 0. Ou seja, um vetor de tamanho 20 vai da

posição 0 a 19, um vetor de tamanho 180 vai da posição 0 a 179. Portanto, um vetor de

tamanho 4 vai da posição 0 a 3.

Agora, se quisermos atribuir os valores 540 na posição 1 e 8456 na posição 3,

faríamos: meuVetor [1]=540; meuVetor [3]=8456.





Não podemos nunca nos esquecer que o limite do vetor é sempre seu tamanho

menos 1. Usando o exemplo: vetor de tamanho 4, posição máxima é 3 (pois 4-1=3).

Então, se atribuirmos um valor a posição 4 ocorrerá um erro. Resumidamente, jamais

poderíamos fazer meuVetor [4]=200.

6.2.1 Inicialização direta de Vetor

Podemos inicializar um vetor diretamente, sem a necessidade de instanciá-lo com

new. Para isso, após a declaração do vetor, basta colocar seus valores em chaves,

separando cada valor por vírgula. Por exemplo, se quiséssemos inicializar o meuVetor

com os valores 450, 200, 1000, 700, faríamos:

int meuVetor [ ] = { 450, 200, 1000, 700 };

6.3. Matrizes

Matrizes são vetores multidimensionais, ou seja, eles não são totalmente lineares,

e sim, geométricos. Enquanto um vetor tem apenas uma linha com vários valores, uma

matriz pode, por exemplo, tem várias linhas com vários valores, que comumente

chamamos de linhas e colunas.

Para criarmos um vetor multidimensional (ou matriz), procedemos da mesma forma





que um vetor normal, porém com mais um dimensionador (os colchetes). Então, se

quisermos criar um vetor (matriz) bidimensional com 3 linha e 5 colunas, faríamos:

int minhaMatriz [ ][ ] = new int [3][5];

Na memória é representado como:

Isso também pode ser feito para adquirirmos o formato de matriz que quisermos.

Ou seja, se fosse uma matriz tridimensional, bastaria ter três dimensionadores, se fosse

4D, então, 4 dimensionadores, se fosse 5D (apesar de geometricamente difícil de

imaginar) seriam 5 dimensionadores. E assim por diante.

6.4. ArrayList

Até o momento, nessa seção de Estrutura de Dados de nosso curso de Java,

vimos o quão útil são os arrays e as operações que podemos fazer com esses arrays,

também conhecidos por vetores.

Porém, há um grande problema neles: são estáticos. Ou seja, tem tamanho

definido, não podemos adicionar nem excluir nada neles, o que é bastante incômodo e faz

com que arrays em Java sejam limitados.

E por que arrays não são muito úteis?





Porque na vida real as coisas não são assim estáticas, elas mudam. O número de

funcionários de um empresa tendem a crescer, em uma faculdade alunos se formam e

outros se matriculam, em um jogo de RPG vamos colecionando itens no decorrer do jogo,

ao passo que vamos usando outros.

Agora vamos aprender como usar os ArrayList, que são arrays mais 'flexíveis', ou

dinâmicos, já que podemos adicionar ou retirar elementos, além de fazer outras coisas

que não são possíveis com os Arrays.

6.4.1. O que são ArrayList em Java

O Java, por padrão, possui uma série de recursos prontos (APIs) para que

possamos tratar de estrutura de dados, também chamados de coleções (collections).

Podemos dizer que ArrayList é uma classe para coleções. Uma classe genérica (generic

classes), para ser mais exato. Coleções mesmo, de qualquer tipo de 'coisa' ou dado, não

somente de tipos primitivos.

Você pode criar seus objetos - através de uma classe - e agrupá-los através de

ArrayList e realizar, nessa coleção, várias operações, como: adicionar e retirar elementos,

ordená-los, procurar por um elemento específico, apagar um elemento específico, limpar

o ArrayList dentre outras possibilidades.





6.4.2. Como declarar e usar ArrayList em Java

Importe:

import java.util.ArrayList;

Por ser um tipo diferente, sua sintaxe é um pouco diferente do que você já viu até

então:

ArrayList< Qualquer_Tipo > nomeDoArrayList = new ArrayList< Qualquer_Tipo >();

No exemplo a seguir, vamos usar um ArrayList de String para trabalhar com o

nome de várias Bandas de música:

ArrayList<String> bandas = new ArrayList<String> ();

6.4.3. Exemplo de uso do ArrayList

Após declarar a ArrayList 'bandas' que armazenará Strings, vamos adicionar alguns

nomes. Primeiro adicionamos a banda "Rush":

bandas.add("Rush");

Existe um método do ArrayList chamado 'toArray()' que coloca todos os elementos

de um ArrayList em um Array.

Ou seja: bandas.toArray() é um Array!

Porém, já vimos que existe um método 'toString' da classe Arrays que retorna uma

String com os elementos de um Array. Vamos usar esse método parar exibir todos os

elementos do ArrayList, que transformamos em Array através do método 'toArray()':





Arrays.toString( bandas.toArray() );

Vamos adicionar a segunda banda, "Beatles" e imprimir, usando o mesmo método.

Note que quando usamos 'add', sempre adicionamos o elemento pro fim da ArrayList.

Confirme isso agora, vendo que a banda "Iron Maiden" ficará depois de "Beatles".

Vamos pegar o primeiro elemento, o elemento '0', através do método 'get':

bandas.get(0);

Note que é a banda "Rush", pois ela foi a primeira a ser adicionada.

Vamos adicionar o "Tiririca" na posição do "Rush", ou seja, na posição '0':

bandas.add(0,"Tiririca");

ou

bandas.add( bandas.indexOf("Rush"), "Tiririca");

Pois o método 'indexOf' retorna o índice em que ocorre "Rush".

Para saber o tamanho que tem seu ArrayList, basta usar o método 'size()':

bandas.size();

Feito isso, rapidamente remova o "Tiririca", pois alguém pode ver.

Para tal, use o método 'remove':

bandas.remove("Tiririca");

Ok. Não quer mais brincar de ArrayList? Remova tudo

bandas.clear();





import java.util.ArrayList; import java.util.Arrays;

public class arrayLists{ public static void main(String[] args){ ArrayList<String> bandas = new ArrayList<String> (); bandas.add("Rush"); System.out.print( "Adicionando a banda Rush: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); bandas.add("Beatles"); System.out.print( "Adicionando a banda Beatles: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); bandas.add("Iron Maiden"); System.out.print( "Adicionando a banda Iron Maiden: " ); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Quem está na índice 0: " ); System.out.println( bandas.get(0) ); System.out.print( "Adicionando Tiririca onde estava o Rush: " ); bandas.add( bandas.indexOf("Rush"), "Tiririca"); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Número de elementos na lista: " ); System.out.println( bandas.size() ); System.out.print( "Removendo o Tiririca: " ); bandas.remove("Tiririca"); System.out.println( Arrays.toString( bandas.toArray() ) ); System.out.print( "Removendo tudo: " ); bandas.clear(); System.out.println( Arrays.toString( bandas.toArray() ) ); }

}

Saída





Adicionando a banda Rush: [Rush] Adicionando a banda Beatles: [Rush, Beatles] Adicionando a banda Iron Maiden: [Rush, Beatles, Iron Maiden] Quem está na índice 0: Rush Adicionando Tiririca onde estava o Rush: [Tiririca, Rush, Beatles, Iron Maiden] Número de elementos na lista: 4 Removendo o Tiririca: [Rush, Beatles, Iron Maiden] Removendo tudo: []

7. Constantes

Constantes são o oposto das variáveis. A diferença está em não podermos atribuir

um novo valor, pois ele recebe um valor final imutável. Isso ajuda na hora que temos que

lembrar de algum número muito grande ou muito pequeno, ou até mesmo um valor que

aparentemente não nos diz nada, mas que significa alguma coisa.

Um exemplo bem simples seria 000000. Mas, o que é 000000? É difícil saber o que

ele significa, mas é muito mais fácil entender que preto em Java é Color.BLACK. Ou seja,

BLACK é uma constante que guarda sempre o mesmo valor (000000).

Para criarmos uma constante em Java é muito simples. Primero nos atemos ao fato

de que uma constante criada dentro de uma classe deve ser acessada por qualquer

membro da classe, então, por definição, essa constante é também global ou estática

(static). Como uma constante não muda seu valor, então, marcamos ela com a palavra

chave final, que fará com que o valor nunca seja modificado.

Toda constante é um dado, portanto, o seu tipo de dado também é obrigatório

declarar. Então, para declarar uma constante faríamos:

static final long CONST1 = 1L; ou final long CONST2 = 1L;





No qual, CONST1 seria uma constante global (ou seja, foi declarada no corpo da classe)

e CONST2 seria uma constante local (ou seja, foi declarada no corpo de alguma função

ou método, por exemplo, dentro de main)

Para ilustrar bem o uso de constantes, vamos calcular a área e o comprimento de

um círculo. O porque deste cálculo é que necessitaremos de um número constante

chamado PI. PI é um número irracional, ou seja, não há uma representação exata dele,

mas, para o nosso exemplo, usaremos ele com uma precisão de 8 casas decimais.

Portanto, nosso pi será do tipo double que valerá 3,14159265. Então, perceba que é

muito mais fácil se lembrar da palavra pi do que do número 3,14159265. Além de,

obviamente, digitarmos bem menos.

Então, só para esclarecer o que irá acontecer: O cálculo da área do círculo

equivale a raio2 × pi, e o comprimento é medido em 2 × raio × pi, no qual o raio é a

distância entre a borda do círculo e seu centro.

Vamos usar um raio de 25cm. Vejamos o resultado.

public class Constantes { static final float PI = 3.14159265f; public static void main(String args[]) { float raio = 25f; float comprimento = raio * 2 * PI; float area = (raio * raio) * PI; System.out.println("Dados de um círculo de " + raio + "cm:\n" + "comprimento: " + comprimento + "cm\n" + "Área: " + area + "cm2"); } }

Exite uma infinidade de constantes que são implementadas em várias classes

diferentes como por exemplo BLACK da classe Color, PLAIN_MESSAGE da classe

JOptionPane e até mesmo o PI da classe Math com muito mais precisão do que este que





usamos no exemplo.

8. Funções

Funções são rotinas ou sub-rotinas automatizadas. Sempre que pretendemos usar

a mesma codificação para algo específico, criamos uma função. Dessa forma, sempre

que quisermos utilizar aquela codificação, ao invés de nós a digitarmos inteira novamente,

simplesmente chamamos a função. Funções são extremamente úteis e adaptáveis, e o

conceito de funções é importante para mais a frente entendermos o funcionamento e

criação dos métodos.

8.1. Criando funções sem argumentos

Para criar uma função, temos que ter sempre em mente que toda função é global,

ou seja, é estática (static). As funções mais básicas são aquelas que apenas executam

uma rotina, portanto, não recebem nenhum argumento. No código, digitaríamos dentro da

classe, mas fora da função main o seguinte:

public static void nomeDaFunção () {

código da função

}

Static porque pode ser acessado globalmente; void porque não retorna nenhum valor;

mesmo não tendo argumentos, é necessário ter parênteses.





Vamos ver o exemplo:

public class ExemploFuncao { //criando a função public static void mostrarMensagem() { System.out.println("Minha Mensagem"); } public static void main(String[] args) { //chamando a função dentro do programa mostrarMensagem(); }}

O código acima funciona da seguinte maneira:

Primeiro é criada a função mostrarMensagem(), que em seu corpo tem apenas um

println com uma mensagem. Depois iniciamos nosso programa com o main. Dentro do

main chamamos a função. Para isso, basta colocar o nome da função. Quando a função é

chamada, o código dentro do corpo da função é executado. Concluindo, o programa

acima apenas mostra na tela a mensagem Minha Mensagem.

8.2. Funções com argumentos

Funções com argumentos funcionam e são criadas da mesma forma que uma

função sem argumento, porém com uma diferença. A diferença está que haverá

informações necessárias para que a função processe, e essas informações serão

descritas dentro dos parênteses.

Uma função pode ter um ou vários argumentos desde que separados por vírgula

(,). Cada argumento deve ter seu tipo de dado declarado. Então, todos os exemplos

abaixo são funções válidas:





public static void funcao1 (String arg1){}

public static void funcao2 (int arg1, int arg2){}

public static void funcao3 (String arg1, char arg2, int arg3, float arg4, Object arg5) {}

Para demonstrar este tipo de função criaremos uma função que mostra na tela o

resultado fatorial de um número. Além disso, colocaremos esta função dentro de um loop

que irá de 1 a 10 para ele mostrar cada um desses fatoriais.

public class FatorialComFuncao {

public static void fatorar(int numero) {

int fator = 1; for (int i = numero; i > 1; i--) { fator *= i; } System.out.println(numero + "! = " + fator); }

public static void main(String args[]) {

for (int x=1; x<=10; x++) fatorar (x); }}

Simplificando, x que está sendo passado pelo main para fatorar() será o valor int

numero da função fatorar.

8.3. Funções que retornam valores

Aqui veremos a grande vantagem de se criar uma função. Funções podem retornar

valores de um processo executado dentro delas e esse valor pode ser guardado dentro de





uma variável no programa. Isso com certeza deixa nosso código mais simples, pois

podemos destacar processos repetitivos e guardar em uma variável apenas o resultado

daquele processo.

Para criar uma função que retorna valores temos que nos ater ao fato retorno.

Como todas as outras funções não retornavam valores, então, seu retorno era vazio -

void. Agora, temos que declarar que tipo de retorno virá da função.

O retorno é dado pelo comando return, que finaliza a função e mostra o retorno. A

variável ou valor que utilizarmos para return será o tipo de retorno da função.

Vamos imaginar que três funções, sendo que a primeira irá retornar um inteiro, a

segunda um double e a terceira uma string. Então, as criaríamos da seguinte maneira:

public static int funcaoDeInteiro (){}

public static double funcaoDeDouble (){}

public static String funcaoDeString (){}

No exemplo abaixo, nós criaremos uma função que irá retornar um valor booleano

(verdadeiro ou falso). Usando este retorno, determinaremos o que fazer dentro de uma

estrutura seletiva (if).

public class Primo {

public static boolean ehPrimo(long nr) { if (nr < 2) return false; for (long i = 2; i <= (nr / 2); i++) { if (nr % i == 0) return false; } return true;





}

public static void main(String[] args) {

long x = 5; if (ehPrimo(x)) // se for primo System.out.println(x + " é primo"); else // se não for primo System.out.println(x + " não é primo"); }}

O algoritmo utilizado acima é muito solicitado em cursos de programação e

faculdades. O que a função faz é verificar se um número é primo ou não.

9. Igualdade de Objetos em java - equals() e hashCode()

Um dos maiores problemas que os programadores encontram ao inciar seu

trabalho em java é o de entender os testes de igualdade. A igualdade em java não pode

ser testada através do operador == , estes operador apenas verifica se duas variáveis

fazem referencia a mesma instancia de um objetos.

Para ser um pouco mais claro, imaginemos uma classe Pessoa, como segue

abaixo.

public class Pessoa {

private String nome;

private String cpf;

public Pessoa(String nome, String cpf){

this.nome= nome;

this.cpf = cpf;


http://www.google.com/search?hl=en&q=allinurl%3AString+java.sun.com&btnI=I'm%20Feeling%20Lucky







}

public String getNome(){

return nome;

}

public String getCpf() {

return cpf;

}

}

Como posso eu falar que duas pessoas são as mesmas pessoas ? a JVM (Java

Virutal Machine) por se só não tem como identificar como duas pessoas podem ser ditas

iguais, desta forma o teste abaixo, verifica apenas se estas são instancias de um mesmo

objeto.

Pessoa maria = new Pessoa("Maria da Silva","111.222.333-44");

Pessoa mariaDaSilva = new Pessoa("Maria da Silva","333.555.222-11");

Apesar dos nomes iguais de maria e mariaDaSilva, os cpfs são diferentes e desta

forma posso falar que são pessoas diferentes.

Pessoa mariaDaSilva2 = new Pessoa("Maria da Silva","333.555.222-11");

Os Objetos mariaDaSilva e mariaDaSilva2 são pessoas iguais, em um teste de

igualdade eu vou querer que para esses 2 objetos ele seja positivo, porem são 2

instancias de de objetos diferentes, portanto:







boolean referencia = mariaDaSilva == mariaDaSilva2;

System.out.println("Referencia é falso ("+ referencia +)");

Isso ocorre porque a variável mariaDaSilva aponta para um objeto enquanto a

variável mariaDaSilva2 aponta para outro objeto.

9.1. Equals:

Para resolver esse problema em java existe um mecanismo de igualdade que vem

em todo objeto, e descende da classe Object, onde você pode testar a igualdade entre

objetos através de: este teste, quando não sobrescrito apenas testa se os 2 objetos são

referencia de uma mesma instancia.

Antes de implementar um equals em nossos objetos é preciso saber de cinco

regras.

• É reflexivo: para qualquer qualquer referencia não nula a, a.equals(a) tem sempre

que ser verdadeiro, ou seja, um objeto é sempre igual a se mesmo.

• É simétrico: para quaisquer referencias não nulas de a e b, a.equals(b) so poderá

retornar verdade se b.equals(a) retornar verdade, o mesmo raciocínio vale para

falso.

• É transitivo: para quisquer referencias não nulas de a,b e c, se a.equals(b) e

b.equals(c) são verdade então também tem que ser verdade que a.equals(c).

• É consistente - para quaisquer referencias não nulas de a e b, múltiplas invocações

de a.equals(b) terá sempre que retornar true ou sempre retornar false, enquanto

informações usadas na comparação do equals não sejam alteradas.

• O resultado de equals() entre um objeto e nulo deve retornar sempre falso,


http://www.google.com/search?hl=en&q=allinurl%3ASystem+java.sun.com&btnI=I'm%20Feeling%20Lucky




a.equals(null) é sempre falso.

Com essa ideia podemos pensar em como implementar o equals para nossa classe

Pessoa, sabemos que, duas Pessoas de mesmo nome podem ser diferente, portanto

esse não pode ser nosso parâmetro para teste. Duas pessoas não podem ter o mesmo

número de CPF, então este número é único, e pode identificar uma pessoa, sendo assim

nosso teste de igualdade entre duas pessoa pode ser.

Com essa ideia podemos pensar em como implementar o equals para nossa classe

Pessoa, sabemos que, duas Pessoas de mesmo nome podem ser diferente, portanto

esse não pode ser nosso parâmetro para teste. Duas pessoas não podem ter o mesmo

número de CPF, então este número é único, e pode identificar uma pessoa, sendo assim

nosso teste de igualdade entre duas pessoa pode ser:

@Override

public boolean equals(Object obj){

if(obj == null){

return false;//nenhum objeto pode ser igual a null

}

if(!obj instanceof Pessoa) {//uma pessoa só pode ser igual a outra pessoa

return false;

}

final Pessoa other = (Pessoa) obj;

if (getCpf() ==null)//se não houver CPF não há como testar as duas pessoas.

return false;

return getCpf().equals(other.getCpf()); //duas pessoas serão iguais...

//se seus CPFs forem iguais...

}


http://www.google.com/search?hl=en&q=allinurl%3AObject+java.sun.com&btnI=I'm%20Feeling%20Lucky




9.2. HashCode:

Assim como há um teste de igualdade, Java ainda dispõem de outro teste, onde é

possível rapidamente, através de integer, restringir o campo de igualdade, através de

hashCode(). assim como equals, o hashCode segue um contrato descrito abaixo:

• É constante: A qualquer momento durante a excecução de um programa java, o

método hashCode deve constantemente retornar o mesmo inteiro, enquanto

informações usadas na comparação do equals não sejam alteradas. O hashCode

não precisa ser constante de uma execução da aplicação para outra.

• Se dois objetos a e b, são iguais, a.equals(b) retorna verdadeiro, então os inteiros

produzidos por a e b devem ser os mesmos, ou seja a.hashCode() ==

b.hashCode()

• O inverso não é necessariamente verdadeiro, dois objetos que produzirem o

mesmo hashCode podem ser diferentes

Diante disso a utilização do hashCode é principalmente para excluir igualdade, ou

seja, ele serve como uma peneira, e é largamente utilizado por Collection em buscas

como contains, remove, removeAll, retainAll entre outras coisas. A ideia é se os hashCode

são diferentes então não é preciso testar a igualdade, pois já se garante que os objetos

não serão iguais, poupando processamento no momento da busca, pois hashCode usa

um calculo com int, que consome pouco processo, geralmente bem menos que o equals.

Existem varias estrategias para calculo do hashCode, desde a mais simples, onde

você praticamente exclui a funcionalidade do hashCode, deixando seu valor constante

para qualquer objeto.





@Override

public int hashCode(){ return 0;}

Este método acima, funciona e respeita as regras de contrato de hashCode, porem

seu programa poderá perder em velocidade. É extremamente desaconselhável o uso de

hashCode constante para qualquer objeto, pois várias funcionalidade que otimizam

processos de busca não terão serventia com um hashCode mau projetado.

A melhor estratégia para hashCode é olhar para equals, e verificar como a

igualdade é exigida, e assim montar um hashCode, concatenando os hashCode dos

objetos que fazem a igualdade e designando um peso para as propriedades.

Por exemplo, para nossa classe Pessoa uma boa estrategia de hashCode seria:

@Override

public int hashCode() { int hash = 7; hash = 23 * hash + (getCpf() != null ? getCpf().hashCode() : 0); return hash;}

O número 7 contido nesse hashCode é apenas um número randômico para startar

o hashCode, e diferenciar de outros objetos, por exemplo, um objeto empresa poderia

iniciar por 3. o número 23 é outro número randômico, usado para quando há varias

propriedades e escalar o hashCode entre as varias propriedade que definem um objeto

igual.

Como no exemplo acima usamos o hashCode da string cpf, e como String tem seu

hashCode bem implementando, podemos assim garantir que sempre que os CPF forem

iguais os hashCode serão iguais.





A igualdade entre objetos é uma parte fundamental da programação, e é uma das

necessidades básica de logica, saber se dois objetos são iguais. A implementação destes

dois métodos é importante, e deve ser implementado em todas as classes instanciáveis

do projeto, de forma a prover mecanismos corretos de comparação de igualdade (equals),

assim como uma forma de otimizar os processos de busca (hashCode).

Muitos programadores só começam a entender a real necessidade da correta

implementação destes dois métodos ao utilizar mais largamente a Java Collection

Framework do pacote java.util, pois vários de seus métodos como contains, removeAll,

remove, ratainAll, etc, falham quando equals não esta corretamente implementado, e

perdem performance ou falham quando hashCode não esta otimizado ou corretamente

implementando.

10. Representação textual de objetos - método toString()

O Java usa o método toString() toda vez que for necessário converter um objeto

em String, ou seja, para obter uma representação textual do objeto. Por exemplo para

imprimir um objeto qualquer usando System.out.println ou para mostrar os itens de um

JComboBox (usando o Renderer padrão).

Esse método toString() é definido na classe Object, portanto é herdado por todos

os objetos - todos os objetos são capazes de gerar uma representação textual. Mas o

método do Object não conhece as classes derivadas, não sabe como o objeto deve ser

representado. Por isso usa um padrão: o nome da classe seguido por um '@' e pelo

hashCode em hexadecimal da instância em questão:

public String toString(){

return getClass().getName() + "@" + Integer.toHexString(hashCode()); }





Exemplo:

public class Pessoa {

private final String nome;

private int idade;

public Pessoa(String oNome, int aIdade){ nome = oNome; idade = aIdade; }

public static void main(String[] args) { Pessoa pessoa = new Pessoa("fulano", 21); System.out.println(pessoa); //equivale a System.out.println(pessoa.toString()); } }

vai imprimir algo como "Pessoa@1b533b0" (provavelemnte com outro número).

Esse formato normalmente não é o que queremos! Por isso temos que sobrescrever o

método toString() para obter a representação desejado.

Exemplo, para mostrar o nome e a idade (entre parênteses) da pessoa,

adicionamos o método toString():

public class Pessoa { private final String nome; private int idade; public Pessoa(String oNome, int aIdade) { nome = oNome; idade = aIdade; } @Override public String toString() { return nome + "(" + idade + ")"; }





public static void main(String[] args) { Pessoa pessoa = new Pessoa("fulano", 21); System.out.println(pessoa); } }

Dessa vez obteremos, como desejado "fulano(21)". O mesmo problema ocorre com

um vetor (Array):

... public static void main(String[] args) { int[] array = {1, 2, 3}; System.out.println(array); } ...

Irá imprimir algo como "[I@15497e0" - "[I" representa um array de int's. O problema

é que não tem como sobrescrever o toString() de um Array, mas podemos usar a classe

auxiliar Arrays do pacote java.util que contém vários métodos estáticos para trabalhar com

um Array. No nosso caso podemos usar o toString(int[]):

... public static void main(String[] args) { int[] array = {1, 2, 3}; System.out.println(Arrays.toString(array)); } ...

Imprimirá "[1, 2, 3]"@146c21b

A em síntese o problema é sempre que obter algo como "Classe@146c21b" é

porque a classe em questão não sobrescreveu o método toString().

A solução, é implementar/sobrescrever o método toString() do Objeto ou usar o

Arrays.toString() se for um Array. (Exemplos acima)





11. Instanciando Objetos

Objetos são estruturas de dados definidas e agrupas dentro de uma classe.

Sempre que utilizamos um objeto ou classe devemos reservar espaço em memória para

que aquele objeto seja manipulado sem maiores problemas.

Além do mais, também podemos utilizar a mesma classe (com todos os seus

métodos e atributos) para manipular outros objetos que serão tratados de forma diferente

(mesmo se tiverem as mesmas características do objeto anterior), pois serão dois

endereços de memória diferentes.

A vantagem de Java é nos possibilitar uma instanciação rápida e simples, sem

termos que nos preocupar com referência a endereços e alocação dinâmica de memória,

pois quem trata de manipular a memória é o próprio Java. Sem contar que, se um objeto

não é mais referenciado dentro do programa, o próprio Java trata de liberar os recursos

de memória consumidos pelo objeto usando o Garbage Colletor - Coletor de Lixo.

Quem faz o papel de instanciador em Java é o new. New trata de reservar memória

o suficiente para o objeto e criar automaticamente uma referência a ele. Para new

conseguir determinar o objeto, precisamos usar o método construtor que será usado

como base para instanciar a classe e gerar o objeto.

Tecnicamente, declaramos uma variável qualquer como sendo do tipo da classe

(ex.: TV minhaTV; ), depois instanciamos o objeto atribuindo a variável o resultado obtido

por new mais o método construtor (ex.: minhaTV = new TV(); ).

Apesar de parecer muitos detalhes, isso fica mais facilmente visualizado no código

abaixo.





public class TV { int tamanho; int canal; boolean ligada; TV() { tamanho = 21; canal = 0; ligada = false; }

public static void main(String[] args) { TV objeto1 = new TV(); TV objeto2; objeto2 = new TV(); } }

No código acima, criamos uma classe chamada TV com os mesmos atributos do

exemplo da página Criação de Classes, e criamos um método construtor que inicializa os

atributos da classe TV com alguns valores. Declaramos duas variáveis chamadas objeto1

e objeto2 sendo do tipo TV. Depois, instanciamos o objeto usando new e o método

construtor.

12. Auto Referencia de Objetos - This

This é usado para fazer auto-referência ao próprio contexto em que se encontra.

Resumidamente, this sempre será a própria classe ou o objeto já instanciado.

Esse conceito de auto-referência é importante para que possamos criar métodos

construtores sobrecarregados e métodos assessores mais facilmente. Por base, se

criarmos um método que receba um argumento chamado ligado que queremos atribuir

para o atributo da classe, que também se chama ligado, devemos diferenciar ambos





mostrando a quem cada um pertence.

Como this se refere ao contexto empregado, então o usamos para identificar que

ligado será o atributo da classe e ligado sem o this se refere ao parâmetro do método. O

que resultaria nisto:

public class TV { //atributos int tamanho; int canal; boolean ligada;

// método contrutor com parâmetro TV(boolean ligada) { this.ligada = ligada; /** * Onde this.ligada é o atributo * e ligada é o valor do parâmetro */ }}

Traduzindo, this.ligada seria: a variável ligada desta classe recebe o valor de

ligada, ou seja, o único ligada que existe fora o atributo é o parâmetro.

13. Sobrecarga de métodos

Java nos permite criar vários métodos com o mesmo nome desde que tenham

parâmetros diferentes. Isso é o que chamamos de sobrecarga de métodos. A sobrecarga

de métodos consiste em criarmos o mesmo método com possibilidades de entradas

diferentes.

Essas entradas, caracterizadas como parâmetros, devem sempre ser de tipos

diferentes, quantidades de parâmetros diferentes ou posições dos tipos diferentes.





Para visualizarmos um cenário, vejamos a classe abaixo:

public TV { int canal; int volume; boolean ligada; int tamanho; }

Agora, criaremos o método ligar. O método ligar, simplesmente, muda o valor dos

atributos canal e volume para 3 e 25, respectivamente.

void ligar (){ canal = 3; volume = 25; ligada = true; }

Agora, vamos personalizar este método para que ele mude o atributo ligada de

acordo com o parâmetro.

void ligar (boolean ligada){ canal = 3; volume = 25; this.ligada = ligada; }

Embora os dois métodos tenham o mesmo nome, poderíamos utilizar ambos os na

mesma classe se quisermos, porque um possui argumentos e o outro não.

void ligar (){ canal = 3; volume = 25; ligada = true; } void ligar (boolean ligada){ canal = 3;





volume = 25; this.ligada = ligada; }

Porém, o mesmo não pode ser aplicado aos atributos canal e volume. Porque não

é possível criar um método que recebe um inteiro e criar um outro método com o mesmo

nome que também recebe um inteiro, mesmo que estes dois inteiros sejam totalmente

diferentes. Se visualizarmos como Java interpreta o método, veríamos:

void ligar (int volume) = void ligar (int canal)

void ligar (int) = void ligar (int)

Por outro lado, é perfeitamente possível criarmos dois métodos que recebam um

booleano e um inteiro, inclusive se forem os mesmos, mas em posições diferentes. Isso

acontece porque Java não verifica o nome do parâmetro, mas apenas o tipo dele.

void ligar (boolean ligada, int canal) ≠ void ligar (int canal, boolean ligada)

void ligar (boolean, int) ≠ void ligar (int, boolean)

Portanto, podemos fazer muitas combinações desde que essas combinações não

sejam em números iguais, de tipos iguais e nas mesmas posições.

Abaixo, está a classe com algumas combinações possíveis. É um bom costume

sempre referenciar para o método que recebe mais argumentos.

public class TV { int canal; int volume; boolean ligada; int tamanho;

void ligar() { this.ligar(3, 25, true); }





void ligar(boolean ligada) { this.ligar(3, 25, ligada); }

void ligar(int canal, int volume) { this.ligar(canal, volume, true); }

void ligar(int canal, int volume, boolean ligada) { this.canal = canal; this.volume = volume; this.ligada = ligada; }}

14. Acesso a Membros e Métodos

Vimos, até agora, como criar uma classe, definir um método construtor,

sobrecarregar métodos e instanciar objetos. Nesse momento, vamos ver como acessar

seus membros e métodos.

Os acessos a membros ou métodos de uma classe são dados a partir do objeto

instanciado usando um separador que é o ponto (.).

Portanto, para acessar qualquer membro da classe, basta que usemos o nome do

objeto, mais um ponto e o nome do membro que queremos acessar. Ainda tomando como

exemplo a classe TV já vista antes, vamos modificar dentro do programa dois atributos: os

atributos canal e volume.






public TV(){ this.tamanho = 21; this.ligada = true; }

public static void main (String args []){ TV minhaTV = new TV(); minhaTV.canal = 3; minhaTV.volume = 25; } }

Como percebemos é construído um objeto chamado minhaTV da classe TV com o

tamanho de 21" e já ligada. Durante a execução do programa modificamos diretamente

seu canal e volume usando o objeto que instanciamos.

Da mesma forma que acessamos um atributo, também podemos acessar um

método. No exemplo abaixo, criaremos o método para aumentar volume da TV.

public class TV {

int canal; int volume; boolean ligada; int tamanho;

public TV(){ this.tamanho = 21; this.ligada = true; this.canal = 3; this.volume = 25; }

public void aumentarVolume(){ this.volume += 5; }

public static void main (String args []){





TV minhaTV = new TV(); minhaTV.aumentarVolume(); } }

Aqui, o objeto minhaTV começa com volume 25 e depois de chamar seu método

aumentarVolume() fica com 30.

Algumas considerações que devemos ter é saber diferenciar funções de métodos.

Apesar da essência de ambos ser a mesma coisa, funções são chamadas estaticamente,

ou seja, ela pode ser chamada diretamente sem o intermédio de nenhum objeto.

Já os métodos são chamados de dentro das classes, portanto, obrigatoriamente

devemos ter um objeto instanciado para conseguirmos utilizar o método. Vejamos a

diferença:


public TV(){ this.tamanho = 21; this.ligada = false; this.canal = 0; this.volume = 0; }

// método da classe public void ligar(boolean ligada){ this.ligada = ligada; } // função public static void estahLigada (TV objeto){ if (objeto.ligada) System.out.println ("está ligada");





else System.out.println ("não está ligada"); } }

public static void main (String args []){ TV televisao1 = new TV(); TV televisao2 = new TV(); // chamando o método ligar televisao1.ligar(true); televisao2.ligar(false); System.out.print ("A televisão 1 "); // chamando a função estahLigada estahLigada (televisao1); System.out.print ("A televisão 2 "); estahLigada (televisao2); }

Observemos que chamamos o método ligar() de cada objeto, portanto, existem

dois métodos ligar distintos - o método ligar() da televisao1 e o método ligar() da

televisao2. A função é estática, portanto, existe apenas uma função estahLigada().

15. Encapsulamento - public, private e protected

Se outros programadores usam nossa classe, nós queremos garantir que erros

pelo mau uso não ocorram. Encapsulamento serve para controlar o acesso aos atributos

e métodos de uma classe.

É uma forma eficiente de proteger os dados manipulados dentro da classe, além de

determinar onde esta classe poderá ser manipulada. Usamos o nível de acesso mais

restritivo que faça sentido para um membro particular. Sempre usamos private, a menos

que tenhamos um bom motivo para deixá-lo com outro nível de acesso.

Não devemos permitir o acesso público aos membros, exceto em caso de ser





constantes. Isso porque membros públicos tendem a nos ligar a uma implementação em

particular e limita a nossa flexibilidade em mudar o código.

Basicamente, usamos quatro tipos de encapsulamento que são divididos em dois níveis:

• Nível de classe ou topo: Quando determinamos o acesso de uma classe inteira que

pode ser public ou package-private (padrão);

• Nível de membro: Quando determinamos o acesso de atributos ou métodos de uma

classe que podem ser public, private, protected ou package-private (padrão).

Para utilizarmos estes modificadores de acesso, basta que nós os digitemos antes

do nome da variável, atributo, método, função ou classe, com exceção de

package-private, que é entendido como padrão, portanto, é qualquer membro ou classe

que não tenha modificador especificado.

Exemplo:

public class MinhaClasse { //classe public private int inteiro; //atributo inteiro private protected float decimal; //atributo float protected boolean ativado; //atributo booleano package-private }

15.1. Public

O modificador public deixará visível a classe ou membro para todas as outras

classes, subclasses e pacotes do projeto Java.





15.2. Private

O modificador private deixará visível o atributo apenas para a classe em que este

atributo se encontra.

15.3. Protected

O modificador protected deixará visível o atributo para todas as outras classes e

subclasses que pertencem ao mesmo pacote. A principal diferença é que apenas as

classes do mesmo pacote tem acesso ao membro. O pacote da subclasse não tem

acesso ao membro.

15.4. Sem Modificador (Padrão)

Por padrão, a linguagem Java permite acesso aos membros apenas ao pacote em

que ele se encontra. De forma ilustrativa, abaixo está uma tabela demonstrando todas

estas características.

Modificador Classe Pacote Subclasse Globalmente

Public sim sim sim sim

Protected sim sim sim não

Sem Modificador (Padrão) sim sim não não

Private sim não não não

Fonte: Controlling Access to Members of a Class


http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html




15.5. Métodos Acessores - Getters e Setters

Como visto anteriormente, o encapsulamento "protege" os atributos ou métodos

dentro de uma classe, portanto devemos prover meios para acessar tais membros quando

eles são particulares, ou seja, quando possuem o modificador private.

O que torna isso possível é a criação de métodos.

Em programação orientada a objetos, esses métodos são chamados de métodos

acessores ou getters e setters, pois eles provêm acesso aos atributos da classe, e

geralmente, se iniciam com get ou set, daí a origem de seu nome.

Na verdade, não há nada de diferente entre os métodos comuns e os métodos

acessores. A única importância está no fato da orientação a objeto. Pois, sempre que

formos acessar um membro em Java usaremos get ou set.

15.5.1. Set

Nomeamos um método acessor com set toda vez que este método for modificar

algum campo ou atributo de uma classe, ou seja, se não criarmos um método acessor set

para algum atributo, isso quer dizer que este atributo não deve ser modificado.

Portanto, como o valor de um atributo da classe será modificado, não é necessário

que este método retorne nenhum valor, por isso, os métodos setters são void. Porém,

obrigatoriamente, eles tem que receber um argumento que será o novo valor do campo.





15.5.2. Get

Nomeamos um método acessor com get toda vez que este método for verificar

algum campo ou atributo de uma classe. Como este método irá verificar um valor, ele

sempre terá um retorno como String, int, float, etc. Mas não terá nenhum argumento.

15.5.3. Is

Nomeamos um método acessor com is toda vez que este método for verificar

algum campo ou atributo de uma classe que tenha retorno do tipo boolean. Levando em

consideração as informações acima, nossa classe de exemplo TV ficaria:

public class TV {

private int tamanho; private int canal; private int volume; private boolean ligada; public TV(int tamanho, int canal, int volume, boolean ligada) { this.tamanho = tamanho; this.canal = canal; this.volume = volume; this.ligada = ligada; }

public int getTamanho() { return tamanho; }

public void setTamanho(int tamanho) { this.tamanho = tamanho; }





public int getCanal() { return canal; }

public void setCanal(int canal) { this.canal = canal; }

public int getVolume() { return volume; }

public void setVolume(int volume) { this.volume = volume; }

public boolean isLigada() { return ligada; }

public void setLigada(boolean ligada) { this.ligada = ligada; } }

16. Herança

Enquanto programamos em Java, há a necessidade de trabalharmos com várias

classes. Muitas vezes, classes diferentes tem características comuns, então, ao invés de

criarmos uma nova classe com todas essas características usamos as características de

um objeto ou classe já existente.

Ou seja, herança é, na verdade, uma classe derivada de outra classe. Para

simplificar de uma forma mais direta, vejamos:





Vamos imaginar que exista uma classe chamada Eletrodoméstico, e nela estão

definidos os seguintes atributos: ligado (boolean), voltagem (int) e consumo (int). Se

levarmos em conta a classe TV que estamos usando de exemplo até agora, podemos

dizer que TV deriva de Eletrodoméstico. Ou seja, a classe TV possui todas as

características da classe Eletrodoméstico, além de ter suas próprias características.

Extends e Super Para fazermos uma classe herdar as características de uma outra,

usamos a palavra reservada extends logo após a definição do nome da classe. Dessa

forma:

class NomeDaClasseASerCriada extends NomeDaClasseASerHerdada

Importante: Java permite que uma classe herde apenas as características de uma única

classe, ou seja, não pode haver heranças múltiplas. Porém, é permitido heranças em

cadeias, por exemplo: se a classe Mamifero herda a classe Animal, quando fizermos a

classe Cachorro herdar a classe Mamifero, a classe Cachorro também herdará as

características da classe Animal.

Como estamos tratando de herança de classes, toda classe tem seu método

construtor. Portanto, se estamos trabalhando com duas classes, temos dois métodos

construtores. Para acessarmos o método construtor da classe que está sendo herdada

usamos o super().





Podemos usar o super para qualquer construtor da classe pai, pois o Java consegue

diferenciar os construtores por causa da sobrecarga de métodos. Para finalizar, iremos

mostrar o exemplo citado mais acima da classe Eletrodomestico e TV.

Observe:

Classe 1: Eletrodomestico

package br.com.primebean;

public class Eletrodomestico {

private boolean ligado; private int voltagem; private int consumo;

public Eletrodomestico(boolean ligado, int voltagem, int consumo) { this.ligado = ligado; this.voltagem = voltagem; this.consumo = consumo; } // (...) }

Classe 2: TV


public class TV extends Eletrodomestico {

private int private int private int

public TV(int voltagem, int consumo, int canal, int volume, int tamanho) { super(false, voltagem, consumo); this.canal = canal; this.volume = volume; this.tamanho = tamanho; }





//(...)}

Classe que mostra a instanciação de TV.


public class ExemploHeranca {

public static void mostrarCaracteristicas(TV obj) { System.out.print("Esta TV tem as seguintes características:\n" + "Tamanho: " + obj.getTamanho() + "\"\n" + "Voltagem Atual: "+ obj.getVoltagem() + "V\n" + "Consumo/h: " + obj.getConsumo() + "W\n");

if (obj.isLigado()) { System.out.println("Ligado: Sim\n" + "Canal: " + obj.getCanal() + "\n" + "Volume: " + obj.getVolume()+"\n"); } else { System.out.println("Ligado: Não\n"); } }

public static void main(String args[]) { TV tv1 = new TV(110, 95, 0, 0, 21); TV tv2 = new TV(220, 127, 0, 0, 29); tv2.setLigado(true); tv2.setCanal(3); tv2.setVolume(25); mostrarCaracteristicas(tv1); mostrarCaracteristicas(tv2); } }

O código acima irá mostrar o seguinte resultado:

Esta TV tem as seguintes características:

Tamanho: 21"





Voltagem Atual: 110V

Consumo/h: 95W

Ligado: Não

Esta TV tem as seguintes características:

Tamanho: 29"

Voltagem Atual: 220V

Consumo/h: 127W

Ligado: Sim

Canal: 3

Volume: 25

17. Enum

Java nos possibilita criar uma estrutura de dados enumarada. Essas estruturas de

dados enumeradas são conjuntos de constantes organizados em ordem de declaração,

ou seja, o que é declarado primeiro virá primeiro. A funcionalidade principal de enum é

agrupar valores com o mesmo sentido dentro de uma única estrutura, como por exemplo,

meses, dias da semana, cores, tabela periódica, etc. e também limitar ou determinar

número de valores que podem ser usados na programação.

Embora sua funcionalidade é totalmente diferente, a criação de uma estrutura

enumerada é parecida com uma classe. Basta trocarmos a palavra-chave class pela

palavra-chave enum. Mas, devemos levar em consideração alguns fatores:





1. Uma estrutura enum deve ter seu próprio arquivo da mesma forma que acontece com

as classes públicas. Por exemplo, se nós implementarmos uma classe pública chamada

HelloWorld, então, deve haver um arquivo chamado HelloWorld.java. Se criarmos um

enumerador chamado Cores, então, deve haver um arquivo chamado Cores.java.

2. Estruturas enum não são instanciáveis. Ou seja, estruturas enum não possuem um

método construtor, portanto, não há como usar o instanciador new.

3. Estruturas enum são apenas declaráveis. Portanto, toda a lista de constantes

declaradas dentro desta estruturas são acessados estaticamente. Ou seja, nome da

variável, mais ponto (.) e o nome da constante (Suposição: mes.JANEIRO).

4. Toda estrutura enum possui um método para acessar seus valores em forma de array

(vetor) chamado values().

Abaixo está uma estrutura enum:

public enum Cores { PRETO, BRANCO, PRATA; }

Agora que temos nosso "kit de constantes" podemos usar em nossa classe.

public class TV {

private int tamanho; private int canal; private int volume; private boolean ligada; //declaração da variável do tipo Enum Cores private Cores cor;

public TV(int tamanho, Cores cor) { this.tamanho = tamanho; this.canal = 0;





this.volume = 25; this.ligada = false; this.cor = cor; }

public int getTamanho() { return tamanho; } public int getCanal() { return canal; } public int getVolume() { return volume; } public Cores getCor() { return cor; }

public static void main(String args[]) { TV minhaTV = new TV(29, Cores.PRATA); /** * acessando estaticamente (diretamente) * o valor PRATA do enum Cores **/ System.out.println("Características da minha TV:" + "\nTamanho:" + minhaTV.getTamanho() + "\nCanal atual:" + minhaTV.getCanal() + "\nVolume atual:" + minhaTV.getVolume() + "\nCor: " + minhaTV.getCor()); }}

Estruturas enum também podem ser determinadas. Dessa forma, podemos atribuir

mais valores a mesma constante. Por exemplo, podemos fazer uma estrutura enum da

tabela periódica com os símbolos químicos tendo todos os valores possíveis da tabela

(Número Atômico, Peso Atômico e Nome do Elemento). Para fazer isso, no final da

enumeração, temos que declarar as constantes que foram usadas, assim:





... private final int numero; //constante para número atômico private final double peso; //constante para peso atômico private final String nome; //constante para nome do elemento ...

O fator do encapsulamento usando private aqui será muito importante, pois dessa

forma não haverá um meio de alterar o valor dessas constantes por acidente. Após isso,

criamos métodos para acessar esses valores.

... private int numero(); private double peso(); private String nome(); ...

Então, criamos a definição usada nas constantes. Essas definições se parecem

muito com os construtores de classes, mas sua função é apenas indicar o que é cada

uma das informações contidas em cada constante.

... NomeDoEnum (int numero, double peso, String nome){ this.numero = numero;this.peso = peso;this.nome = nome;...

Relembrando: Todas estas definições sempre devem vir após a definição das

constantes. No exemplo abaixo, está esta estrutura com apenas três elementos químicos.

public enum TabelaPeriodica {

// Declaração das constantes H (1, 1.00794, "Hidrogênio"), HE (2, 4.002602, "Hélio"), O (8, 15.9994, "Oxigênio");





/** * Por ser um exemplo, * não foram colocados * todos os elementos químicos * da Tabela Periódica **/

// Definição das constantes private final int numero; private final double massa; private final String nome; // métodos para acessar os valores private int numero() { return this.numero; } private double massa() { return this.massa; } private String nome() { return this.nome; }

//método que define as constantes private TabelaPeriodica(int numero, double massa, String nome) { this.numero = numero; this.massa = massa; this.nome = nome; }

public static void main(String args[]) { System.out.println("Dados do elemento químico H:"); System.out.println("\nNúmero: " + TabelaPeriodica.H.numero() + "\nMassa: " + TabelaPeriodica.H.massa() + "\nElemento: " + TabelaPeriodica.H.nome()); } }





18. Interfaces

Interface é um recurso da orientação a objeto utilizado em Java que define ações

que devem ser obrigatoriamente executadas, mas que cada classe pode executar de

forma diferente. Interfaces contém valores constantes ou assinaturas de métodos que

devem ser implementados dentro de uma classe. E por que isso?

Isso se deve ao fato que muitos objetos (classes) podem possuir a mesma ação

(método), porém, podem executá-la de maneira diferente.

Usando um exemplo bem drástico, podemos ter uma interface chamada aéreo que

possui a assinatura do método voar(). Ou seja, toda classe que implementar aéreo deve

dizer como voar(). Portanto, se eu tenho uma classe chamada pássaro e outra chamada

avião, ambas implementando a interface aéreo, então, nestas duas classes devemos

codificar a forma como cada um irá voar(). Uma interface é criada da mesma forma que

uma classe, mas utilizando a palavra-chave interface no lugar de class.

interface nomeDaInterface { métodoAbstrato (argumentos); }

18.1. Usando uma Interface em uma Classe

Como vimos anteriormente, uma classe pode extender suas funcionalidades

obtendo as características de outra classe num processo que chamamos de herança.

Uma interface não é herdada, mas sim, implementada. Porque todo o código dos métodos

da interface deve ser escrito dentro da classe que o chama. Dessa forma, obtemos as

assinaturas dos métodos da interface em uma classe usando a palavra- chave

implements.

A vantagem principal das interfaces é que não há limites de quantas interfaces uma

classe pode implementar. O que ajuda no caso de heranças múltiplas que não é possível





ser feito em Java, pois uma classe apenas pode herdar as características de uma outra

classe. Trazendo ao exemplo já usado por nós, teríamos o seguinte conceito.

1) Teríamos a classe principal que caracteriza a TV.

public class TV {

private int tamanho; private int canal; private int volume; private boolean ligada; public TV(int tamanho) { this.tamanho = tamanho; this.canal = 0; this.volume = 0; this.ligada = false; } // abaixo teríamos todos os métodos construtores get e set... }

2) Teríamos as ações que comumente toda televisão executa, mas que cada modelo pode

executar de forma diferente. Como geralmente toda ação da TV é executada pelo controle

remoto, então chamaremos esta interface de controle remoto.

public interface ControleRemoto {

/* * Perceba que apenas a assinatura dos métodos estão aqui. * E cada método termina com um ponto-e-vírgula (;) */

void mudarCanal(int canal); void aumentarVolume (int taxa); void diminuirVolume (int taxa); boolean ligar(); boolean desligar(); }





3) Agora que temos nossa interface e a definição do que é a TV, vamos desenvolver duas

TVs diferentes, imaginando que fossem duas marcas completamente distintas e que uma

não tem nenhuma relação com a outra.

Como ambas as TVs irão implementar a interface ControleRemoto, então, no corpo

das duas classes devem conter todos os métodos da interface. No exemplo usado abaixo,

apenas implementaremos os métodos ligar e desligar.

A TV modelo 001 é uma TV simples, sem muitos recursos que quando acionarmos

o comando desligar irá simplesmente desligar.

public class ModeloTV001 extends TV implements ControleRemoto {

public final String MODELO = "TV001"; public ModeloTV001(int tamanho) { super(tamanho); } public void desligar() { super.setLigada(false); } public void ligar() { super.setLigada(true); } public void aumentarVolume(int taxa) { } public void diminuirVolume(int taxa) { } public void mudarCanal(int canal) { } }

O modelo SDX é uma TV mais moderna, que quando acionarmos o comando

desligar irá apresentar uma mensagem dizendo "tchau!".

public class ModeloSDX extends TV implements ControleRemoto {

public final String MODELO = "TV-SDX";

public ModeloSDX(int tamanho) { super(tamanho);





} public void desligar() { System.out.println("Tchau!"); super.setLigada(false); } public void ligar() { super.setLigada(true); } public void aumentarVolume(int taxa) { } public void diminuirVolume(int taxa) { } public void mudarCanal(int canal) { } }

Como pode ser visto, ambos possuem a mesma ação que é desligar, porém cada

um executa de forma diferente.

public class ExemploInterfaceamento {


ModeloTV001 tv1 = new ModeloTV001(21); ModeloSDX tv2 = new ModeloSDX (42); tv1.ligar(); tv2.ligar(); System.out.print("TV1 - modelo " + tv1.MODELO + " está "); System.out.println(tv1.isLigada() ? "ligada" : "desligada"); System.out.print("TV2 - modelo " + tv2.MODELO + " está "); System.out.println(tv1.isLigada() ? "ligada" : "desligada"); }

// ambas as TVs estão ligadas e vamos desligá-las System.out.println("Desligando modelo " + tv1.MODELO); tv1.desligar(); System.out.println("Desligando modelo " + tv2.MODELO); tv2.desligar(); }

Se prestarmos atenção, apenas a TV2 mostrará uma mensagem quando for

desligada. Para visualizar melhor este exemplo, baixe o código exemplo e implemente os





métodos que faltam.

19. Annotations

Annotations, traduzindo, quer dizer anotações. Annotations dão informações sobre

o código que está sendo escrito ou até mesmo do próprio programa, o que se assemelha

aos comentários. Porém, annotations podem ser usados como objeto semântico de

compiladores, ou seja, compiladores podem interpretar as annotations.

Dessa forma é possível que compiladores entendam que, por exemplo, não é para

mostrar mensagens de advertências (Warnings), ou usar as annotations para detectar

erros de código, criar documentações usando XML, etc. Annotations podem possui

elementos ou não. Seus elementos são sempre pair values, ou seja, elemento tem um

nome e um valor.

19.1. Uso de Annotations

As annotations são sempre precedidas de arroba (@). Por convenção, usamos

annotations antes de um elemento qualquer, por exemplo, antes da criação de uma classe

ou do uso de um método. Existem annotations com vários pair values (valores diferentes)

que são separados por vírgula, que contenham apenas um valor ou simplesmente

nenhum valor. Exemplo: @SuppressWarnings(value = "unchecked").

Quando uma annotation possui apenas um elemento chamado value, então,

apenas é necessário atribuir seu valor sem declarar o nome value. Exemplo:

@SuppressWarnings("unchecked").

Quando uma annotation não possui elementos, não é necessário usar os parênteses.





Exemplo: @Override.

Abaixo está uma lista com algumas das annotations mais utilizadas.

• @Deprecated: Sempre que algum método tem seu uso desencorajado por ser perigoso

ou por ter uma alternativa melhor desenvolvida, então, ele recebe a anotação

@Deprecated.

• @Override: Usado principalmente em casos de polimorfismo, sempre que formos

sobrescrever um método da classe-pai (superclasse) devemos indicar ao compilador com

@Override. Mas, devemos tomar cuidado ao utilizar @Override, pois se marcarmos o

método e ele não sobrescrever nenhum método da classe-pai (superclasse), então, o

compilador gerará uma mensagem erro.

• @SuppressWarnings ("deprecation"): Todos os avisos da categoria "inadequado" são

ignorados.

• @SuppressWarnings ("unchecked"): Todos os avisos da categoria "não verificado" são

ignorados.

• @SuppressWarnings ({"unchecked", "deprecation"}): Todos os avisos de qualquer

categoria são ignorados.

19.2. Criando uma Annotation

Antes de criarmos uma annotation, primeiramente temos que nos ater ao fato de

que annotations apenas podem ser criadas em projetos que são compatíveis com JDK

5.0. Annotations são criadas de forma muito parecida com interfaces, diferenciando pelo

fato de antes da palavra-chave interface há um símbolo arroba (@), cada elemento se

parece com a declaração de um método abstrato, a nomenclatura utilizada é a mesma

utilizada para nomear Classes e cada annotation fica em um arquivo .java da mesma

forma que uma classe, classe abstrata ou interface.





public @interface MinhaAnnotation { String elemento1(); int elemento2(); }

Podemos definir um valor padrão para um elemento utilizando a palavra-chave default.

public @interface MinhaAnnotation { String elemento1() default "VALOR"; int elemento2() default 123; }

Também podemos utilizar vetores para a definição de um elemento.

public @interface MinhaAnnotation

String elemento1(); //elemento de String float elemento2(); //elemento de ponto flutuante int elemento3() default 1; //elemento inteiro que vale 1 por padrão String[] elemento4(); // elemento vetor de Strings}

Abaixo está um exemplo de como usar nossa própria annotation.

public @interface DetalhesSoftware { String [] desenvolvedor (); String nomeProjeto (); String software (); float versao () default 1.0f; }

Agora que temos nossa anotação, basta chamá-la.

@DetalhesSoftware ( desenvolvedor = ("Desenvolvedor1", "Desenvolvedor2", "Desenvolvedor3"), nomeProjeto = "Java Resources Checker",





software = "JRC", versao = 1.0f ) public class AlgumaClasse { //código da classe }

19.3. Adicionar Annotations ao Javadoc

Para fazer com que nossas annotations fiquem registradas no Javadoc toda vez

que ele for gerado, devemos importar o pacote java.lang.annotation.Documented e antes

de criarmos nossa annotation usarmos @Documented. Vejamos o exemplo abaixo:

import java.lang.annotation.Documented;

@Documented public @interface DetalhesSoftware { String software (); String nomeProjeto (); float versao () default 1.0f; String [] desenvolvedor (); }

20. Classes Abstratas e Métodos Abstratos

Classes abstratas tem uma função importante na orientação a objeto em Java. De

forma objetiva, uma classe abstrata serve apenas como modelo para uma classe concreta

(classe que comumente usamos).





Como classes abstratas são modelos de classes, então, não podem ser

instanciadas diretamente com o new, elas sempre devem ser herdadas por classes

concretas. Outro fato importante de classes abstratas é que elas podem conter ou não

métodos abstratos, que tem a mesma definição da assinatura de método encontrada em

interfaces. Ou seja, uma classe abstrata pode implementar ou não um método.

Os métodos abstratos definidos em uma classe abstrata devem obrigatoriamente

ser implementados em uma classe concreta. Mas se uma classe abstrata herdar outra

classe abstrata, a classe que herda não precisa implementar os métodos abstratos.

Para criarmos uma classe ou método abstrato usamos a palavra-chave abstract.

Para demonstrar, usaremos uma classe abstrata chamada Eletrodomestico, que servirá

de modelo para todos os objetos que possam ser eletrodomésticos.

package classeabstrata;

public abstract class Eletrodomestico { private boolean ligado; private int voltagem; // métodos abstratos // /* * não possuem corpo, da mesma forma que * as assinaturas de método de uma interface */

public abstract void ligar(); public abstract void desligar(); // método construtor // /* * Classes Abstratas também podem ter métodos construtores, * porém, não podem ser usados para instanciar um objeto diretamente */

public Eletrodomestico(boolean ligado, int voltagem) { this.ligado = ligado; this.voltagem = voltagem; } // métodos concretos





/* * Uma classe abstrata pode possuir métodos não abstratos */

public void setVoltagem(int voltagem) { this.voltagem = voltagem; } public int getVoltagem() { return this.voltagem; } public void setLigado(boolean ligado) { this.ligado = ligado; }

public boolean isLigado() { return ligado; }}

Como podemos observar, criamos um modelo de classe que compreende a uma

gama enorme de outros objetos. Agora, qualquer objeto que derivar desse modelo deve

ter sua voltagem especificada e dizer se está ligado ou não.

Então, vamos criar outras duas classes que herdam as características da classe

abstrata (modelo).

A primeira é a classe TV:


public class TV extends Eletrodomestico {

private int tamanho; private int canal; private int volume;

public TV(int tamanho, int voltagem) { super (false, voltagem); // construtor classe abstrata





this.tamanho = tamanho; this.canal = 0; } /* implementação dos métodos abstratos */ public void desligar() { super.setLigado(false); setCanal(0); setVolume(0); }

public void ligar() { super.setLigado(true); setCanal(3); setVolume(25); } //abaixo teríamos todos os métodos construtores get e set... }

E essa é a classe Radio.


public class Radio extends Eletrodomestico { public static final short AM = 1; public static final short FM = 2; private int banda; private float sintonia; private int volume;

public Radio(int voltagem) { super(false, voltagem); setBanda(Radio.FM); setSintonia(0); setVolume(0); }

/* implementação dos métodos abstratos */ public void desligar() { super.setLigado(false);





setSintonia(0); setVolume(0); }

public void ligar() { super.setLigado(true); setSintonia(88.1f); setVolume(25); } // abaixo teríamos todos os métodos construtores get e set... }

Pronto, como podemos ver, temos duas classes totalmente diferentes que tem

como base o mesmo modelo. Também é perceptível o fato de que em ambas as classes,

os métodos abstratos ligar() e desligar() foram implementados, porém, não há a

implementação dos outros métodos como setVoltagem() ou isLigado().

As classes abstratas servem de base para codificação de uma classe inteira,

diferentemente das interfaces que são apenas assinaturas dos métodos. Sumarizando,

quando temos que definir variáveis, constantes, regras, e pequenas ações definidas

devemos usar classes abstratas. Mas, se formos apenas criar a forma como objetos

devem realizar determinadas ações (métodos) devemos optar por interfaces.

A boa combinação de heranças e implementações de classes abstratas e

interfaces proporciona uma forma robusta de criação de softwares e uma ótima alternativa

para heranças múltiplas comumente usadas em C++.

Abaixo está uma classe que testa a funcionalidade dessas classes.

package classeAbstrata;

public class Main { public static void main(String[] args) { TV tv1 = new TV(29, 110);





Radio radio1 = new Radio(110); /* * chamando os métodos abstratos implementados * dentro de cada classe (TV e Radio) */ tv1.ligar(); radio1.ligar(); System.out.print("Neste momento a TV está "); System.out.println(tv1.isLigado() ? "ligada" : "desligada"); System.out.print("e o Rádio está "); System.out.println(radio1.isLigado() ? "ligado." : "desligado."); } }}

21. Polimorfismo

Polimorfismo, que vem do grego "muitas formas". É o termo definido em linguagens

orientadas a objeto - como o Java - para a possibilidade de se usar o mesmo elemento de

forma diferente.

Especificamente em Java, polimorfismo se encontra no fato de podemos modificar

totalmente o código de um método herdado de uma classe diferente, ou seja,

sobrescrevemos o método da classe pai.

Portanto, polimorfismo está intimamente ligado a herança de classes. Um pequeno

exemplo para simplificar essa característica segue abaixo:

a. Classe 1 possui 2 métodos: métodoA() e métodoB().

b. Classe 2 herda a classe 1.

c. Classe 2 reescreve todo o métodoA() que pertence a classe 1.





Levando isso a um patamar mais prático.

Sabemos que toda classe em Java herda implicitamente a classe Object. A classe

Object possui alguns métodos, dentre eles o método toString(). O método toString()

original, descreve qual instância de objeto está sendo utilizada. Resumidamente, ele cria

um texto com o nome da classe mais um código hexadecimal que cada instância possui

diferente de outra, chamado hash code (é como um RG daquela instância).

Então, se tivéssemos a classe TV dentro do pacote primebean e usássemos o

comando: System.out.println (tv1.toString()). O que apareceria no console seria algo

como: primebean.TV@c17124. Então o que faremos para melhorar será usar o

polimorfismo para sobrescrever o método toString(), colocando o texto da forma que

desejarmos.

package primebean;

public class TV { private String marca; private String modelo; private int tamanho; private int canal; private int volume; private boolean ligada;

public TV(String marca, String modelo, int tamanho) { this.marca = marca; this.modelo = modelo; this.tamanho = tamanho; this.canal = 1; this.volume = 0; this.ligada = false; }

// métodos getters e setters public String toString() { return "TV" + "\nMarca: " + this.marca +


mailto:primebean.TV@c17124




"\nModelo: " + this.modelo + "\nTamanho: " + this.tamanho; }

public static void main(String args[]) { TV tv1 = new TV("Marca1", "SDX-22", 29); System.out.println(tv1.toString()); }}

Agora, o resultado da linha System.out.println (tv1.toString()) não será mais:

primebean.TV@c17124

Agora, será: TV

Marca: Marca1

Modelo: SDX-22

Tamanho: 29

É possível que dependendo do seu JRE e compilador seja necessário o uso da

annotation @override antes de sobrescrever o método toString();

22. Typecast - Casting

Quando lidamos com linguagens de programação fortemente tipadas como Java,

nos confrontamos muitas vezes com a necessidade de variar de um tipo de dado para

outro. Há casos, também, em que até mesmo o compilador não compreende que tipo de

dado estamos atribuindo a uma variável.

Em Java, nós podemos fazer uso do que chamamos de indução de tipo, typecast

ou ate mesmo casting. O typecast dita ao compilador como tal dado deve ser interpretado





e manipulado. Essa indução de tipo ou typecast pode ser implícita ou explícita.

O typecast implícito é feito automaticamente pelo compilador quando um tipo de

dado pode ser facilmente manipulado no lugar de outro tipo de dado. O typecast explícito

é feito diretamente no algorítmo para indicar ao compilador qual a forma de interpretação

de um dado quando ele entende que há ambiguidade ou formatos incompatíveis.

O typecast explícito é dado sempre dentro de parênteses que sempre vem antes

do dado a ser induzido. Ex.: (int) var1, (float) var2, (Object) var3, …

22.1. Typecast de Dados Primitivos

O typecast de dados primitivos é dado basicamente em questão de seu consumo

de memória. Se tentamos designar um tipo de dado que consome menos memória para

um que consome mais memória, o typecast é realizado implicitamente. No exemplo

abaixo, atribuímos um dado inteiro (varInt) a uma variável do tipo float (varFloat).

public class ExemploTypecast1 { public static void main(String[] args) { float varFloat; int varInt; varInt = 200; varFloat = varInt; System.out.println(varFloat); } }

O contrário não se aplica. Tentar atribuir um tipo de dado maior para um tipo de

dado menor irá resultar em um erro de tipos incompatíveis (type mismatch). Para

demonstrar isso, usaremos dois tipos de dados inteiros. Porém, iremos atribuir um inteiro

longo (que consome mais memória) a um dado inteiro que consome menos. Nesse caso,





somos obrigados a usar typecast explícito.

public class ExemploTypecast2 {

public static void main(String[] args) { long varLong; int varInt; varLong = 200; varInt = (int) varLong; System.out.println(varInt); } }

22.2. Typecast de Classes e Objetos

Typecast também pode ser usado em Classes e Objetos. Sempre e uma classe for

genérica, ela poderá receber qualquer tipo de objeto que será feito o typecast

implicitamente. Por exemplo, vamos utilizar a classe TV que vinhamos criando até agora.

package primebean;

public class TV {

int tamanho; int canal; int volume; boolean ligada;

public TV(int tamanho, int canal, int volume, boolean ligada) { this.tamanho = tamanho; this.canal = canal; this.volume = volume; this.ligada = ligada; } }





Agora, vamos instanciar uma variável da classe genérica Object com a classe TV.

package primebean;


public static void main(String[] args) { Object obj = new TV(29, 1, 0, false); System.out.println("A variável obj é " + obj.getClass()); } }

Como podemos perceber, o resultado de getClass da variável obj não é sua classe

original (Object), mas sua instância: class primebean.TV. Agora, não será possível criar

uma cópia desse objeto para uma variável do mesmo tipo de sua instância. Neste caso,

devemos fazer o typecast explícito da classe.

package primebean;


public static void main(String[] args) { Object obj = new TV(29, 1, 0, false); TV tv = (TV) obj; TV tv2 = new TV(29, 1, 0, false); System.out.println("A variável tv é cópia de obj" + "\nobj: " + obj.toString() + "\ntv: " + tv.toString()); System.out.println("TV2 é outro objeto: " + tv2.toString()); } }

O resultado do código acima seria algo como:

A variável tv é cópia de obj

obj: primebean.TV@12345f





tv: primebean.TV@12345f

TV2 é outro objeto: primebean.TV@abcde1

23. Instanceof

No exemplo anterior, se tentássemos atribuir obj diretamente a tv ocorreria um erro

de tipos incompatíveis (type mismatch). Quando lidamos com classes, podemos testar

qual seu tipo de instancia usando o operador instanceof. Instanceof indica se um objeto

(já instanciado) pertence a uma classe.

O uso de instanceof é: objeto instanceof nomeDaClasse. Para melhorar o exemplo

anterior, usaremos instanceof antes de atribuirmos obj a tv.

package primebean;

public class ExemploTypecast { public static void main(String[] args) { Object obj = new TV(29, 1, 0, false); TV tv = null; if (obj instanceof TV) { tv = (TV) obj; } TV tv2 = new TV(29, 1, 0, false); System.out.println("A variável tv é cópia de obj" + "\nobj: " + obj.toString() + "\ntv: " + tv.toString()); System.out.println("TV2 é outro objeto: " + tv2.toString()); } }


mailto:primebean.TV@abcde1




24. Generics

No artigo anterior de Java, vimos como usar typecast e instanceof. Aqui, veremos

uma pequena introdução de Generics ou programação genérica, na qual será muito

importante quando formos tratar de classes e interfaces de coleção como, por exemplo, a

classe Vector.

Generics, ou programação genérica, serve para determinar para o compilador, qual

tipo de classe deve ser interpretada. Por exemplo, vamos imaginar que será criada uma

classe chamada Aparelho que irá conter um objeto de alguma outra classe.

Para que essa classe possa aceitar qualquer tipo de classe, devemos fazer uso de

generics. Generics é indicado como um identificador entre os sinais de maior e menor

(<>).

24.1.Criando classes usando generics

Para criar uma classe usando generics, basta que logo após o nome da classe

coloquemos o indicador genérico. Esse indicador genérico é simplesmente uma letra na

qual será substituída dentro da classe no momento da execução.

package primebean;

public class Aparelho <T> {

T objeto;

public Aparelho(T objeto) { this.objeto = objeto; }

public T getObjeto() {





return objeto; } public void setObjeto(T objeto) { this.objeto = objeto; } }

Como a letra T identifica um tipo genérico, ela será substituída por qualquer classe.

Vamos imaginar agora que temos duas classes distintas. A classe TV:

package primebean;

public class TV { int tamanho; int canal; int volume; boolean ligada;

public TV(int tamanho, int canal, int volume, boolean ligada) { this.tamanho = tamanho; this.canal = canal; this.volume = volume; this.ligada = ligada; } //métodos get e set }

E a classe Radio:

package primebean;

public class Radio {

public static int AM = 1; public static int FM = 2; private float frequencia; private int volume;





private int banda;

public Radio(float frequencia, int volume, int banda) { this.frequencia = frequencia; this.volume = volume; this.banda = banda; } // métodos get e set }

24.2. Instanciar uma classe genérica

Se fossemos criar um programa que usa as duas classes de aparelhos acima,

faríamos:

package primebean;

public class MinhaClasse {

public static void main(String[] args) { Aparelho<TV> aparelho1 = new Aparelho<TV>(new TV(29, 0, 0, false)); Aparelho<Radio> aparelho2 = new Aparelho<Radio>(new Radio(88.1f, 0, Radio.FM)); System.out.println(aparelho1.getObjeto().getClass()); System.out.println(aparelho2.getObjeto().getClass()); } }

Perceba o seguinte: sem o uso de generics, o compilador não conseguiria saber

qual a diferença entre aparelho1 e aparelho2, pois ele os trataria da mesma forma. Nesse

caso, seria obrigatório o uso de typecast para determinar ao compilador que dado está

sendo processado.

Se pensarmos em uma aplicação muito grande, além de ficar cansativo ter que





usar typecast toda vez que fossemos usar um aparelho, seria muito provável que

erraríamos em algum momento. Java usa uma pequena convenção de nomenclatura para

as letras de identificação de generics (que são vastamente utilizadas no Framework de

coleções Java), sendo:

• E - Elemento

• K - Chave

• N - Número

• T - Tipo

• V - Valor

Generics é um assunto bastante extenso com vários tópicos que podem ser

abordados, dentre os quais podemos citar:

• Multiplos tipos genéricos. Ex.: <T, E, N>;

• Tipos genéricos limitados. Ex.: <U extends Number>;

• Wildcards;

• e Subtipos;

O intuito desta apostila é apenas introduzir um conceito geral de programação

genérica (generics) para compreensão de classes e métodos que utilizam generics.





25. Exceções

As exceções são, na verdade, instâncias de classes. E como qualquer classe ou

objeto, podemos facilmente manipular. Existem métodos comuns entre todas as classes

de Exceções, dentre as quais podemos citar:

• toString(): Converte os dados da exceção para String para visualização.

• printStackTrace(): Imprime na saída de erro padrão (geralmente console) todos os

frames de onde foram detectados erros. Útil para depuração no desenvolvimento, pois

mostra todo o histórico do erro, além das linhas onde foram ocasionados.

• getCause(): Retorna a causa da Exceção, ou null se a causa for desconhecida ou não

existir.

• getMessage(): Retorna uma string com o erro. É uma forma simples e elegante de

mostrar a exceção causada, geralmente, utilizada como forma de apresentação ao

usuário.

25.1. Try e Catch

Umas das utilidades proporcionadas pela orientação a objetos de Java é a

facilidade em tratar possíveis erros de execução chamados de exceções. Sempre que um

método de alguma classe é passível de causar algum erro, então, podemos usar o

método de tentativa - o try.

Tudo que estiver dentro do bloco try será executado até que alguma exceção seja

lançada, ou seja, até que algo dê errado. Quando uma exceção é lançada, ela sempre

deve ser capturada. O trabalho de captura da exceção é executado pelo bloco catch.





Um bloco try pode possuir vários blocos de catch, dependendo do número de

exceções que podem ser lançadas por uma classe ou método. O bloco catch obtém o erro

criando uma instância da exceção. Portanto, a sintaxe do bloco try

catch é:

try { // código a ser executado } catch (ClasseDeExceção instânciaDaExceção) { // tratamento da exceção }

25.2. Finally

Finally é o trecho de código final. A função básica de finally é sempre executar seu

bloco de dados mesmo que uma exceção seja lançada. É muito útil para liberar recursos

do sistema quando utilizamos, por exemplo, conexões de banco de dados e abertura de

buffer para leitura ou escrita de arquivos.

Finally virá após os blocos de catch.

try { // código a ser executado } catch (ClasseDeExceção instânciaDaExceção) { // tratamento da exceção } finally { // código a ser executado mesmo que uma exceção seja lançada }

Abaixo está um exemplo de tratamento de erro ou exceção. Tentaremos atribuir

uma string de letras a um objeto inteiro. Como não é possível atribuir uma string de letras

a um objeto inteiro, uma exceção de formato de número é lançada.





public class ExemploDeExcecao {


String var = "ABC"; try {

Integer i = new Integer(var); System.out.println("A variável i vale " + i); } catch (NumberFormatException nfe) { System.out.println("Não é possível atribuir a string " + var + " a um Objeto Inteiro.\n" + "A seguinte mensagem foi retornada:\n\n" + nfe.getMessage()); } } }

O código acima apresentará algo como:

Não é possível atribuir a string ABC a um Objeto Inteiro. A seguinte mensagem foi

retornada:

For input string: "ABC"

Perceba que a linha System.out.println("A variável i vale " + i) não foi executada,

pois houve um erro na linha anterior. Portanto, apenas a mensagem de tratamento do erro

NumberFormatException foi impressa na tela.





26. Classes Numéricas

Estamos seguindo para, em breve, entrarmos nos tutoriais de programação usando

SWING e AWT, resumidamente, janelas. Mas antes, veremos classes que se tornarão de

extrema importância para o uso da manipulação dos dados. Essas classes são as que

tem por base a classe abstrata Numbers e a classe String.

Em Java, além de podermos utilizar os tipos primitivos de dados, também podemos

usufruir de classes completas para o tratamento desses tipos primitivos. Isso é uma

grande vantagem quando métodos necessitam ou retornam objetos ao invés de tipos

primitivos (o que é muito comum com os objetos do pacote SWING e AWT).

Outra vantagem dessas classes é que o próprio compilador é capaz de extrair os

dados do objeto implicitamente e manipular seus dados como sendo simples dados

primitivos, num processo descrito como box e unbox (encaixotar e desencaixotar).

Por exemplo, se quisermos somar dois inteiros que estão dentro de dois objetos

inteiros, não precisaríamos fazer nada de especial, a não ser somá-los de fato, como se

fossem dados primitivos. Veja:

public class SomarIntegers {


Integer var1 = 25; Integer var2 = 75; int resultado = var1 + var2; // somando dois objetos System.out.println(resultado); } }

A princípio, a classe abstrata Number nos proporciona um conjunto de métodos

que, logicamente, são possíveis acessar de qualquer classe numérica.





26.1. Obtendo Tipo Primitivo de um Objeto Numérico

Podemos utilizar os métodos *Value para obter um tipo primitivo de qualquer objeto

numérico.

• byteValue(): Obtém um valor primitivo byte.

• shortValue(): Obtém um valor primitivo short (inteiro curto).

• intValue(): Obtém um valor primitivo int (inteiro).

• longValue(): Obtém um valor primitivo long (inteiro longo).

• floatValue(): Obtém um valor primitivo float.

• doubleValue(): Obtém um valor primitivo double.

Esses métodos são ótimos para passar de um tipo de dado para o outro sem nos

preocuparmos com indução de tipo ou typecasting, pois a mudança é feita diretamente

pelo objeto.

public class ConverterNumeros {


Byte meuByte = 5; Integer meuInt = 12345; Double meuDouble = 1234567.89; byte doubleParaByte = meuDouble.byteValue(); int byteParaInteiro = meuByte.intValue(); double inteiroParaDouble = meuInt.doubleValue(); System.out.println("Byte: " + meuByte + " - para int: " + byteParaInteiro + "\nInteger: " + meuInt + " - para double: " + inteiroParaDouble + "\nDouble: " + meuDouble + " - para byte: " + doubleParaByte); }}





26.2. Comparando Números

Para comparação de números, há dois métodos: compareTo() e equals(). O método

compareTo() compara o objeto com um outro objeto da mesma classe ou número de tipo

primitivo do mesmo tipo. Ele retorna 0 se o número comparado for igual, -1 se o número

for menor ou 1 se o número for maior.

Equals() funciona de forma semelhante. Ele indica se o número comparado é igual

ao argumento deste método, porém não diz se o argumento é maior ou menor que o valor

do objeto. Outra diferença fica por conta de seu retorno que é um valor booleano (true ou

false).

26.7. Classes Integer, Float, Short, Byte, Long e Double

Agora que temos a base de todas as classes numéricas, iremos para a descrição

dos métodos contidos nessas classes, que apesar de diferentes, mantem uma

similaridade muito grande.

26.7.1. Análise de Dados

A análise de dados consiste em tentar usar uma String que possa ser interpretada

como tal objeto numérico usando o comando parse*. Caso a String não possa ser

interpretada como um número, uma exceção (erro) é lançada.

• Byte.parseByte(): analisa uma String para tenta atribuir um dado do tipo primitivo byte.

• Short.parseShort(): analisa uma String para tenta atribuir um dado do tipo primitivo short.





• Integer.parseInt(): analisa uma String para tenta atribuir um dado do tipo primitivo inteiro.

• Long.parseLong(): analisa uma String para tenta atribuir um dado do tipo inteiro primitivo

longo.

• Float.parseFloat(): analisa uma String para tenta atribuir um dado do tipo primitivo float.

• Double.parseDouble(): analisa uma String para tenta atribuir um dado do tipo primitivo

double.

Se quisermos que, ao invés de um tipo primitivo de número, seja retornado um

objeto, podemos trocar qualquer parse* por valueOf(). Em tipos inteiros, além de

valueOf(), também podemos trocar parseInt, parseByte, parseShort e parseLong por

decode().

Importante: As classes que se baseiam em números inteiros (Byte, Short, Long e Integer)

possuem um segundo argumento do tipo inteiro opcional nos métodos parse* que indica a

base do número inteiro, fazendo com que dessa forma possa ser interpretado números

Decimais (base 10), Binários (base 2), Octais (base 8) e Hexadecimais (base 16). Decode

também pode fazer este tipo de interpretação, mas não é necessário um segundo

argumento desde que a String respeite algumas convenções:

• Não são aceitos espaços;

• Não são aceitos números negativos;

• Números octais devem começar com um 0 (ex.: "0377", "0400", "0401");

• Números hexadecimais devem começar com 0x, 0X ou # (ex.: "0xFF", "0X100", "#101").

public class ParseEDecode {

public static void main(String[] args) { String numero = "256";





// retorna um dado do tipo int (inteiro) int tipoInteiro = Integer.parseInt(numero);

// retorna um objeto da classe Integer (inteiro) Integer objetoInteiro = Integer.decode(numero); System.out.println("tipoInteiro: " + tipoInteiro + "\nobjetoInteiro: " + objetoInteiro); } }

26.7.2. Conversão Para String

Para converter qualquer objeto numérico para uma String podemos fazer uso de

toString() como qualquer outra classe.

26.8. Classe Math

Vimos anteriormente como tratar números de vários tipos. Veremos agora, como

aplicar conceitos matemáticos mais complexos a nossos processamentos usando a

classe Math do pacote Java.lang.

A classe Math nos proporciona uma série de operações e constantes matemáticas

que são facilmente acessadas estaticamente, ou seja, não precisamos instanciar um

objeto para podermos usar seus métodos.

Dentro desta classe encontramos vários métodos e categorizamos os mais

utilizados da seguinte forma:





• Máximo e Mínimo;

• Potências e Raízes;

• Logaritmo;

• Arredondamentos e Valores Absolutos;

• Trigonometria;

• Números Randômicos.

26.8.1. Constantes

A classe Math possui duas constantes que são o Π (pi) e E (base de logaritmos

naturais ou neperianos) cada uma com o valor de 3,141592653589793 e

2.718281828459045, respectivamente.

Abaixo está um exemplo simples com o cálculo do comprimento do círculo:

public class ComprimentoCirculo {

public static void main(String[] args) { float raio = 2.4f; double comprimento = 2 * raio * Math.PI; System.out.println(comprimento); } }





26.8.2. Máximo e Mínimo

Como o título já sugere, a classe Math de Java possui dois métodos que retornam

o maior e o menor valor de seus argumentos. Esses métodos são max() e min().

public class MenorMaior {


float precoProdutoA[] = { 11.2f, 15.12f }; float precoProdutoB[] = { 19.7f, 20 }; System.out.println("O maior preço do produto A é " + Math.max(precoProdutoA[0], precoProdutoA[1])); System.out.println("O menor preço do produto B é " + Math.min(precoProdutoB[0], precoProdutoB[1])); } }

26.8.3. Potências e raízes

Podemos fazer cálculos de potência e raízes com facilidade usando os métodos

disponíveis em Math.

• pow (base, expoente) - calcula a potência da base elevada ao expoente.

• sqrt (número) - calcula a raíz quadrada de um número

• cbrt (número) - calcula a raiz cúbica de um número

• exp (expoente) - calcula o valor da constante de Euler (E) elevado ao expoente

public class PotenciasRaizes {






System.out.println("1 MB tem " + Math.pow(2, 10) + " KB"); System.out.println("A raiz quadrada de 121 é " + Math.sqrt(121) + " e a raiz cúbica de 1331 também é " + Math.cbrt(1331)); } }

26.8.4. Logaritmo

Na classe Math encontramos funções para cálculo de logaritmo natual, na base de

10 e a soma do número mais 1. Tais métodos são:

• log (número) - logaritmo natural de um número.

• log10 (número) - logaritmo natural de um número na base 10

• log1p (número) - logaritmo natual de um número somado a 1. Esse método retorna um

resultado mais confiável se o número em questão for muito próximo a 0 ou um número

fracionado. Ou seja, o resultado não é o mesmo entre os métodos log1p (0.1f) e log

(1+0.1f).

public class Exemplo {


float nr = 0.1f; System.out.println("Resultado 1: " + Math.log(nr+1)); System.out.println("Resultado 2: " + Math.log1p(nr)); } }





26.8.5. Arredondamentos e Valores Absolutos

Existem algumas formas de arredondar um número fracionado (float e double)

transformando-o em um número inteiro e também como obter o valor absoluto de

qualquer número.

• abs (número) - retorna o valor absoluto do mesmo tipo do parâmetro (ex.: inteiro retorna

int positivo, decimal retorna float positivo, etc)

• ceil (decimal) - este método retorna o valor decimal do parâmetro sem a parte

fracionada. Ex.: 2.1 será 2, 6.0 será 6, 10.8 será 10...

• floor (decimal) - este método retorna o primeiro inteiro após o valor decimal. Ex.: 2.1 será

3, 6.0 será 6, 10.8 será 11...

• rint (decimal) - retorna um valor double mais próximo do valor do parâmetro.

• round (decimal) - retorna o arredondamento aritmético do número decimal passado

como parâmetro



float nr = -5.75f; System.out.println("Absoluto: " + Math.abs(nr) + "\nInteiro mais baixo: " + Math.ceil(nr) + "\nInteiro mais alto: " + Math.floor(nr) + "\nDouble mais próximo: " + Math.rint(nr) + "\nArredondamento: " + Math.round(nr)); } }





26.8.6. Trigonometria

A maior parte dos métodos encontrados na classe Math são trigonométricas, o que

ajuda muito em cálculos mais complexos que envolvem figuras.

• sin (graus) - este método retorna o valor do seno de acordo com o número de

graus passado como parâmetro.

• cos (graus) - este método retorna o valor do coseno de acordo com o número de


• tan (graus) - este método retorna o valor da tangente de acordo com o número de


• asin (graus) - este método retorna o valor do arco seno de acordo com o número

de graus passado como parâmetro.

• acos (graus) - este método retorna o valor do arco coseno de acordo com o

número de graus passado como parâmetro.

• atan (graus) - este método retorna o valor do arco tangente de acordo com o


• sinh (graus) - este método retorna o valor hiperbólico do seno de acordo com o


• cosh (graus) - este método retorna o valor hiperbólico do coseno de acordo com o


• tanh (graus) - este método retorna o valor hiperbólico da tangente de acordo com o


• hypot (x , y) - retorna o valor da hipotenusa, ou, basicamente, a distância entre dois

pontos fundamentada na fórmula √x2+y2 » [sqrt (pow(x, 2) + pow(y,2))].

• toRadians (graus) - retorna um valor aproximado de radianos de acordo com o





ângulomedido em graus.

• toDegrees (raio) - retorna um valor aproximado de graus de acordo com o ângulo

medido em raios.

public class Hipotenusa {

public static void main(String[] args) { double ponto1 = 30; double ponto2 = 40; System.out.println("A distancia entre o " + ponto1 + " e o " + ponto2 + " é " + Math.hypot(ponto1, ponto2)); } }

26.8.7. Números Randômicos

Os números randômicos são obtidos usando o método random(). O método

random() retorna um valor double em 0.0 e 1.0. Para conseguirmos um valor limite ou um

alcance (comumente chamado de range) delimitado, devemos fazer pequenas operações

matemáticas.

Essas operações são simples e podem ser resumidas da seguinte maneira.

• O limite inferior, ou valor inicial (start value) será sempre somado ao número

randômico.

• O limite superior, ou alcance (range) será sempre o limite superior subtraído o

limite inferior e depois multiplicado ao número randômico.

Por exemplo, se quisermos que um número randômico sempre fique entre 5 e 10,

procederíamos da seguinte maneira:

• O menor número possível é 5, portanto ele será nosso start value ou limite inferior.





• O maior número possível é 10, então 10 será nosso limite superior.

Como temos ambos os limites (inferior e superior) devemos criar um alcance (range).

Para obtermos isso, subtrairemos o limite superior com o limite inferior (10-5=5).

public class Exemplo { public static void main(String[] args) {

int limiteInferior = 5; int limiteSuperior = 10; int alcance = limiteSuperior - limiteInferior; double nrRandomico = Math.random(); System.out.println("O número randômico escolhido entre 5 e 10 foi " + Math.round(limiteInferior + nrRandomico * alcance)); } }

27. String

Strings são utilizadas frequentemente em várias linguagens de programação, não

apenas Java. Embora Strings sejam uma sequência de caracteres em Java, e não um

array de caracteres.

Em Java, o importante é entender que string não é um tipo de dado, mas sim uma

classe. E suas variáveis são, na verdade, objetos dessa classe. Em síntese, tanto um

array de caracteres como uma string se apresentam da mesma forma. Então, qual a

vantagem de se usar uma classe e não um array de tipo primitivo?

A resposta se baseia exatamente no uso da orientação a objetos e no fato de que

existem muitos métodos que podemos utilizar em um objeto instanciado da classe String,

mesmo sendo os objetos desta classe imutáveis, ou seja, uma vez instanciados não

podemos mudar o que está guardado dentro do objeto String.





Dentre as possibilidades oferecidas pela classe String podemos destacar algumas como:

• Concatenação;

• Tamanho da String;

• Converter para maiúsculas ou minúsculas;

• Fazer comparações que incluem verificações no início e no fim;

• Extrair um carácter específico da string;

• Achar um índice da string, inclusive recursivamente (de trás para frente);

• Substituir uma parte da string ou ela completamente;

• Verificar se uma string contém outra;

• Dividir uma string em array ou vetor;

• Obter uma porção da string inteira, o que chamamos de substring.

Objetos Strings podem ser instanciadas usando um array de caracteres ou bytes

com o operador new. Ou por meio de uma string literal. String literal é qualquer sequência

de caracteres que estiver entre aspas (").

public class ExemploCriarString {

public static void main(String[] args) { char[] charArray = { 'T', 'I', ' ', 'E', 'x', 'p', 'e', 'r', 't'}; /* construindo uma string a partir de um array de char */ String string1 = new String(charArray); /* construindo uma string a partir de uma string literal */ String string2 = "www.primebean.com.br"; System.out.println(string1); System.out.println(string2); } }





27.1. Concatenação de Strings

Concatenação nada mais é do que juntar strings numa só. Isto pode ser feito de

duas formas:

A primeira utilizando o método concat() da classe String ou usando o sinal de

adição (+) como operador de concatenação. O método concat() retorna uma nova string

formada da junção da string principal com a string indicada como parâmetro.

De uma forma mais simples, podemos usar o + para juntar várias strings ao mesmo

tempo.

27.2. Tamanho da string - length()

A classe String possui um método acessor que retorna o tamanho da String. Esse

método é length().

public class TamanhoString {

public static void main(String[] args) { String str = "primebean"; System.out.println(str + " possui " + str.length() + " caracteres."); } }





24.3. Letras Maiúsculas e Minúsculas

Podemos facilmente deixar todas as letras de uma sequência de caracteres

maiúscula ou minúscula usando os métodos toUpperCase() e toLowerCase()

respectivamente.

public class StringMaiusculoMinusculo {

public static void main(String[] args) { String email = "[email protected]"; String hexadecimal = "#aa33ff"; System.out.println(email.toLowerCase()); System.out.println(hexadecimal.toUpperCase()); } }

24.4. Comparação

Há várias formas de se fazer comparações com uma string, mas vale sempre

lembrar que Java é case sensitive - diferencia letras maiúscula de minúsculas e

vice-versa. Embora haja métodos próprios para comparações em que não há importância

em diferenciar letras maiúsculas e minúsculas.

A comparação mais simples é usando o próprio operador de igualdade (==), mas

por se tratar de um objeto é preferível que se use o método específico chamado equals().

O método equals() compara o objeto string com outro objeto, se ambos possuírem

conteúdos iguais, então, é retornado verdadeiro (true), caso contrário falso (false). Isso

quer dizer que se, por exemplo, tiver um objeto da classe Integer que vale 15 e uma string

contendo os caracteres 1 e 5, a comparação de ambos resultará em verdadeiro.

A função equals() é case sensitive, para fazer uma comparação ignorando esta





característica basta usar o método equalsIgnoreCase().

public class ComparacaoIgualdadeString {


String string1 = "PRIMEBEAN"; String string2 = "primebean"; System.out.println("São iguais? (case sensitive)"); System.out.println(string1.equals(string2) ? "sim" : "não"); System.out.println("São iguais? (sem case sensitive)"); System.out.println(string1.equalsIgnoreCase(string2) ? "sim" : "não"); } }

Há também uma forma de comparar strings lexicograficamente. Dessa forma,

podemos verificar se uma string é idêntica (quando retorna-se 0), ou se ela tem um valor

menor (quando retorna-se um número abaixo de 0) ou se ela tem um valor maior (quando

retorna-se um número acima de 0). O método para fazer tais comparações é o

compareTo() (case sensitive) ou compareToIgnoreCase() (sem case sensitive).

public class ComparacaoString {


String string1 = "PRIMEBEAN"; String string2 = "primebean"; int comparacao = string1.compareTo(string2); System.out.println("Comparação entre string1 e string2 (sensitive case)"); if (comparacao > 0) { System.out.println("string1 é lexicograficamente maior que string2"); } else if (comparacao < 0) { System.out.println("string1 é lexicograficamente menor que string2"); } else { System.out.println("string1 é lexicograficamente igual a string2"); } } }





24.5. Início e fim

Outra forma de fazer comparações é fazer testes no início e no fim de uma string.

Podemos fazer tais comparações usando dois métodos: startsWith() e endsWith().

StartsWith() verifica se há uma string no começo de outra string. StartsWith()

também possui um segundo parâmetro opcional que determina a compensação inicial, ou

seja, caso necessite verificar a string não da posição 0, mas de uma posição mais

adiante.

EndsWith() verifica se há uma string no final de outra string. Diferentemente de

startsWith(), o método endsWith() não possui compensação.

public class InicioFim {


String string1 = "http://www.primebean.com.br"; System.out.println("A string " + string1 + " é:");

// verifica se há 'http:' no inicio da string if (string1.startsWith("http:")) { System.out.println("uma URL"); } /* * verifica se há 'www' no início da string, mas apenas a partir do * 8o. caracter, ou seja, após o prefixo 'http://', portanto deverá * ser compensado 7 caracteres */ if (string1.startsWith("www", 7)) { System.out.println("uma página da web"); } if (string1.endsWith(".br")) { System.out.println("um site registrado no Brasil"); } else { System.out.println("não é um site registrado no Brasil"); } } }





24.6. Caracter na posição

Podemos também obter um caracter que se encontra em alguma posição dentro da

string. Para isso, usaremos o método charAt(). CharAt() recebe um inteiro como

argumento que indica a posição que queremos da string.

Importante: Strings seguem o mesmo conceito de vetores e arrays, portanto, seu

primeiro caracter não está na posição 1, mas na posição 0.

public class ExtrairCaracter {

public static void main(String[] args) { String string1 = "primebean"; char caracter = string1.charAt(3); System.out.println("O 4o. caracter desta string é " + caracter); } }

24.7. Índice da String

A classe string possui uma forma de encontrar o índice da primeira ocorrência de

uma string dentro de outra string. O método indexOf() retorna um número inteiro que

indica exatamente em que posição ocorre uma string de busca, ou retorna um valor

menor que 0 caso não encontre o valor requisitado.

Assim como startsWith(), indexOf() também possui um segundo argumento que

determina a compensação a ser feita caso a busca não possa ser feita desde a posição 0,

mas de uma posição posterior. Além do método indexOf(), há também o método

lastIndexOf() que faz a mesma coisa que indexOf(), porém de forma recursiva (de trás

para frente ou do fim da string para o começo).





public class IndiceString {


String string1 = "www.primebean.com.br"; int posicao; posicao = string1.indexOf("primebean"); if (posicao >= 0) { System.out.println("A string primebean começa na posição " + posicao); } else { System.out.println("Não há primebean na string"); } posicao = string1.lastIndexOf(".com"); if (posicao >= 0) { System.out.println("A string .com começa na posição " + posicao); } else { System.out.println("Não há .com na string"); } } }

24.8. Substituir string ou parte dela

Podemos substituir todas as ocorrências de uma string por uma nova string

resultando em uma nova string de retorno. Para executarmos esta operação usamos o

método replace() que tem dois parâmetros: o primeiro será o que desejamos procurar

dentro da string e o segundo a string que colocaremos no lugar da antiga.

Nota: replace também funciona com o tipo primitivo char.

public class SubstituirString {






String string1 = "http://primebean.com.br"; System.out.println(string1.replace("http://", "www.")); } }

24.9. Verificar conteúdo da string

Um método muito útil para verificar o conteúdo de uma string é o contains().

Contains() retorna verdadeiro (true) se houver a sequência de caracteres especificada no

parâmetro.

public class VerificarConteudo {


String string1 = "http://www.primebean.com.br"; System.out.println("É uma página da web?"); System.out.println(string1.contains("www.") ? "sim" : "não"); } }

24.10. Dividindo em vários vetores ou arrays

Também é possível dividir uma string em um vetor ou array de strings, o que

possibilita trabalhar com pedaços menores e mais lógicos da string. Para dividir a string

podemos usar o método split().

O método split usa uma expressão regular para fazer a divisão. Para simplificar o

entendimento, podemos usar como parâmetro uma outra string como base. Mas vale

atentar no fato de que a expressão utilizada para ser feita a quebra desaparece no fim do

processo. Ex.: Se minha string for 15:30:00, se utilizarmos os dois pontos (:) para a





separação conseguiremos um array com 3 posições que seriam: [0]->15, [1]->30, [2]->00.



String string1 = "15:30:00"; String[] stringDividida = string1.split(":");

for (int i = 0; i < stringDividida.length; i++) { System.out.println("stringDividida[" + i + "]=" + stringDividida[i]); } } }

24.11. Substring

Substring é uma porção ou parte da string principal da qual pode formar outra

string, ou seja, uma substring é uma string formada a partir de uma string principal.

Para obtermos uma substring usamos um método homônimo (de mesmo nome)

com um ou dois parâmetros.

O primeiro parâmetro, obrigatório, é a posição que a substring deve iniciar

(lembrando-se que strings sempre começam da posição 0). O segundo parâmetro,

opcional, é a posição final da substring, caso este parâmetro não seja indicado, a

substring sempre irá até o último carácter encontrado.

Nota: O carácter na posição inicial fará parte da substring, porém o carácter na posição

final não faz parte da substring. Vejamos o exemplo: Se tivermos uma string de 9

caracteres, portanto, de 0 a 8 posições, se fizermos a substring da seguinte forma:

stringOriginal.substring(5,8);





0 1 2 3 4 5 6 7 8

P R I M E B E A N

O resultado será BEA. Então, se quisermos que a 8a posição entre, devemos usar

a posição seguinte 9, assim: stringOriginal.substring(3,9);

public class ExemploSubstring {


String url = "www.primebean.com.br"; String dominio = url.substring(4); String site = url.substring(url.indexOf('.') + 1,url.lastIndexOf('.')); System.out.println("Análise da string:"); System.out.println("Domínio: " + dominio); System.out.println("Site: " + site); } }

25. Manipulando datas em Java

Para quem está começando, trabalhar com datas em Java pode ser um pouco

complicado, já que a classe Date não fornece todos os recursos necessários. Para

completá-la é também utilizada a classe Calendar, que é uma classe abstrata que permite

a manipulação de datas de forma mais fácil.





25.1. Date(java.util.Date)

A classe Date armazena uma data e hora, que internamente é armazenada com

um inteiro long que é o numero de milissegundos que se passou desde 01/01/1970. Esta

classe é bem simples de se trabalhar, mas muitos de seus métodos foram depreciados

por não trabalhar muito bem com internacionalização e etc.

Date d = new Date();

25.2. Calendar(java.util.Calendar)

A classe Calendar sendo uma classe abstrata não pode ser instanciada com o

operador new, ela deve ser criada utilizando um operador estático sobrecarregado

getInstance(). Na maioria das vezes você vai receber uma instância de

Java.util.GregorianCalendar.

Calendar c = Calendar.getIntance();

Com a instância de Calendar devemos configurar uma data e podemos fazer isso

de duas formas:

Métodos set

c.set(ano,mes,dia);

c.set(ano,mês,dia,hora,minuto);

c.set(ano,mês,dia,hora,minuto,segundo);

Método setTime

c.setTime(new Date() );





A classe Calendar também nos fornece várias constantes que utilizaremos para

manipular uma data entre elas. Com a data devidamente configurada podemos realizar

diversas operações com a data:

Para adicionar ou subtrair um dia, hora, mês ou ano utilizamos o método add. O

método add aceita dois parâmetros, sendo o primeiro um constante inteira que representa

a unidade da data que queremos modificar(dia, mês , ano, etc…) e o segundo quantas

vezes será adicionada/subtraída esta unidade. A unidade é informada utilizando

constantes fornecidas pela classe Calendar que pode ser:

Dia:

Calendar.DAY_OF_MONTH

Calendar.DAY_OF_WEEK

Calendar.DAY_OF_YEAR

Mês:

Calendar.MONTH

Ano:

Calendar.YEAR

Hora:

Calendar.HOUR

Calendar.HOUR_OF_DAY





Segundos:

Calendar.SECOND

Veja o Exemplo abaixo:

Date d= new Date();

Calendar c = Calendar.getInstance();

c.add(Calendar.DAY_OF_YEAR,5 );//adicionamos 5 dias a data aual c.add(Calendar.MONTH,3 );//adicionamos 3 mêses a data atual c.add(Calendar.YEAR,1 );//adicionamos 1 ano a data atual

25.3. DateFormat(java.text.DateFormat)

Bom agora sabemos como manipula datas, agora precisamos formatar a data para

apresentação. A classe DateFormat nos fornece uma maneira simples de formatá-la e

permite a internacionalização a partir da classe Locale.

Date d = new Date(); Calendar c = Calendar.getInstance(); c.setTime(d); DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT); System.out.println( df.format(c.getTime()) );

Para obtermos uma String da data utilizamos o método format que retorna uma

String no formato especificado no método getDateInstance(). A saída do exemplo acima

será algo como 03/04/14. A classe DateForma nos fornece vários tipos de formato para

data como:





Dateformat.SHORT // 03/04/14 Dateformat.MEDIUM // 03/04/2014 Dateformat.LONG //3 de Abril de 2014 Dateformat.FULL //Quarta-feira, 3 de Abril de 2014

Embora para muitos casos estes formatos serão suficientes algumas vezes

necessitamos de uma formato vem personalizado. Isso pode ser feio através de um

subclasse de DateFormat a SimpleDateFormat..

Date hoje = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); System.out.println( sdf.format(hoje));

O construtor de SimpleDateFormat recebe uma String que representa o formato da

data. Os símbolos utilizados para cada campo da data pode ser visto na tabela abaixo

abaixo:

Símbolo Significado Apresentação Exemplo

G era designator (Text) AD

Y Year (Number) 2014

M Month in year (Text & Number) April & 04

D Day in month (Number) 14

h Hour in am/pm (1 ~ 12) (Number) 12

H Hour in day (0 ~ 23 ) (Number) 0

m Minute in hour (Number) 30

s Second in minute (Number) 55

S milisecond (Number) 978

E Day in week (Text) Tuesday

D Day in year (Number) 189

F Day in week in month (Number) 2(2nd Wed in July)

w Week in year (Number) 27

W Week in month (Number) 2





a Am/pm marker (Text) PM

k Hour in day (1 ~ 24) (Number) 24

K Hour in am/pm (0 ~ 11) (Number) 0

z Time zone (Text) Pacif Standard Time

Como vimos o dia da semana pode ser escrito por extenso, que língua ele será

utilizada? Normalmente o inglês, mas se quisermos que seja na língua de um local

diferente?

Para isso utilizaremos a internacionalização com a classe Locate que recebe em

seu construtor a língua e o país que queremos utilizar:

Locale brasil = new Locale("pt","br");//portugues do brasil Locale japao = new Locale("ja");// japao

O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto

com a classe SimpleDateFormat.

Date hoje = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("E dd ",new Locale("pt","br")); System.out.println( sdf.format(hoje)); DateFormat df = DateFormat.getDateInstance(DateFormat.FULL,new Locale("pt","br")); System.out.println( df.format(hoje));

Para finalizar como covertermos uma String em um objeto Date

Date d = new Date();

SimpleDateFormat df = new SimpleDateFormat("DD/MM/yyyy"); try { d = df.parse("25/03/2010"); } catch (ParseException ex) { ex.printStackTrace();





} System.out.println( df.format(d));

O métdo parse da classe DateFormat e recebe uma string e convertepara um objeto Date

26. Uma Introdução à API Swing

Após apresentarmos os conceitos estruturais principais de linguagem, a idéia de

orientação a objeto e as classes que mais utilizaremos como String e Numbers,

passaremos agora a focar uma programação mais voltada a práticas possíveis,

demonstrando classes com funções mais avançadas e importantes, além de

abandonarmos um pouco o visual de console e partirmos para a programação visual de

Java.

26.1. JoptionPane

Para introduzir esta nova fase, iniciaremos descrevendo um pouco sobre

JOptionPane do pacote visual Swing. A classe JOptionPane nos proporciona uma série de

métodos estáticos que ao serem invocados criam caixas de diálogos simples e objetivas.

Para usar JOptionPane temos sempre que importar o pacote

javax.swing.JoptionPane primeiro.





26.2. Caixas de Diálogo Input Text

As caixas de diálogo de entrada de texto ou Input Text Dialog servem para fazer

uma requisição de algum dado ao usuário de forma bem simples e direta. O que é

digitado pelo usuário é retornado pelo método em forma de string.

Existem mais de 10 métodos sobrecarregados para invocar uma caixa de diálogo

Input Text, mas, a princípio, usaremos a mais simples. O método showInputText recebe

um argumento que é a string contendo a informação desejada, o que na maioria das

vezes é uma pergunta ou pedido. O exemplo abaixo demonstra um programa pedindo

para que digite seu nome.

import javax.swing.JOptionPane;

public class CaixasDeDialogo {


JOptionPane.showInputDialog("Qual é o seu nome?"); } }

Será apresentada uma janela a seguir.





26.3. Caixas de Diálogo Confirm

Outra caixa de diálogo simples e objetiva do JOptionPane é a caixa de diálogo de

confirmação ou Confirm Dialog.

A Confirm Dialog (caixa de confirmação) consiste de uma caixa contendo uma

mensagem, um ícone e três botões: sim, não e cancelar.

Apesar deste ser o aspecto padrão, esta caixa, como qualquer outra de

JOptionPane, pode ser facilmente configurada (assunto que será tratado com mais

detalhes nas próximas páginas).

No método padrão chamado showConfirmDialog usamos dois argumentos:

1. O primeiro é a dependência ou frame pai, ou seja, de qual janela esta confirmação está

sendo gerada. Como nossos exemplos iniciais não possuem nenhuma dependência,

então, sempre usaremos null neste argumento.

2. O segundo argumento é a mensagem que desejamos mostrar ao usuário. O

método showConfirmDialog sempre retorna uma constante que é a resposta clicada pelo

usuário, que são:

Valor Nome da Constante Equivale

0 YES_OPTION ao clicar no botão Yes (sim)

1 NO_OPTION ao clicar no botão No (não)

2 CANCEL_OPTION ao clicar no botão Cancel (cancelar)

Melhorando o exemplo anterior ficaria assim.


public class CaixasDeDialogo {






String nome = null; nome = JOptionPane.showInputDialog("Qual é o seu nome?"); JOptionPane.showConfirmDialog(null, "O seu nome é " + nome + "?"); } }

A caixa de confirmação pareceria da seguinte forma:

26.4. Caixa de Diálogo de Mensagem

A caixa de diálogo de mensagem é uma caixa que serve apenas para emitir uma

mensagem. Esta caixa também é muito configurável e versátil, pois serve para muitas

situações distintas como uma mensagem de erro, um alerta, ou simplesmente uma

informação.

O método showMessageDialog é responsável em trazer a caixa de mensagem, o

qual pode ter muitos argumentos, porém, vamos nos ater ao mais simples. Assim como o

método showConfirmDialog, usaremos null como valor de nosso primeiro argumento,

pois, por enquanto, não há dependência de outras janelas em nosso programa.

O segundo argumento é a mensagem que desejamos emitir. Para finalizar nosso

exemplo, incluiremos as caixas de mensagem de acordo com as respostas.






public class CaixasDeDialogo { public static void main(String[] args) {

String nome = null; int resposta; nome = JOptionPane.showInputDialog("Qual é o seu nome?"); resposta = JOptionPane.showConfirmDialog(null, "O seu nome é " + nome + "?"); if (resposta == JOptionPane.YES_OPTION) { // verifica se o usuário clicou no botão YES JOptionPane.showMessageDialog(null, "Seu nome é " + nome); } else { JOptionPane.showMessageDialog(null, "Seu nome não é " + nome); } } }

Abaixo está um exemplo de como irá ficar a caixa de mensagem caso clique no botão

YES.





26.5. Input Dialogs

Caixas de Entrada de Dados

Como foi introduzido anteriormente, em Java, podemos usufruir de classes e

objetos do pacote Swing, o qual facilita a criação de interface gráfica sem a necessidade

de ficar horas programando.

Neste artigo, nos aprofundaremos no uso de JOptionPane, começando a

personalizar algumas caixas de diálogo mais simples.

Caixas de diálogo de entrada de dados são importantes para obter informações ou

requisitar algo do usuário. No objeto JOptionPane, há o método showInputDialog() que é

responsável em criar uma caixa de diálogo requisitando uma entrada de dado. Este

método é sobrecarregado de várias maneiras.

A forma mais simples de seus argumentos é:

1. A mensagem que deve ser exibida para o usuário.

Com apenas este argumento é possível criar uma caixa de diálogo com o título

Input, um ícone de interrogação, uma caixa de texto, uma mensagem e dois botões. Igual

a figura abaixo:

Porém, há como alterarmos a aparência dessa caixa, customizando-a

completamente. Outra forma é utilizar dois argumentos, sendo:





1. A mensagem que deve ser exibida ao usuário.

2. O valor inicial da caixa de texto.

O valor inicial da caixa de texto é a string que deve aparecer dentro do campo onde

digitamos nossa entrada. Assim que aparece a caixa, seu campo está preenchido com um

valor inicial já selecionado.

Ex.: O código JOptionPane.showInputDialog("Qual o seu nome?", "Digite seu nome

aqui.")

geraria a seguinte caixa:

Uma das formas mais completas desse método inclui alterar, inclusive, o título da

caixa. Assim, usa-se 4 argumentos:

1. De qual frame a caixa de diálogo é dependente, ou seja, qual a janela principal

que chamou a caixa Input Dialog. Caso a caixa de diálogo não dependa de nenhum frame

ou janela principal, basta utilizarmos o valor null para este argumento.


3. O título da caixa de texto.

4. Que tipo de mensagem é. O tipo de mensagem define qual o ícone será

utilizado, podendo ser utilizados os números inteiros representados pelas constantes:





• PLAIN_MESSAGE (valor: -1): Mensagem limpa, sem nenhum ícone.

• ERROR_MESSAGE (valor: 0): Mensagem de erro.

• INFORMATION_MESSAGE (valor: 1): Mensagem informativa.

• WARNING_MESSAGE (valor: 2): Mensagem de alerta.

• QUESTION_MESSAGE (valor: 3): Mensagem de requisição ou pergunta. Esta é a

opção padrão do método showInputDialog().

Ex.: O código JOptionPane.showInputDialog(null, "Qual o seu Nome?", "Pergunta",

JOptionPane.PLAIN_MESSAGE)

geraria a seguinte caixa:

26.5.1. Obter valor de showInputDialog

O método showInputDialog pode retornar dois valores: ou uma string ou null. Se o

botão OK for clicado a string contida na caixa de texto será retornada, se o botão Cancel

for clicado o valor null será retornado. Sabendo disso, podemos usar uma variável string

para obter o valor e tratarmos da forma que quisermos. Vejamos o exemplo abaixo:


public class CaixasDeInput {





public static void main(String[] args) { String nome = null; while (nome == null || nome.equals("")) { nome = JOptionPane.showInputDialog("Qual o seu nome?"); if (nome == null || nome.equals("")) { JoptionPane.showMessageDialog(null, "Você não respondeu a pergunta."); } } JOptionPane.showMessageDialog(null, "Seu nome é " + nome); } }

26.5.2. Input Dialog com lista de opções

Outra forma de caixa de diálogo de entrada de dados é a Input Dialog com lista de

opções. É o mesmo método showInputDialog, mas com mais argumentos, sendo um

deles uma lista de objetos. Esta lista de objetos fará com que a caixa de diálogo venha

com um combo box ao invés de um campo de texto.

Para criar um Input Dialog com um combo box devemos usar os seguintes

argumentos na respectiva ordem:

1. De qual frame a caixa de diálogo é dependente, ou seja, qual a janela principal

que chamou a caixa Input Dialog. Caso a caixa de diálogo não dependa de nenhum frame

ou janela principal, basta utilizarmos o valor null para este argumento.


3. O título da caixa de texto.

4. Que tipo de mensagem é. O tipo de mensagem define qual o ícone será

utilizado, podendo ser utilizados os números inteiros representados pelas constantes da





mesma forma como foi mostrada anteriormente.

5. O quinto argumento é representado pelo objeto Icon, que é um ícone que

podemos criar a partir de um jpg, gif, png, etc.

6. O segredo do combo box está neste argumento. Aqui virá um array (vetor) de

objetos que serão nossos valores pré-definidos.

7. O último argumento serve apenas para indicar qual elemento do array (vetor)

deve vir selecionado no início. Caso não desejarmos que um ítem seja selecionado no

início basta utilizarmos null.

O array (vetor) de objetos deve ser genérico, portanto, utilizamos a classe Object

para criar este array. O método showInputDialog com combo box se diferencia do

showInputDialog com caixa de texto pelo seguinte fato: o que é retornado dessa vez não

será uma string, mas um objeto.

Isso faz sentido se percebermos que agora estamos escolhendo um item dentro de

uma lista de objetos. Portanto, o que será retornado será um objeto dessa lista, não uma

string como acontecia com o Input Dialog com caixa de texto.

Então, se quisermos utilizar o objeto genérico como algum outro tipo de dado,

devemos antes fazer uma indução de tipo ou typecasting.

Vejamos o exemplo abaixo:


public class CaixaComComboBox {


Object[] opcoes = { "sim", "não" }; Object resposta; do { resposta = JoptionPane.showInputDialog(null, "Deseja finalizar o programa?",





"Finalização", JoptionPane.PLAIN_MESSAGE, null, opcoes, "não"); } while (resposta == null || resposta.equals("não")); } }

No exemplo acima, criamos uma lista com dois objetos: "sim" e "não". E já

definimos "não" como opção pré-selecionada. Removemos qualquer ícone com as opções

PLAIN_MESSAGE e ícone null.

Criamos um laço (loop) com while que sempre irá repetir a mesma caixa enquanto

o botão Cancel ou a opção "não" forem selecionados. Abaixo está um exemplo mais

funcional, divertido e simples de fazer e entender.

Trata-se de um jogo de adivinhar onde um número é escolhido e temos que

adivinhar qual número foi sorteado. No exemplo, serão usados elementos já estudados no

site como a classe Math e Integer.


public class JogoDeAdivinhar {

public static void main(String[] args) { // define um número qualquer entre 0 e 10 int rndNr = (int) Math.ceil(Math.random() * 10); // lista de opções para o combo box da caixa de diálogo Object[] opcoes = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9","10" }; // string onde será retornado o resultado String resposta; while (true) { // loop para evitar que o jogo feche depois da primeira resposta resposta = (String) JOptionPane.showInputDialog(null, "Em que número estou pensando?", "Jogo de Advinhar", JoptionPane.QUESTION_MESSAGE, null, opcoes, null);





if (resposta == null) { /* * se clicar no botão Cancel, mostrar uma mensagem de Game Over * e sair do loop para finalizar o programa */ JOptionPane.showMessageDialog(null, "Game Over!\nVocê desistiu do jogo!"); break; } if (Integer.valueOf(resposta) > rndNr) { /* * Interpreta string como inteiro e compara com o número sorteado * para ver se é maior */ JOptionPane.showMessageDialog(null, "Errado!\nO número que eu pensei é menor."); } else if (Integer.valueOf(resposta) < rndNr) { /* * Interpreta string como inteiro e compara com o número sorteado * para ver se é maior */ JOptionPane.showMessageDialog(null, "Errado!\nO número que eu pensei é maior."); } else { /* * se não for nem maior e nem menor, então é igual. * Finaliza o jogo saindo do loop */ JOptionPane.showMessageDialog(null, "Parabéns\nVocê adivinhou!\n" + "Eu realmente pensei no número " + rndNr); break; } } }}




apostila introducao a linguagem java

Documents