Livro Programação de Software Java - Por Célio Azevedo
-
Upload
compu-visions-info-celio-azevedo -
Category
Software
-
view
709 -
download
9
description
Transcript of Livro Programação de Software Java - Por Célio Azevedo
PROGRAMAÇÃO JAVA
• CONCEITOS DE PROGRAMAÇÃO
• ORIENTAÇÃO A OBJETOS
O QUE É PROGRAMAÇÃO
Uma linguagem de programação é um método padronizado para expressar instruções para um computador. É um conjunto de regras sintáticas e semânticas usadas para definir um programa de computador.
Uma linguagem permite que um programador especifique precisamente sobre quais dados um computador vai atuar, como estes dados serão armazenados ou transmitidos e quais ações devem ser tomadas sob várias circunstâncias.
O conjunto de palavras constitui o código fonte de um software. Esse código fonte é depois traduzido para código de máquina, que é executado pelo processador.
Uma das principais metas das linguagens de programação é permitir que programadores tenham mais produtividade, permitindo expressar suas intenções mais facilmente do que quando comparado com a linguagem de máquina. Assim, linguagens de programação são projetadas para que possam ser mais facilmente entendidas por programadores, sendo ferramentas para que programadores possam escrever programas mais organizados e com maior rapidez.
INTERPRETAÇÃO E COMPILAÇÃO
Uma linguagem de programação pode ser convertida, ou traduzida, em código de máquina por compilação ou interpretação, que juntas podem ser chamadas de tradução.
Se o método utilizado traduz todo o texto do programa (também chamado de código), para só depois executar o programa, então diz-se que o programa foi compilado e que o mecanismo utilizado para a tradução é um compilador (que por sua vez nada mais é do que um programa).
A versão compilada do programa tipicamente é armazenada, de forma que o programa possa ser executado um número indefinido de vezes sem que seja necessária nova compilação, o que compensa o tempo gasto na compilação.
CONCEITOS DE PROGRAMAÇÃO
Programação estruturada
Programação estruturada é uma forma de programação de
computadores que preconiza que todos os programas possíveis
podem ser reduzidos a apenas três estruturas: seqüência, decisão
e iteração. A Programação estruturada orienta os programadores
para a criação de estruturas simples em seus programas, usando
as sub-rotinas e as funções. Apesar de ter sido sucedida pela
programação orientada por objetos, pode-se dizer que a
programação estruturada ainda é marcantemente influente, uma
vez que grande parte das pessoas ainda aprendem programação
através dela. Porém, a orientação a objetos superou o uso das
linguagens estruturadas no mercado.
Cobol, PHP, Perl e Python C são exemplos.
PROGRAMAÇÃO ORIENTADA A OBJETOS
Orientação a objetos, também conhecida como Programação Orientada a Objetos é um paradigma de análise, projeto e programação de sistemas de software baseado na composição e interação entre diversas unidades de software chamadas de objetos. Em alguns contextos, prefere-se usar modelagem orientada ao objeto, em vez de programação.
O funcionamento deste sistema se dá através do relacionamento e troca de mensagens entre estes objetos. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software. Cada classe determina o comportamento através de métodos e atributos de seus objetos, assim como o relacionamento com outros objetos.
C++, C♯, VB.NET, Java, Object Pascal, Objective-C, SuperCollider, Ruby e Smalltalk são exemplos.
JAVA
É uma linguagem de programação orientada a objetos desenvolvida na década de 1990 por uma equipe de programadores chefiada por James Gosling, na empresa Sun Microsystems. Hoje, vendida para a Oracle. 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.
ESTRUTURA DE UM BYTECODE
APPLETS, APLICAÇÃO E APPLETVIEWER
O que é uma APPLET?
Applet é um programa especial escrito em Java adaptado para instalação e
execução dentro de páginas HTML. Estas páginas podem então ser visualizadas
num browser.
O que é uma APLICAÇÃO?
Aplicação é um programa mais geral escrito na linguagem Java. Não requer um
browser para sua execução. De fato, Java pode ser usada para criar todo tipo de
aplicações que usualmente você implementa com outras linguagens mais
convencionais.
O que é o APPLETVIEWER?
O Appletviewer que mostra apenas a área onde é executada applet. Depois de
testar bem seu código com o Appletviewer.
APPLET EM HTML
<HTML>
<HEAD>
<TITLE> Java </TITLE>
</HEAD>
<BODY>
<APPLET CODE=”nome.class” WIDTH=300 HEIGHT=100>
</APPLET>
</BODY>
</HTML>
Disparadas quando se carrega a página HTML
EXERCÍCIO
Criar no Notepad (Bloco de notas) um arquivo que contenha o seguinte conteúdo:
class helloworld {
public static void main (String args[]) {
System.out.println(“Hello World!”);
}
}
Não se esqueça de salvar o arquivo como “todos os arquivos” com o seguinte nome: helloworld.java
COMPILANDO
Para compilar a aplicação, basta digitar o comando no prompt:
javac helloworld.java
Este comando irá gerar o arquivo helloworld.class, que é o bytecode da aplicação. Para executar o bytecode , basta digitar o comando:
java helloworld
CASO SEJA NECESSÁRIO
Configure o caminho do Java no prompt ou na variáveis de ambiente em
“sistema” painel de controle do Windows:
Ex:
set path=%path%;C:\Program Files\Java\jdk1.7.0_07\bin
Variáveis de ambiente:
path=%path%;C:\Program Files\Java\jdk1.7.0_07\bin
MÁQUINA VIRTUAL
Em uma linguagem de programação como C e Pascal, temos a seguinte
situação quando vamos compilar um programa:
CÓDIGO FONTE
O código fonte é compilado para código de máquina específico de
uma Plataforma sistema operacional.
Muitas vezes o próprio código fonte é desenvolvido visando uma única plataforma! Esse código executável (binário) resultante será executado
pelo sistema operacional e, por esse motivo, ele deve saber
conversar com o sistema operacional em questão.
UM POUCO MAIS SOBRE ORIENTAÇÃO A OBJETOS
Existem, basicamente, duas metodologias de desenvolvimento de software:
a Programação Estruturada e a Programação Orientada a Objetos.
Na primeira, o objetivo consiste em separar os dados da funcionalidade do
programa. Neste caso, as entidades são representadas de forma tal que
satisfaçam as restrições da linguagem de programação utilizada. Isso acaba
gerando programas que são difíceis de manter e compreender, principalmente
se eles forem muito grandes.
Na segunda, a linguagem de programação é que tem de satisfazer as restrições
e requisitos das entidades. Isso permite a construção de modelos mais
realísticos do mundo, e, portanto, mais fáceis de serem mantidos e
compreendidos.
EXEMPLO – REPRESENTAÇÃO DE UM CARRO
Vamos tomar como exemplo a representação de um carro. Vamos descobrir que cada
metodologia modela de forma diferente esse carro.
Na Programação Estruturada, por exemplo, um carro é representado por um conjunto de
funções responsáveis por ligar, frear, estacionar, acelerar e assim por diante. Um conjunto
separado de variáveis define a cor do carro, seu modelo, fabricante e demais características.
Você deve então inicializar (atribuir valores) às variáveis do carro e chamar algumas das
funções para manipular estas variáveis para que o carro funcione.
Já na Programação Orientada a Objetos, o carro é visto como uma integração de seus
comportamentos (suas funções) e atributos (variáveis) que mantêm o estado atual do carro.
A integração destes atributos e comportamentos resulta em um objeto. A criação deste
objeto é simples e faz com que ele seja inicializado ao mesmo tempo sem comandos
adicionais.
BIBLIOTECAS
Isto é, temos um código executável para cada sistema operacional. É necessário
compilar uma vez para Windows, outra para o Linux, e assim por diante, caso a
gente queira que esse nosso software possa ser utilizado em várias plataformas.
Esse é o caso de aplicativos como o OpenOffice, Firefox e outros.
A sua aplicação se utiliza das bibliotecas do sistema operacional, como, por
exemplo, a de interface gráfi�ca para desenhar as “telas”. A biblioteca de interface
gráfi•ca do Windows é bem diferente das do Linux.
Precisamos então reescrever um mesmo pedaço da aplicação para diferentes
sistemas operacionais, já que eles não são compatíveis.
BYTECODE JAVA E SUA VANTAGEM
Já o Java utiliza do conceito de máquina virtual, onde existe
entre o sistema operacional e a aplicação, uma camada extra
responsável por interpretar o que sua aplicação deseja fazer
para as respectivas chamadas do sistema operacional onde
ela está rodando no momento.
DIAGRAMA BYTECODE
JVM – JAVA VIRTUAL MACHINE
Seu programa ganha independência de sistema operacional. Ou, melhor ainda,
independência de plataforma em geral: não é preciso se preocupar em qual
sistema operacional sua aplicação está rodando, nem em que tipo de
Máquina, confi•gurações, etc.
Máquina virtual é um conceito bem mais amplo que o de um interpretador.
Como o próprio nome diz, uma máquina virtual é como um “computador de
mentira": tem tudo que um computador tem. Sua aplicação roda sem nenhum
envolvimento com o sistema operacional! Apenas conversando com a Java
Virtual Machine (JVM).
VARIÁVEIS
Variáveis são alocações de memória nas quais
podemos guardar dados. Elas têm um nome,
tipo e valor. Toda vez que necessite usar de
uma variável você precisa declará-la e só
então poderá atribuir valores a mesma.
DECLARANDO VARIÁVEIS
As declarações de variáveis consistem de um tipo e um nome de variável: como
segue o exemplo:
int idade;
String nome;
boolean existe;
Os nomes de variáveis podem começar com uma letra, um sublinhado ( _ ), ou
um cifrão ($). Elas não podem começar com um número. Depois do primeiro
caracter pode-se colocar qualquer letra ou número.
DECLARANDO VARIÁVEIS
• Int a ; // declaração de uma variável 'a'
//iniciada a 0 (valor por padrão).
• Int b = 8; // declaração de uma variável 'b' iniciada a 8.
TIPOS DE VARIÁVEIS
Toda variável deve possuir um tipo. Os tipos que uma variável pode assumir são uma das três “coisas” a seguir:
• Uma das oito primitivas básicas de tipos de dados. (tipos de informação mais usuais e básicos – boolean “true
or false”, char UNICODE 16 bits, inteiros e Reais)
• O nome de uma classe ou interface.
• Um Array. (checaremos mais adiante)
TIPOS DE VARIÁVEIS
Os oito tipos de dados básicos são: inteiros, números de ponto-flutuante, caracteres e booleanos (verdadeiro ou falso).
Tipo Tamanho Alcance (tipos inteiros)
byte 8 bits - 128 até 127
short 16 bits - 32.768 até 32.767
int 32 bits - 2.147.483.648 até 2.147.483.647
long 64 bits - 9223372036854775808 até 9223372036854775807.
“Existem dois tipos de números de ponto-flutuante: float ( 32 bits, precisão simples) e double (64 bits, precisão dupla).”
ATRIBUIÇÕES A VARIÁVEIS
Após declarada uma variável a atribuição é feita simplesmente usando o
operador ‘=’:
Exemplo:
idade = 18;
existe = true;
CARACTERES ESPECIAIS
Caracter Significado
\n Nova Linha
\t Tab
\b Backspace
\r Retorno do Carro
\f “Formfeed” (avança página na impressora)
\\ Barra invertida
\’ Apóstrofe
\” Aspas
\ddd Octal
\xdd Hexadecimal
OPERADORES ARITMÉTICOS
Operador Significado Exemplo
+ soma 3 + 4
- subtração 5 -7
* multiplicação 5 * 5
/ divisão 14 / 7
% módulo 20 % 7
COMENTÁRIOS
Java possui três tipos de comentário, o /* e */ como no C e C++. Tudo o que
estiver entre os dois delimitadores será ignorado:
/* Este comentário ficará visível somente no código o compilador ignorará
completamente este trecho entre os delimitadores
*/
Duas barras (//) também podem ser usadas para se comentar uma linha:
Exemplo:
int idade; // este comando declara a variável idade
/** e */
E finalmente os comentários podem começar também com /** e
terminar com */.
Este comentário é especial e é usado pelo javadoc e para gerar uma
documentação API do código.
EXERCÍCIO
//A (public static void main( String args[] )) corresponde à declaração de um método. Classes podem ter um ou mais métodos.
//Para a execução de um aplicativo deve sempre existir pelo menos o método main. Como os métodos podem retornar
//informações, a palavra-chave void é empregada e nenhuma informação é devolvida. Este método possui ainda, entre parêntesis,
//parâmetros de entrada dados por String args[].
//O comando da linha 5 realiza a impressão de uma cadeia de caracteres contidas entre as aspas duplas, empregando um objeto
//de saída padrão, o System.out. Portanto, o método System.out.println exibe uma linha de texto na janela de comando.
//É importante notar, também, que esta instrução, assim como todas as outras, é seguida de ponto-e-vírgula (;). Declaração da
//classe testamensagem com apenas um método. Esta classe deve estar em um arquivo testamensagem1.class. Salve primeiro
como testamensagem1.java
public class testamensagem1 {
// Exibe uma mensagem.
public static void main (String[] args) {
System.out.println(“Java Rules the Universe!");
}// fim do método.
} // fim da classe.
CLASSES E OBJETOS
Classes são como moldes que geram instâncias de um certo tipo.
Para definir uma classe, use a palavra chave class e o nome da classe.
Exemplo:
class Minhaclasse{
...
}
Se esta classe é uma subclasse de outra classe, use extends para indicar a
superclasse.
Exemplo:
class Minhaclasse extends SuperClasse{
...
}
DEFININDO VARIÁVEIS DE INSTÂNCIA
As variáveis de instância, aparentemente, são declaradas e definidas quase
exatamente da mesma forma que as variáveis locais, a principal diferença é que a
alocação delas é na definição da classe. Exemplo:
class Bike extends Veículo {
String tipo;
int correia;
int pedal;
}
DEFININDO VARIÁVEIS DE INSTÂNCIA
• Variáveis de instância de classe são como as variáveis de classe, exceto
que cada subclasse possui sua própria cópia. Como é uma variável
privada, a variável de instância de classe deve começar com uma letra
minúscula. Variáveis de instância de classe suportam o comportamento
de uma classe herdada, com cada classe possuindo seu próprio estado.
OBJETOS
Objetos são instâncias de uma classe. Quando um objeto é criado ele
precisa ser inicializado, ou seja para uma única classe de nome
• Estudante de Graduação podemos ter vários objetos durante a
execução de um programa.
• Estudante de graduação André; Identificação 940718; Curso
Computação / Estudante de graduação Luiza , Identificação 893249,
Curso Medicina... A classe representa somente o molde para a criação
dos objetos, estes sim contém Informação.
O atributo Identificação pode ter o valor 940718 por exemplo para a
instância (objeto) André da classe Estudantes de Graduação.
REPRESENTAÇÃO GRÁFICA
Uma classe e suas instâncias
REPRESENTAÇÃO 2
Cada estudante (ou instância) poderia ser modelado,
desenhado como:
MAIS SOBRE CLASSES
Uma classe é um modelo usado para definir vários objetos com características semelhantes. Um
programa é constituído de uma classe ou de um conjunto de classes. Os elementos básicos de uma
classe são chamados membros da classe e podem ser divididos em duas categorias:
As variáveis, que especificam o estado da classe ou de um objeto instância desta classe.
Os métodos, que especificam os mecanismos pelos quais a classe ou um objeto instância desta
classe podem operar. O esqueleto de uma classe apresenta-se da seguinte maneira:
class NomeDaClasse { TipoDaVariahvel1 variahvel1; TipoDaVariahvel2 variahvel2; ...
TipoDeRetorno1 mehtodo1() { ... }
TipoDeRetorno2 mehtodo2() { ... } ... }
MAIS SOBRE OBJETOS
Um Objeto é uma instância de uma classe. Um objeto precisa ser declarado
e criado. Na declaração, a seguinte instrução declara que a
variável nomeDoObjeto refere-se a um objeto instância da classe NomeDaClasse:
NomeDaClasse nomeDoObjeto;
Na criação, a seguinte instrução cria (em memória) um novo objeto instância da
classe NomeDaClasse, que será referenciado pela
variável nomeDoObjeto previamente declarada :
nomeDoObjeto = new NomeDaClasse();
As duas instruções acima podem ser combinadas numa só:
NomeDaClasse nomeDoObjeto = new NomeDaClasse();
EXEMPLO DE UMA CLASSE (INSTÂNCIA)
// Classe
class animal
{
// Atributo
protected string especie;
// Construtor
public animal(string especie)
{
this.especie = especie;
}
// Execução
static void Main(string[] args)
{
// Instâncias
cachorro = new animal("Canis lupus familiaris");
gato = new animal("Felis catus");
lobo = new animal("Canis lupus"); }
}
REPRESENTAÇÃO DE HERANÇA
Uma subclasse só pode herdar de uma única superclasse diretamente.
CONSTANTES
Para declarar uma constante, use a palavra chave final antes da declaração da
variável e inclua um valor inicial para esta variável.
Exemplo:
final float pi=4.141592;
final boolean debug=false;
final int maxsize = 40000;
CONSTANTES – CONTINUA
Você pode alterar o seu valor apenas uma vez... ou na hora da declaração
da variável, ou posteriormente no código, desde que seja uma única vez.
final int a = 2;
a = 3;
Não compila porque você já atribui um valor 2 para a variável a.
CONSTANTES - CONTINUA
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. Primeiro 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)
CONSTANTES - CONTINUA
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 raio² ×
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 a seguir.
CONSTANTES - CÓDIGO
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 + "cm²");
}
}
ANATOMIA DE UMA CLASSE (livro “Use a
Cabeça Java”
MÉTODOS E ATRIBUTOS STATIC
Métodos e atributos estáticos só podem acessar outros métodos e
atributos estáticos da mesma classe, o que faz todo sentido já que
dentro de um método estático não temos acesso à referência this, pois
um método estático é chamado através da classe, e não de um objeto.
ARRAYS
Dentro de um bloco, podemos declarar diversas variáveis e usá-las:
int idade1;
int idade2;
int idade3;
int idade4;
Isso pode se tornar um problema quando precisamos mudar a quantidade de
variáveis a serem declaradas de acordo com um parâmetro. Esse parâmetro
pode variar como por exemplo a quantidade de números contidos num bilhete de
loteria. Um jogo simples possui 6 números mas podemos comprar um
Bilhete mais caro com 7 números ou mais.
CRIANDO UMA ARRAY
Para facilitar esse tipo de caso podemos declarar um vetor (array) de
Inteiros. Assim criando um objeto de array:
int[] idades;
O int[] é um tipo. Uma array é sempre um objeto, portanto, a variável
idades é uma referência. Vamos precisar criar um objeto para poder
usar a array.
idades = new int[10];
RESULTADO
O que •fizemos foi criar uma array de int de 10 posições e atribuir o endereço no
qual ela foi criada.
No caso do bilhete de loteria, podemos utilizar o mesmo recurso. Mais ainda, a
quantidade de números do nosso bilhete pode ser defi•nida por uma variável.
Considere que n indica quantos números nosso bilhete terá, podemos então
fazer:
int numerosDoBilhete[] = new int[n];
ARRAYS - DIFICULDADES
• Aprender a usar arrays pode ser um problema em qualquer
linguagem. Isso porque envolve uma série de conceitos, sintaxe e
outros. No Java, muitas vezes utilizamos outros recursos em vez
de arrays, em especial os pacotes de coleções do Java. (Java
collections framework)
CONDICIONAIS
O condicional contém a palavra chave if, seguido por um teste booleano. Um
opcional else como palavra chave pode ser executado no caso do teste ser falso,
Exemplo:
if ( x < y)
System.out.println(“ x e menor do que y”);
else
System.out.println(“ y e maior);
Nota técnica: A diferença entre o if em Java e C ou C++ é que o teste deve
retornar um valor booleano(true ou false).
CONDIÇÃO BOOLEANA
if (condicaoBooleana) {
codigo;
}
Uma condição booleana é qualquer expressão que retorne true ou false. Para
isso, você pode usar os operadores <, >, <=, >= e outros. Um exemplo:
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
}
BLOCO Um bloco é definido por ({}) e contém um grupo de outros blocos. Quando um novo bloco é
criado, um novo escopo local é aberto e permite a definição de variáveis locais. As variáveis
definidas dentro de um bloco só podem ser vistas internamente a este, e são terminadas ou
extintas no final da execução deste(}).
void testblock(){
int x = 10, w=1;
if (x> w)
{ // inicio do bloco
int y=50;
System.out.println(“dentro do bloco”);
System.out.println(“x:” + x);
System.out.println(“y:” + y);
} // final do bloco
System.out.println(“w:” + w);
System.out.println(“y:” + y); // erro variável não conhecida
}
STRING
A String guarda uma cadeia de caracteres, uma frase completa. Strings São
objetos que contém uma cadeia de caracteres. São imutáveis, portanto uma vez
criadas não podem ser alteradas. Caso ocorra uma concatenação de Strings, um
novo objeto é criado, e o antigo, automaticamente removido.
class Conta {
int numero;
String dono;
...
EXERCÍCIO
Crie um arquivo testaidade.java e o compile para calcular a idade seguinte de alguém com 20 anos:
class testaidade {
public static void main(String[] args) {
// imprime a idade
int idade = 20;
System.out.println(idade);
// gera uma idade no ano seguinte
int idadeNoAnoQueVem;
idadeNoAnoQueVem = idade + 1;
// imprime a idade
System.out.println(idadeNoAnoQueVem);
}
}
IDEs
JCreator é um poderoso Ambiente de desenvolvimento integrado criado pela
Xinox Software tendo as versões Pro e LE(Learn Edition) que suporta o
desenvolvimento em Java,JavaScript,XML, HTML.
Um interativo entorno de desenvolvimento (IDE) para JAVA que com
algumas características como as que se seguem:
• Manuseamento de projetos em uma interface semelhante à do Microsoft Visual Studio;
• Definição de esquemas de cor XML;
• Reutilização de código de projetos existentes usando diferentes versões do JDK;
• Modelos pré-definidos;
• Permite manusear e intercâmbiar código com sua integração entre Ant e CVS.
• Personalização da interface do usuário.
Além desse IDE há diversos outros conhecidos também como o Netbeans e o Eclipse.
EXERCÍCIO – USANDO O JCREATOR
Botão Iniciar e localize o Jcreator. Clique nele. Na janela que abrir, selecione New
project... e Basic Java Applet. Coloque o nome como ola_internet.java
Na janela que abrir construa a seguinte applet. Logo após, compile, clicando em play.
import java.awt.*;
import java.applet.*;
public class ola_internet extends Applet {
public void init() {
}
public void paint(Graphics g) {
g.drawString(“Ola internet!!", 50, 60 );
}
}
EIS NA SEGUINTE HTML CRIADA
<HTML>
<HEAD>
</HEAD>
<BODY BGCOLOR="000000">
<CENTER>
<APPLET
code = “ola_internet.class"
width = "500"
height = "300"
>
</APPLET>
</CENTER>
</BODY>
</HTML>
JCREATOR E NETBEANS
• Nesses ambientes de desenvolvimento
integrado (IDE) você poderá desenvolver os
mesmos exercícios já realizados no bloco de notas.
ENCAPSULAMENTO
O encapsulamento é a técnica para agregação das partes de um subprograma
(dados e códigos) numa forma que seja tratada como uma unidade indivisível
pelas demais partes do programa. Quando queremos que o objeto retorne o
nome da referencia desse objeto, por exemplo, deixamos com que um atributo
chamado Nome possa ser acessado de qualquer parte do programa e não
sabemos se ele é de um atributo de retorno ou de modificação, utilizamos os
métodos assessores Get e Set.
Por exemplo, quando queremos receber algum valor utilizamos o método get +
o nome do atributo com a inicial capitalizada, como vemos no
exemplo getNome já quando queremos modificar ou repassar um valor
utilizamos o set da mesma forma como apresentada acima,
exemplo setNome os padrões gets sempre retornam algum valor já os sets
geralmente somente modificam estes valores. Vamos ver um método get:
MÉTODO ENCAPSULADO
public String getNome () {
return nome;
}
• Então para ter um método encapsulado utilizamos um modificador de acesso
que geralmente é public o tipo de retorno que ele terá que neste caso é String e
o nome do método e o tipo de retorno dele. Uma coisa que devemos saber é que
o retorno sempre tem que ser alcançável e do mesmo tipo.
MÉTODO ENCAPSULADO
public String getNome(){
if (this.nome == null){
return 1;
} else {
return 2;
}
}
ESCONDER
A idéia de ENCAPSULAR é esconder todos os membros de uma classe, além
de esconder como funcionam as rotinas (no caso métodos) do nosso sistema.
Encapsular é fundamental para que seu sistema seja suscetível a mudanças:
Não precisaremos mudar uma regra de negócio em vários lugares, mas sim em
apenas um único lugar, já que essa regra está encapsulada.
(veja o caso do método saca)
MÉTODO SACA
CONSTRUTORES
Quando usamos a palavra chave new, estamos construindo um objeto. Sempre quando o
new é chamado, ele executa o construtor da classe. O construtor da classe é um bloco
declarado com o mesmo nome que a classe:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// construtor
Conta() {
System.out.println("Construindo uma conta.");
}
// ..
}
CONSTRUTORES - CONTINUAÇÃO
Então, quando •fizermos:
Conta c = new Conta();
A mensagem “construindo uma conta” aparecerá na tela. É como uma rotina de
inicialização que é chamada sempre que um novo objeto é criado. Um construtor
pode parecer, mas não é um método.
CONSTRUTORES - CONCLUSÃO
O interessante é que um construtor pode receber um argumento, podendo assim
inicializar algum tipo de informação:
class Conta {
int numero;
Cliente titular;
double saldo;
double limite;
// construtor
Conta(Cliente titular) {
this.titular = titular;
}
// ..
}
Recapitulando: ATRIBUTOS E MÉTODOS
Atributos: Definem características de objetos, e.g., a
classe Pessoa tem os Atributos Nome, Endereço, Telefone e Sexo.
Métodos: Definem o comportamento (funções) dos objetos, tendo seus
nomes normalmente definidos por verbos, ações. Para a
classe Pessoa, por exemplo, podem haver os métodos
Comprar, Vender e Alugar.
EXERCÍCIO
Utilize um IDE ou o bloco de notas para criar um programa que faz um carro
andar. Você vai precisar criar duas classes em arquivos diferentes para poder
executar o projeto. Uma classe será o carro, propriamente dito, a outra será o
executor da primeira (a chave do carro). Compile as duas classes .java e rode o
executor. Os dados são Carro.java e TestaCarro.java e devem estar na mesma
pasta. IDES recomendados: Eclipse, Jcreator e Netbeans.
O código fonte segue a seguir como exemplo:
class Carro.java
class Carro {
String cor;
String modelo;
double velocidadeAtual;
double velocidadeMaxima;
//liga o carro
void liga() {
System.out.println("O carro esta ligado");
}
//acelera uma certa quantidade
void acelera(double quantidade) {
double velocidadeNova = this.velocidadeAtual + quantidade;
this.velocidadeAtual = velocidadeNova;
}
//devolve a marcha do carro
int pegaMarcha() {
if (this.velocidadeAtual < 0) {
return -1;
}
if (this.velocidadeAtual >= 0 && this.velocidadeAtual < 40) {
return 1;
}
if (this.velocidadeAtual >= 40 && this.velocidadeAtual < 80) {
return 2;
}
return 3;
}
}
class TestaCarro.java
class TestaCarro {
public static void main(String[] args) {
Carro meuCarro;
meuCarro = new Carro();
meuCarro.cor = “Vermelho";
meuCarro.modelo = "Ferrari";
meuCarro.velocidadeAtual = 0;
meuCarro.velocidadeMaxima = 300;
// liga o carro
meuCarro.liga();
// acelera o carro
meuCarro.acelera(100);
System.out.println(meuCarro.velocidadeAtual);
}
}
Duke – mascote do java
POR QUE JAVA?
Por que Java?
Linguagem muito poderosa embora simples
Permite portabilidade
Muito usada em programação em rede
Server Programming
Aplicações de e-commerce, e-business, etc.
Aplicações para acesso via Internet, intranet, etc
HISTÓRICO DO JAVA 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, 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.
HISTÓRICO DO JAVA – PARTE 2
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.
A sorte é que o boom 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, em um golpe de sorte, 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.
HISTÓRICO DO JAVA - CONCLUSÃO
A velocidade dos acontecimentos seguintes foi assustadora, o número de usuários cresceu rapidamente,
grandes players, 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. Hoje são cerca de 9 milhões de desenvolvedores.
Java continuou e continua crescendo e hoje é com certeza um padrão para o mercado oferecendo
qualidade, performance e segurança ainda sem nenhum competidor a altura. 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.
VÍDEOS
ASSISTA OS VÍDEOS SOBRE O HISTÓRICO DO JAVA
HERANÇA E POLIMORFISMO
Herança: É a capacidade de criar subclasses a partir de uma
superclasse. Essas subclasses herdam, então, todas as características
da superclasse. É normalmente definida como uma associação do tipo
"é um", e.x., Cliente é uma Pessoa.
Polimorfismo: É o princípio pelo qual uma subclasse sobrescreve um
comportamento (método) herdado de sua superclasse. Por exemplo, a
classe Pessoa implementa o método Comprar, mas a classe Cliente,
derivada da classe Pessoa, precisa de algo mais específico,
envolvendo mais dados. Então a classe Cliente sobrescreve o
método Comprar, tornando-o mais específico.
HERANÇA
Primeiramente cria-se a classe Pessoa.java com o código abaixo:
package heranca;
Pessoa.java
public class Pessoa {
String nome,
idade,
endereco= "R: Java ,501";
public void ImprimeNome(){
System.out.println("o nome é:");
System.out.println("Endereco: " + endereco);
}
}
HERANÇA
Cria-se a classe Fornecedor.java:
package heranca;
Fornecedor.java
public class Fornecedor extends Pessoa {
String cnpj;
public void ImprimeNome (){
System.out.println("O nome do fornecedor é : " + nome + "\n Cnpj: " + cnpj);
}
}
HERANÇA
Cria-se a classe Cliente.java:
package heranca;
public class Cliente extends Pessoa {
String cpf;
public void ImprimeNome (){
System.out.println("Nome do cliente é : " + nome + "\n Nº CPF: " + cpf + "\n Seu endereco :" + endereco);
}
}
HERANÇA - CONCLUSÃO A classe Principal será a executora.
package heranca;
public class Principal {
public static void main(String[] args) {
Cliente c = new Cliente();
c.nome="Luiz";
c.cpf="073.777.796-21";
c.ImprimeNome();
Fornecedor f = new Fornecedor ();
f.nome="Deltatronic";
f.cnpj="073.856.9856.52-10";
f.ImprimeNome();
} }
HERANÇA - EXERCÍCIO
• Faça o exemplo como exercício através do
Netbeans/Eclipse e execute o programa.
HERANÇA – OUTRO EXEMPLO
A classe herda (têm) todos atributos e métodos visíveis em outra classe:
Exemplo: class a { public void metodo1() { } private void metodo2() { } } class b extends a { //b tem metodo1 porque herdou //b não tem metodo2 porque não é visivel para herança }
POLIMORFISMO OU SOBRECARGA
Os métodos em Java podem ser sobrecarregados, ou seja, podem-se criar métodos com o
mesmo nome, mas com diferentes assinaturas (parâmetros) e diferentes definições. Quando
se chama um método em um objeto, o Java casa o nome do método, o número de
argumentos e o tipo dos argumentos e escolhe qual a definição do método a executar. Para
criar um método sobrecarregado, é necessário criar diferentes definições de métodos na sua
classe, todos com o mesmo nome, mas com diferentes parâmetros (número de argumentos
ou tipos).
No exemplo a seguir veremos a definição da classe Retângulo, a qual define um Retângulo
plano. A classe Retângulo têm quatro variáveis para instanciar, as quais definem o canto
superior esquerdo e o canto inferior direito do retângulo:
x1, y1, x2 e y2.
POLIMORFISMO OU SOBRECARGA
class Retangulo {
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
}
Quando uma nova instância da classe Retângulo for criada, todos as suas variáveis são
inicializadas com 0. Definindo um método construaRetang (): este método recebe quatro
inteiros e faz um “resize” do retângulo de acordo com as novas coordenadas e retorna o
objeto retângulo resultante ( note que os argumentos possuem o mesmo nome das variáveis
instanciáveis, portanto deve-se usar o this para referenciá-las ):
POLIMORFISMO OU SOBRECARGA
Retangulo construaRetang ( int x1, int y1, int x2, int y2 ) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
return this;
}
Querendo-se definir as dimensões do retângulo de outra forma, por exemplo
pode-se usar o objeto Point ao invés de coordenadas individuais. Faremos a
sobrecarga do método construaRetang (), passando agora como parâmetro dois
objetos Point:
POLIMORFISMO OU SOBRECARGA
Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = inferiorDireito.x;
y2 = inferiorDireito.y;
return this;
}
Porém querendo-se definir um retângulo usando somente o canto superior
esquerdo e uma largura e altura do retângulo pode-se ainda definir mais um
método construaRetang ():
POLIMORFISMO OU SOBRECARGA
Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura)
{
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = (x1 + largura);
y2 = (y1 + altura);
return this;
}
POLIMORFISMO OU SOBRECARGA - CONCLUSÃO
Para finalizar o exemplo mostra-se a seguir um método para imprimir as coordenadas do
retângulo e um main para fazer o teste:
import java.awt.Point;
class Retangulo {
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
Retangulo construaRetang ( int x1, int y1, int x2, int y2 ) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
return this;
}
Retangulo construaRetang (Point superiorEsquerdo, Point inferiorDireito) {
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = inferiorDireito.x;
y2 = inferiorDireito.y;
return this;
}
public static void main ( String args[] ) {
Retangulo retang = new Retangulo();
System.out.println ( “Chamando construaRetang com
coordenadas 25, 25,
50, 50 :” );
retang.construaRetang ( 25, 25, 50, 50 );
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);
System.out.println ( “Chamando construaRetang com os pontos
(10, 10)
, (20, 20) :” );
retang.construaRetang ( new Point (10,10) , new Point (20, 20)
);
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);
System.out.println ( “Chamando construaRetang com os pontos
(10, 10)
, largura (50) e altura (50) :” );
retang.construaRetang ( new Point (10,10) , 50, 50);
retang.imprimaRetangulo ();
System.out.println ( “--------------------------------------------“);
}}
POLIMORFISMO OU SOBRECARGA - CONCLUSÃO
Retangulo construaRetang (Point superiorEsquerdo, int largura, int altura)
{
x1 = superiorEsquerdo.x;
y1 = superiorEsquerdo.y;
x2 = (x1 + largura);
y2 = (y1 + altura);
return this;
}
void imprimaRetangulo () {
System.out.print ( “Retângulo: < “ + x1 + “, “ + y1 );
System.out.println ( “, “ + x2 + “, “ + y2 + “>”);
}
EXERCÍCIO
Descubra os dados de salário do Funcionário Zeus construindo duas
classes do Java. Salve-as como Funcionario.java e TestaFuncionario.java e
depois as compile.
Faça isso utilizando um IDE ou mesmo o bloco de notas se preferir.
Execute o programa.
class Funcionario.java
class Funcionario {
double salario;
String nome;
//seus outros atributos e métodos
void bonifica(double aumento) {
//o que fazer aqui dentro
}
double calculaGanhoAnual() {
return 0;
//o que fazer aqui dentro
}
}
class TestaFuncionario.java
class TestaFuncionario {
public static void main(String[] args) {
Funcionario f1 = new Funcionario();
f1.nome = "Zeus";
f1.salario = 100;
f1.bonifica(50);
System.out.println("salario atual:" + f1.salario);
System.out.println("ganho anual:" + f1.calculaGanhoAnual());
}
}
ÁREAS DE APLICAÇÃO DO JAVA
Até hoje, a plataforma Java já atraiu mais de 9 milhões de desenvolvedores de
software. Ele é usado em todo grande segmento do setor e está presente em
uma grande gama de dispositivos, computadores e redes.
A versatilidade, eficiência, portabilidade de plataforma e segurança da tecnologia
Java, a tornam a tecnologia ideal para a computação de rede. De laptops a
datacenters, consoles de games a supercomputadores científicos, telefones
celulares à Internet, o Java está em todos os lugares!
ÁREAS DE APLICAÇÃO DO JAVA
• 1,1 bilhão de desktops executam Java;
• 930 milhões de download do Java Runtime Environment a cada ano;
• 3 bilhões de telefones celulares executam Java;
• Telefones Java são lançados a cada ano em um número 31 vezes maior que a Apple e a Android juntas;
• 100% de Blu-ray players executam Java;
• 1,4 bilhões de Placas Java são fabricadas a cada ano;
• Decodificadores Java, impressoras, câmeras Web, games, sistemas de navegação automotiva, casas lotéricas, dispositivos médicos, estações de pagamento de estacionamento, etc;
Para conhecer mais informações sobre as áreas de aplicação Java, explore
o java.com.
OS DESENVOLVEDORES ESCOLHEM JAVA
O Java foi testado, refinado, estendido e comprovado por uma comunidade dedicada. Mais de 9 milhões de
desenvolvedores Java fazem dele tornam a maior e a mais ativa comunidade de desenvolvimento do
planeta. Com sua versatilidade, eficiência e portabilidade, o Java tornou-se inestimável para os
desenvolvedores permitindo que eles:
• Gravem um software em uma plataforma e o executem virtualmente em qualquer outra plataforma.
• Criem programas que possam ser executados dentro em um web browser e acessem web services
disponíveis.
• Desenvolvam aplicações do servidor para fóruns on-line, armazenamentos, pesquisas, processamento de forms HTML e mais.
• Combinem aplicações ou serviços usando a linguagem Java para criar aplicações ou serviços altamente personalizáveis.
• Gravem aplicações potentes e eficientes para telefones celulares, processadores remotos, produtos de
consumo de baixo custo e praticamente qualquer outro dispositivo com pulso digital.
CRESCIMENTO DO JAVA
Atualmente, o Java tem crescido muito na área de engenharia e sistemas de informação.
O conceito de aplicação Java para o desenvolvimento de outros softwares não poderia ser
diferente, com isso levou as universidades a realizar a implantação em seu ensino de
softwares de simulação como exemplo, C & C++ com o intuito de transformar o aluno em um
bom profissional de mercado. Nesse crescente mercado, várias empresas buscam
desenvolver softwares para as mais diversas aplicações. É aí que surgem os grandes
desafios, como o de permitir a interoperabilidade entre os múltiplos dispositivos distintos e o
de desenvolver núcleos de aplicações que possam ser usados em aparelhos computacionais
diversos, como exemplo, as câmeras digitais, os PDAs, os celulares, os novos aparelhos de
TV digital, entre muitos outros.
Nesse contexto, a linguagem Java surge como uma solução poderosa no desenvolvimento
de aplicações multiplataforma, devido a fornecer uma quantidade de pacotes para as mais
diversas necessidades tecnológicas dos dias atuais.
CRESCIMENTO DO JAVA – PARTE 2 Java tem como eficiência, devido sua criação ter sido realizada para ser utilizada em
computadores pequenos, ela exige pouco espaço e pouca memória. Java é muito mais eficiente
que grande parte das linguagens de “scripting” existentes, embora seja cerca de 20 vezes mais
lenta que C, o que não é um marco definitivo. Com a evolução da linguagem, serão criados
geradores de “byte-codes” cada vez mais otimizados que trarão as marcas de performance da
linguagem mais próximas das de C++ e C.
É perceptível que a linguagem Java é excelente para desenvolver aplicações comerciais e
para ser usada em universidades. Java pode ser vista como uma fusão de várias tecnologias
que vêm sendo desenvolvidas na área de computação, de modo que estudantes dessa
linguagem tem a oportunidade de tomar contato com vários tópicos recentes: programação
concorrente, sistemas distribuídos, orientação a objetos, protocolos da Internet, e uma série de
outros assuntos fáceis de praticar nessa linguagem.
Com isso o aluno provido do conhecimento de linguagem Java, aplica, toma decisões, modela
informações ao ponto de ter o resultado esperado ou exato, se a construção dos parâmetros e
a programação estiverem corretos.
SEMELHANÇAS
Java tem a aparência de C ou de C++, embora a filosofia da linguagem seja diferente,
havendo grandes semelhanças entre alguma destas linguagens. O aluno de Engenharia por
exemplo que programa em qualquer uma delas, ou em uma linguagem orientada a objetos,
se tornará um bom programador Java em menos tempo. Java também possui características
herdadas de muitas outras linguagens de programação: Smalltalk, Eiffel,
Modula-3, etc.
Muitas das características desta linguagem não são totalmente novas. Java é uma feliz
união de tecnologias testadas por vários centros de pesquisa e desenvolvimento de
software.
ESTRUTURAS DAS APLICAÇÕES JAVA
• Agora você entenderá a estrutura básica do Java
(Arquivo fonte , classes, métodos , método main),
assim como a anatomia básica dessas respectivas
estruturas.
ARQUIVOS FONTE (SOURCE FILE)
Em Java, cada classe (class) é colocada em um arquivo source, esses arquivos representam partes de uma aplicação ou toda a aplicação(no caso de programas muito pequenos).
Arquivos source são gerados com a extensão .java e podem ser facilmente criados
utilizando o notepad por exemplo. Esses arquivos devem possuir o mesmo nome da
classe que possuem.
CLASSES
Em uma classe Java são colocados os métodos (methods), funções ou procedimentos. Todo o código deve estar em alguma classe, pois quando executamos algum aplicativo java nós estamos, na verdade, executando uma classe.
Diferentemente de um arquivo fonte que só pode conter uma classe, uma classe pode conter vários métodos. Em java a classe deve estar em um Arquivo Fonte (Source File) e deve ir com um par de chaves “{}”, são nessas chaves que serão colocados os métodos. Lembrando que uma classe sempre inicia com letra maiúscula.
Listagem 1: Exemplo de uma classe contida em um Source File MyClass.java
1
2
3
public class MyClass{
// código vai aqui
}
MÉTODOS (METHODS)
Os métodos, funções ou procedimentos são onde declararemos o código das nossas aplicações
java.
Assim como classes, os métodos em java devem ser escritos acompanhados de um par de chaves
“{}” no final. Lembrando que um método sempre inicia com letra minúscula.
Listagem 2: Exemplo de um método contido em uma Classe
public class MyClass{
public void meuMetodo(/*argumentos*/){
}
}
Agora que vimos a estrutura básica do código em java, vamos analisar melhor o
código e tentar entender o que declaramos quando criamos classes ou métodos.
ANATOMIA DE UMA CLASSE EM JAVA
public class MyClass{
public void meuMetodo (/*argumentos*/){
}
}
public = Refere-se a visibilidade desta classe. Quando dizemos que uma classe é de
visibilidade “public” , estamos dizendo que esta classe poderá ser acessada por
outras classes.
class = Mostramos que estamos criando uma classe.
MyClass = Refere-se ao nome da classe que estamos criando. Nesse caso , o nome da
minha classe será “MyClass”.
{ } = As chaves indicam até onde certa classe ou método se estende. O código que
queremos inserir nesta classe deverá ser escrito dentro do espaço das chaves.
ANATOMIA DE UM MÉTODO
public class MyClass{
public void meuMetodo(/*argumentos*/){
}
}
public = Do mesmo modo que uma classe, refere-se a visibilidade deste método. Quando dizemos
que o método é de visibilidade “public” , estamos dizendo que este método poderá ser acessado por
outras classes.
void = Refere-se ao tipo de retorno que esse método terá. Nesse caso, como o tipo de retorno é
“void”, ou seja , “vazio”, esse método não retornará valor nenhum.
meuMetodo = Assim como numa classe, refere-se ao nome do método que estamos criando. Nesse
caso, o nome do meu método será “meuMetodo”.
(/*argumentos*/ ) = Refere-se aos argumentos que serão passados para esse método, sendo
opcional. Caso não seja necessário passar argumentos, simplesmente deixaríamos os parênteses
vazios “( ) “. De contrário énecessário escrever o tipo da variável a ser passada e um nome para
essa variável “(int valor)”. { } = As chaves indicam até onde certa classe ou método se estende. O
código que queremos inserir nesta classe deverá ser escrito dentro do espaço das chaves.
O MÉTODO MAIN
Quando o java virtual machine (JVM) inicia, ele procura na sua classe principal
(executora) por um método muito específico, chamado de método main. Uma
aplicação Java obrigatoriamente deverá possuir pelo menos uma classe e um método
main, pois é por esse método main que o JVM começará a executar.
Como o método main é padrão para qualquer aplicação java, há algumas regras que
devem ser cumpridas para o funcionamento desse método. Por regra , todo método
main deverá ser : Público, estático , sem retorno(void), com nome de “main”, e deverá
receber como argumento um array do tipo String.
Exemplo de um método main contido em uma Classe:
public class MyClass{
public static void main(String[] args){
}
}
ANATOMIA DO MÉTODO MAIN
public class MyClass{
public static void main(String[] args){
}
}
public = Do mesmo modo que um método comum, refere-se a visibilidade deste método. Quando
dizemos que o método é de visibilidade “public” , estamos dizendo que este método poderá ser
acessado por outras classes.
static = Nos garante que somente haverá uma, e não mais que uma, referência para nosso método,
main, ou seja, todas as instâncias da classe irão compartilhar a mesma cópia do método main.
void = Assim como um método comum, refere-se ao tipo de retorno que esse método terá. Nesse
caso, como o tipo de retorno deve ser “void”, ou seja , “vazio”, esse método não retornará valor
nenhum.
(String[] args ) = Refere-se aos argumentos que serão passados para esse método, sendo obrigatório no
caso do método Main.
{} = Assim como um método comum , As chaves indicam até onde certa classe ou método se estende. O
código que queremos inserir neste método deverá ser escrito dentro do espaço das chaves.
DE MANEIRA MAIS CLARA E MAIS
public significa que a classe pode ser acessível a qualquer parte do código class para
introduzirmos o nome da classe
static significa que não é necessário criar um objeto para usar esse método.
void significa que esse método realiza uma tarefa mas não retorna nenhuma
informação ao completá-la.
main (pronuncia men) (Para um aplicativo ser executado, um dos métodos deve se
chamar main.
O parâmetro "String [] args" indica que o método main recebe significa um array de
Strings.
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 que
qualquer programador precisa.
extends está informando que a classe herda métodos e atributos de determinada
classe.
DE MANEIRA MAIS CLARA E MAIS
protected oculta as informações para as classes que instanciarem os métodos e
atributos dela, portanto eles são acessíveis diretamente pelas classes que herdam as
informações delas.
private indica que a classe ou o pacote está encapsulado, por herança, oculta
completamente.
construtor - todas as informações que serão iniciadas junto com o projeto estarão no
construtor. ex: initcomponents (definir posições da tela por exemplo, titulo, tamanho,
etc).
instanciar - criar objeto.
Instancia é a declaração de um objeto que foi definido por uma classe. Objeto é a
concretização da classe e Classe é a abstração de objetos que tenham atributos
comuns.
Buffer é uma região da memória, temporária, para armazenar informações.
DE MANEIRA MAIS CLARA E MAIS
classe - molde
objeto - produto desse molde. Objeto é uma representação computacional de uma
entidade do mundo real.
import - os termos que seguem o import são as bibliotecas utilizadas.
Return serve para a mesma finalidade que no DOS. Return (ou teclar ENTER, por
exemplo) é um comando que instrui o programa para executar algo
que ele está aguardando ou mesmo não executar nada. o return serve para encerrar
um método, retornando o que a assinatura disse que iria retornar.
Por exemplo:
public int metodo(){
return 1; // porque o método retorna int
}
}
DE MANEIRA MAIS CLARA E MAIS
Ou no caso de void, não retornaria nada...
só seria usado caso quisesse finalizar o método por alguma condição.
public void qualquercoisa (int numero){
if(numero == 1)
return;
else
numero = 1;
//agora nao precisa de return pois o método já chegou ao fim.
}
MÉTODOS E CONSTRUTORES
Uma das dúvidas entre métodos e construtores é de que se são a mesma coisa ou não.
A resposta simples é essa: Qualquer método que não seja o construtor é um método comum.
Os métodos comuns devem ser executados explicitamente. Os métodos construtores são executados na
instanciação de um objeto.
No exemplo: public class Gato { public void Gato() { system.out.println("Um gato foi criado"); } public void miar() { system.out.println("MIAU"); } }
A classe Gato tem um construtor, que deve ser de mesmo nome, isto é a função Gato ... quando você
instancia o objeto Gato g = new Gato(); o construtor é executado e um gato foi criado e impresso no
console. Para executar o método comum Miar, chame gato.miar();
POLÊMICAS SOBRE O “MÉTODO CONSTRUTOR
ESPECIAL”
• O construtor não é um método: Não é herdado, não pode ser chamado
duas vezes, não existe invocação virtual. Mas, internamente, na JVM
(Java Virtual Machine), ele é tratado como um método especial, sem
essas características.
IMPORTANDO BIBLIOTECA DE ENTRADA/SAÍDA
• Agora vocês poderão inserir e receber dados em seu programa
Java.
• Façam isso começando com: import java.io.*; no início do código.
EXERCÍCIO
Crie um novo programa Hello para a inserção de dados, com uma entrada
interativa de string.
Salve-o como Hello.java
import java.io.*;
class Hello {
public static void main(String[] args) throws IOException {
BufferedReader in;
in = new BufferedReader (new InputStreamReader (System.in));
System.out.print("Digite o seu nome: ");
String name = in.readLine();
System.out.println("Hello, " + name);
}
}
DESCREVENDO O CÓDIGO
O comando import é necessário para indicar ao compilador onde encontrar as definições das
classes IOException, InputStreamReader e BufferedReader.
A cláusula throws IOException é necessária porque o método main() está usando construtores e
métodos que disparam esta exceção. Em Java, esta espécie de exceção deve ser capturada ou
novamente disparada como está aqui.
O construtor da classe InputStreamReader cria um objeto InputStreamReader, anexado ao objeto
System.in que representa o teclado de entrada. Este objeto controla cada caracter que é digitado no
teclado.
O construtor de classe BufferedReader guarda cada caracter que provém do objeto anônimo
InputStreamReader, acumulando-os como um string em seu buffer.
O método readLine() retorna o string que foi acumulado no buffer do objeto.
EXERCÍCIO
Crie um programa em Java que adivinha o ano que você nasceu, com uma entrada interativa
numérica.
Declare as Variáveis necessárias. Ao término, salve-o como YearOfBirth.java e o compile:
import java.io.*;
class YearOfBirth {
public static void main(String[] args) throws IOException {
BufferedReader in;
in = new BufferedReader (new InputStreamReader (System.in));
System.out.print("Digite sua idade: ");
String input = in.readLine();
int age = Integer.parseInt(input);
System.out.println("você tem " + age + " anos agora.");
int year = 2013 - age;
System.out.println("Assim, você provavelmente nasceu em " + year);
}
}
RESUMO
O que é código fonte?
Código fonte é o código do programa ainda aberto num formato em que um
compilador possa abrir e alterá-lo.
O que é linguagem de alto nível?
É aquela linguagem q se aproxima da linguagem humana.
E linguagem de baixo nível?
Seria uma linguagem que se assemelha a linguagem da máquina. Ex. O Assembly.
O que é compilador?
É um programa para escrever e abrir códigos que criam um programa ou arquivo.
RESUMO – PARA FIXAR (ALGORITMO)
EXEMPLO DE UM ALGORITMO QUE CALCULA A MÉDIA ARITMÉTICA:
INÍCIO (início do programa)
DECLARE NOME COMO STRING ( declarando como uma cadeira de caracteres)
DECLARE N1,N2,N3,N4, MA COMO REAL (declarando como números reais)
LEIA NOME, N1, N2, N3, N4 (lendo as variáveis declaradas)
MA<-(N1+N2+N3+N4)/4 (fórmula para o cálculo)
ESCREVA MA, N1, N2, N3, N4, NOME (escrevendo os resultados)
FINAL ALGORITMO (fim do programa)
RESUMO – PARA FIXAR (ALGORITMO) 2
EXEMPLO DE UM ALGORITMO QUE CALCULA A BASE DO
RETÂNGULO:
INÍCIO (início do programa)
DECLARE A, B, H COMO REAL (declarando as variáveis como números reais)
LEIA B, H (lendo as variáveis declaradas)
A<-(B*H) (fórmula para cálculo)
ESCREVA B, H, A (escrevendo os resultados)
FINAL ALGORITMO (fim do programa)
O QUE BAIXAR DO SITE DA ORACLE/SUN?
• JVM = É a virtual machine, esse download não existe, ela sempre vem acompanhada.
• JRE = Java Runtime Environment, ambiente de execução Java, formado pela JVM e
bibliotecas, tudo que você precisa para executar uma aplicação Java. Mas nós precisamos
de mais.
• JDK = Java Development Kit: Nós, desenvolvedores, faremos o download do JDK do
Java SE (Standard Edition). Ele é formado pela JRE somado a ferramentas, como o
compilador.
Tanto o JRE e o JDK podem ser baixados do site http://java.sun.com, hoje gerenciado pela
Oracle. Para encontrá-los, acesse o link Java SE dentro dos top downloads. Consulte o
apêndice de instalação do JDK para maiores detalhes.
INSTALAÇÃO DO JAVA
Como já foi visto anteriormente, a VM é apenas uma especificação e devemos
baixar uma implementação. Há muitas empresas que implementam uma VM,
como a própria Oracle, a IBM, a Apache e outros.
A da Oracle é a mais usada e possui versões para Windows, Linux e Solaris.
Você pode baixar o SDK acessando:
http://www.oracle.com/technetwork/java/
Nesta página da Oracle, você deve escolher o Java SE, dentro dos top
downloads. Depois, escolha o JDK e seu sistema operacional.
INSTALAÇÃO DO JAVA
• O Java Software Development Kit (SDK) reúne em um só pacote todas as
bibliotecas de classes e outras ferramentas de software que você necessita para
desenvolver programas em Java. O SDK é fornecido sem custo algum, e on-line
pela Sun/Oracle.
INSTALAÇÃO NO UBUNTU
Cada distribuição Linux tem sua própria forma de instalação. Algumas já trazem
o Java junto, outras possibilitam que você instale pelos repositórios ofi•ciais e em
alguns casos você precisa baixar direto da Oracle e con•figurar tudo
manualmente.
No Ubuntu, basta ir no terminal e digitar:
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer
Caso queira utilizar o openjdk, a distribuição opensource, basta fazer
sudo apt-get install openjdk-7-jdk
INSTALAÇÃO NO FEDORA
No linux fedora, você faria com su -c "yum install java-1.7.0-openjdk".
Se você já tiver outras versões instaladas no seu Ubuntu, pode utilizar:
sudo update-alternatives –config java para escolher entre elas.
Uma instalação mais braçal, sem usar repositório , pode ser feita baixando o
instalador no próprio site da Oracle. É um tar.gz que possui um .bin que deve ser
executado. Depois, é necessário apontar JAVA_HOME para esse diretório e
adicionar JAVA_HOME/bin no seu PATH.
INSTALAÇÃO ATRAVÉS DO WINDOWS
Para instalar o JDK no Windows, primeiro baixe-o no site da Oracle. É um
simples arquivo executável que contém o Wizard de instalação:
http://www.oracle.com/technetwork/java/
PROCEDIMENTOS DA INSTALAÇÃO
1 - Dê um clique duplo no arquivo jdk-<versão>-windows-i586-p.exe e espere até
ele entrar no wizard de instalação.
2 - Aceite os próximos dois passos clicando em Next. Após um tempo, o instalador
pedirá para escolher em que diretório instalar o SDK. Pode ser onde ele já oferece como
padrão. Anote qual foi o diretório escolhido, vamos utilizar esse caminho mais adiante. A
cópia de arquivos iniciará:
PROCESSO DA INSTALAÇÃO
3 - O instalador instalará também o JavaFX. Após isso, você será direcionado à uma página onde você pode, opcionalmente, criar
uma conta na Oracle para registrar sua instalação.
CONFIGURANDO O AMBIENTE
Precisamos con•figurar algumas variáveis de ambiente após a instalação, para
que o compilador seja acessível via linha de comando. Caso você vá utilizar
diretamente algum IDE, provavelmente não será necessário realizar
esses passos.
1) Clique com o botão direito em cima do ícone Computador e selecione a opção
Propriedades.
2) Escolha a aba “Con�figurações Avançadas de Sistema” e depois clique no botão
“Variáveis de Ambiente”
CONFIGURANDO VARIÁVEL DE AMBIENTE
FINALIZANDO A CONFIGURAÇÃO
3) Nesta tela, você verá, na parte de cima, as variáveis de ambiente do usuário corrente e,
embaixo, as variáveis de ambiente do computador. Clique no botão Novo... da parte de baixo.
4) Em Nome da Variável digite JAVA_HOME e, em valor da variável, digite o caminho que
você utilizou na instalação do Java. Provavelmente será algo como:
C:\Program Files\Java\jdk1.7.0_07\bin ou a versão referente à sua JDK. Depois clique em
OK.
FINALIZANDO A INSTALAÇÃO
5) Abra o prompt, indo em Iniciar, Executar e digite cmd.
No console, digite javac -version. O comando deve mostrar a versão do Java
Compiler e algumas opções javac -version.
6) No console, digite javac -version. O comando deve mostrar a versão do Java
Compiler e algumas opções.
INSTALAÇÃO NO MAC OS X
• O Mac OS X já traz o Java instalado junto como sistema operacional até a
versão 10.6. As versões mais novas, do Lion em diante, o instalador do Mac vai
perguntar se você deseja baixá-lo quando for rodar sua primeira aplicação Java,
Algum IDE.
IMPLEMENTAÇÃO DE ORIENTAÇÃO A OBJETO EM JAVA
CLASSES E OBJETOS Em um programa orientado a objetos normalmente existem vários objetos de um mesmo tipo. Por
exemplo, um programa de controle de estoque de uma livraria pode conter vários clientes e vários
livros. As classes descrevem as informações armazenadas e os serviços providos por um objeto.
Em outras palavras, são padrões a partir dos quais os objetos são criados (código). Em um
programa orientado a objetos, um objeto é uma instância de uma classe. Os objetos que são
instâncias de uma mesma classe armazenam os mesmos tipos de informações e apresentam o
mesmo comportamento. Em Java uma classe é definida pela palavra-chave class seguida do nome
da classe. Para ilustrar os novos conceitos, vejamos o exemplo da conta corrente. A conta corrente
é uma classe que é definida da seguinte maneira:
class ContaCorrente {
// Definição dos métodos e atributos
}
VARIÁVEIS
Cada variável tem um nome e um tipo que define o comportamento estático do
objeto. Em Java para cada variável são especificados: um modificador
(opcional), o nome, o tipo e o valor inicial (opcional) do atributo. Por exemplo, a
classe ContaCorrente possui as variáveis saldo (saldo da conta corrente) e nome
(nome do dono da conta). As variáveis de uma classe podem ser de instância ou
de classe. Cada classe possui as suas próprias cópias das variáveis de
instância, enquanto que as variáveis de classe são compartilhadas.
VARIÁVEIS
CLASSE ContaCorrente
Cada instância da classe ContaCorrente (objeto) terá as mesmas variáveis (saldo e nome),
porém, elas podem ter valores diferentes em cada instância. A variável de classe
(dinheiroTotal), porém, é compartilhada por todos os objetos. Por isso, possui o mesmo valor
para todos os objetos e se um objeto modificar o seu valor, o novo valor é visto por todos os
outros objetos.
MÉTODOS
Os métodos definem os serviços que podem ser solicitados a uma instância
(objeto), ou seja, o comportamento dinâmico de um objeto. A definição de um
método em Java inclui um modificador (opcional), o tipo do dado retornado após
a execução do método, o nome do método, o nome e tipo dos parâmetros e o
código delimitado por chaves ( { } ). Por exemplo, na classe ContaCorrente
podem ser definidos os métodos:
verificaSaldo: retorna o saldo da conta corrente;
depositaValor: deposita um valor especificado x na conta;
retiraValor: retira um valor especificado x da conta;
A definição da classe ContaCorrente com as variáveis e métodos é a seguinte:
CLASSE ContaCorrente COM OS MÉTODOS E VARIÁVEIS
class ContaCorrente {
static float dinheiroTotal;
float saldo;
String nome;
float verificaSaldo ( ) {
return saldo;
}
void depositaValor (float valor) {
saldo = saldo + valor;
dinheiroTotal += valor;
}
void retiraValor (float valor) {
if (saldo>=valor) {
saldo = saldo – valor;
dinheiroTotal -= valor;
}
}
}
INSTANCIANDO UMA CLASSE
Em um programa Java, os objetos são criados (as classes são instanciadas)
através do operador new. A execução do comando new cria um objeto de um
determinado tipo (classe) e retorna uma referência a este objeto. Por exemplo:
ContaCorrente minhaConta; minhaConta = new ContaCorrente (“Maria”); Na
primeira linha tem-se o nome da variável (minhaConta) na qual o identificador do
objeto será armazenado. Na segunda linha é criado o objeto do tipo
ContaCorrente com o comando new que retorna o identificador do objeto que é
armazenado na variável minhaConta. O enunciado acima poderia ser escrito
também da seguinte maneira: ContaCorrente minhaConta = new ContaCorrente
(“Maria”);
O OPERADOR THIS
Java inclui um valor de referência especial, chamado this, que é usado dentro de qualquer método para referir-se
ao objeto corrente. O valor de this refere-se ao objeto do qual o método corrente foi chamado. Em Java é
permitido que variáveis locais (dentro de um método) tenham o mesmo nome de variáveis de instância. Para
definir que se está acessando a variável de instância, usa-se o this. Por exemplo, a classe ContaCorrente
poderia ter os seus métodos construtores declarados da seguinte maneira:
class ContaCorrente {
static float dinheiroTotal;
float saldo;
String nome;
public ContaCorrente (String nome) {
this.nome = nome;
saldo = 0;
}
... // restante do código
}
ITERAÇÃO
A maior parte dos programas úteis utilizam objetos de dados que contêm
seqüências de elementos numerados. Essas seqüências são facilmente
processadas pela iteração (repetição) de blocos de comandos. Tais
comandos de programação são denominados de laços, porque o fluxo de
execução “faz a volta” para o início do bloco. Como a maioria das
linguagens de programação modernas, Java possui três comandos de
laços: o comando for, o comando while e o comando do ...while.
A sintaxe do comando for é:
for ( expr1; expr2; expr3 )
comando;
ITERAÇÃO - CONTINUAÇÃO
• Onde que expr1 e expr3 são expressões quaisquer, expr2 é uma expressão booleana e
comando é qualquer comando ou bloco de comando. As três expressões são usadas para
controlar a iteração do comando ou bloco nessa ordem:
1. Avaliar expr1; isto é chamado de expressão de inicialização.
2. Avaliar a condição expr2; essa é chamada de condição de continuação.
3. Se esse valor booleano é falso, sair imediatamento do laço.
4. Executar comando; esse é chamado de corpo do laço.
5. Avaliar expr3; essa é a chamada de expressão de atualização.
6. Voltar ao passo 2.
EXERCÍCIO
Charles Babbage solicitou apoio financeiro ao governo britânico para construir
seu computador . Ao descrever como seu computador poderia tabular funções,
ele forneceu explicitamente o exemplo da função f(x) = x ao quadrado + x + 41.
Esse polinômio é curioso porque parece gerar apenas números primos. Esse é o
programa que a máquina diferencial de Babbage teria executado.
Crie esse mesmo programa de laço em Java e o execute, após a compilação:
Class Babbage
//programa que gera apenas números primos na função f(x) = X ao quadrado + x + 41 dos
//100.000 primeiros números primos.
class Babbage {
public static void main (String[] args){
for (int x = 0; x < 100001; x++) {
int y = x*x + x + 41;
System.out.println("\t" + x + "\t" + y);
}
}
}
LAÇOS – LAÇOS ANINHADOS
Laços são repetições de uma ou mais instruções até que uma condição
seja satisfeita. O comando dentro de um laço pode ser de qualquer tipo.
Geralmente ele é um bloco de comandos, freqüentemente alguns
desses comandos são também laços. Nesse caso eles são chamados
de laços aninhados.
Essa área é relacionada à matemática e portanto a prática é importante.
Tem haver com a Álgebra linear.
EXERCÍCIO Crie um programa que imprima na tela uma Tabela de Multiplicação de 1 a 9.
Utilize as variáveis necessárias.
class MultiplicationTable {
public static void main(String[] args) {
//Final indica que a entidade não pode ser alterada e ter outro valor e que a classe final não pode ser
//uma subclasse
final int SIZE = 9;
for (int x = 1; x <= SIZE; x++) {
for (int y = 1; y <= SIZE; y++) {
int z = x*y;
System.out.print((z<10?" ":" ") + z);
}
System.out.println();
}
}
}
O COMANDO WHILE
O while é um comando usado para fazer um laço (loop), isto é, repetir um
trecho de código algumas vezes. A idéia é que esse trecho de código seja
repetido enquanto uma determinada condição permanecer verdadeira.
int idade = 15;
while (idade < 18) {
System.out.println(idade);
idade = idade + 1;
}
O COMANDO WHILE - CONTINUAÇÃO
O trecho dentro do bloco do while será executado até o momento em que a
condição idade < 18 passe a ser falsa. E isso ocorrerá exatamente no momento
em que idade == 18, o que não o fará imprimir 18.
int i = 0;
while (i < 10) {
System.out.println(i);
i = i + 1;
}
Já o while acima imprime de 0 a 9.
O COMANDO WHILE - CONCLUSÃO
• O while é o mais simples de todos os ciclos:
Exemplo:
while ( boolean_expr )
statement;
Ou seja:
int i = 0;
while (i < 10) {
System.out.println("i = " + i);
i++;
}
DO... WHILE
• Os ciclos do… while têm o teste no fim do ciclo:
Exemplo:
do
statement;
while ( termination );
Ou seja:
int i = 0;
do {
System.out.println("i = " + i);
i++;
} while (i < 10);
DO... WHILE X WHILE
while(CONDIÇÃO){
COMANDO(S);
}
do{
COMANDO(S);
} while(CONDIÇÃO);
• Ele funciona exatamente igual ao comando "while". A diferença é que a
CONDIÇÃO só é analisada depois que os comandos são executados. Isso
significa que o comando "do-while" sempre executa o conjunto de comandos ao
menos uma vez. Mesmo que a condição seja inicialmente falsa.
EXEMPLOS DO... WHILE
Ex 1:
while(true){
System.out.println("Estou preso!"); //Como aqui CONDIÇÃO sempre é
verdadeira, este comando sempre será executado. }
Ex 2:
while(variavel==4){
variavel+=(variavel*3); //O numero de vezes que este comando será executado
depende do valor inicial da variável }
DIFERENÇAS ENTRE SUPERCLASSE E SUBCLASSE
• Super classe é a classe pai.
• Sub classe é a classe filha. O comando super chama um método da super classe.
public class Automovel {
private int potencia = 3;
public void imprimeDados() {
System.out.println("Potencia = " + potencia);
}
}
public class Carro extends Automovel {
private int consumo = 1;
public void imprimeDados() {
super.imprimeDados(); //Imprime Potencia = 3
System.out.println("Consumo = " + consumo);
}
}
CLASSE ABSTRATA
O que é Classe Abstrata? Bem, para entendermos, primeiramente trabalharemos com uma
classe chamada Funcionario. O que exatamente vem a ser a nossa classe Funcionario?
Vamos supor que a nossa empresa tenha apenas Diretores, Gerentes, Secretárias, etc. Ela
é uma classe que apenas idealiza um tipo.
Para o nosso sistema, é inadmissível que um objeto seja apenas do tipo Funcionario (pode
existir um sistema em que faça sentido ter objetos do tipo Funcionario ou apenas Pessoa,
mas, no nosso caso, não).
Usamos a palavra chave abstract para impedir que ela possa ser instanciada.
Esse é o efeito direto de se usar o modifi•cador abstract na declaração de uma
classe:
CLASSE ABSTRATA
abstract class Funcionario {
protected double salario;
public double getBonificacao() {
return this.salario * 1.2;
}
// outros atributos e metodos comuns a todos Funcionarios
}
CLASSE ABSTRATA
E, no meio de um código:
Funcionario f = new Funcionario(); // código não compila!!!
*
O código acima não compila. O problema é instanciar a classe - criar referência,
você pode. Porém, pode ser usado para herança ou polimorfismo.
* Exemplo retirado da apostila caelum.
CLASSE ABSTRATA
Vamos então herdar dessa classe, reescrevendo o método getBonificacao:
class Gerente extends Funcionario {
public double getBonificacao() {
return this.salario * 1.4 + 1000;
}
}
CLASSE ABSTRATA
Mas qual é a real vantagem de uma classe abstrata? Poderíamos ter feito isto
com uma herança comum. Por enquanto, a única diferença é que não podemos
instanciar um objeto do tipo Funcionario, que já é de grande valia, dando mais
consistência ao sistema.
Fique claro que a nossa decisão de transformar Funcionario em uma classe
abstrata dependeu do nosso domínio.
Pode ser que, em um sistema com classes similares, faça sentido que uma
classe análoga a Funcionario seja concreta.
CLASSE ABSTRATA - CONCLUSÃO
Uma classe abstrata existe para poder servir de molde para outras classes.
Levamos em consideração uma classe exemplo: a classe Pessoa.java, ela pode
se tornar muito genérica pois um funcionário pode ser uma pessoa. Uma pessoa
pode ser jurídica e pode ser física, então podemos dizer que todas as pessoas
tem um padrão e esse padrão nós colocamos em classes abstratas. Esta será
sempre uma superclasse, não podendo também ser instanciada, ou seja, não
poderá ser dado new nessa classe.
Ela geralmente apresenta métodos incompletos, o que pode ser sobrescrito na
classe filha. Ou seja, são classes que não tem instancias diretas.
CLASSE ABSTRATA - CONCLUSÃO
Outro exemplo:
ABSTRAÇÃO E ASSOCIAÇÃO
Abstração: É a habilidade de se concentrar nos principais aspectos de
um grupo de objetos, em vez de se preocupar com as suas
especificações. Ex.: Para a classe Pessoa são definidas as principais
características comuns à maioria das pessoas, sem que haja
preocupação especial com objetos muito específicos e, por
conseguinte, pouco comuns (e.x., pessoas com dedos a mais ou a
menos).
TRATAMENTO DE EXCEÇÕES
• Permite detectar erros e manipular esses erros, ou seja, tratá-los.
Diferenças entre Instruções condicionais & Tratamento de exceções:
A grande diferença é que instruções não servem para tratar erros e sim para
testar condições. Se X não for verdadeiro, faça Y, ao contrário das exceções
que tem como objetivo detectar áreas onde possíveis erros possam acontecer e
tratá-los.
O fato de um programador colocar dentro de uma instrução if…else que se o
usuário não digitar os valores válidos, informa que está errado. Isso não
quer dizer que aconteceu um erro e ele foi tratado, apenas que a condição
esperada não aconteceu ou não foi satisfeita.
COMO TRATAR UM ERRO OU EXCEÇÃO
Através de comandos como:
try - é usada para indicar um bloco de código que possa ocorrer uma exceção.
catch – serve para manipular as exceções, ou seja, tratar o erro.
finally – sempre será executado depois do bloco try/catch. O importante é saber
que esse bloco sempre será executado (exceto nos casos de encerramento da
jvm System.exit()).
O QUE É UMA EXCEÇÃO?
• É uma ocorrência que altera o fluxo do programa. As exceções podem ocorrer
por falhas de hardware, exaustão de recursos e erros.
1. As palavras try e catch servem para informar a JVM o que fazer quando ocorrer
uma exceção.
2. Os blocos catch devem aparecer após o try (isso é um requisito); entre os blocos
não podem possuir nenhuma instrução.
3. Quando uma exceção é identificada no try{} o restante do código não é executado
e não há um retorno para o término do código.
EXCEÇÕES VERIFICADAS E NÃO VERIFICADAS:
- Toda exceção verificada deriva da class Exception.
- As não verificadas ou não-checadas derivam da class RuntimeException.
Throwable – é o pai de todas as exceções.
Error – não são exceções e sim erros que jamais poderiam ter acontecidos. Ex.: estouro da
memória.
Exception- as classes que deveriam aqui funcionar, lançam exceções e não erros de programação.
Exemplo: tentar abrir um arquivo que não existe. Então é lançado uma exceção verificada,
porque a classe de leitura de arquivos deriva de Exception.
RuntimeException – são exceções que indicam erros de programas (não de lógica, pois
senão não passaria pelo compilador). Esse tipo de exceção é conhecido como não
verificada. Sendo assim, não é requisito declarar uma cláusula try{} e catch{}. Ex.: tentar
converter “dois” em “2”.
HIERARQUIA DAS EXCEÇÕES
EXERCÍCIO
Construa um programa em Java que execute uma estrutura de
repetição While enquanto determinada ação for verdadeira. Esse
programa emitirá o primeiro caracter do nome digitado. Até que seja
digitado “fim”, assim finalizando o programa. Salve a aplicação com o
nome de Primeiro.java e depois a compile.
class Primeiro.java
import java.util.*;
public class Primeiro {
public static void main(String[] args) {
String nome;
//buffer para armazenamento temporário
Scanner input = new Scanner(System.in);
System.out.println("Digite nome ou fim pra sair");
nome = input.next();
//condição while enquanto tiver o nome o programa continuará
// ao digitar fim o programa termina
while (!"fim".equals(nome)) {
System.out.println("Primeiro caractere" + nome.charAt(0));
System.out.println("Digite nome ou fim pra sair");
nome = input.next();
}
}
}
UM POUCO DE MATEMÁTICA
O triângulo aritmético é conhecido há muito tempo, mas recebeu o nome de
'Triângulo de Pascal' devido aos estudos que o filósofo e matemático Blaise
Pascal (1623-1662) .
O triângulo é infinito e simétrico, e seus lados esquerdo e direito sempre devem
possuir o número. Cada linha possui um número a mais que a linha anterior.
Além disso, o triângulo também possui várias propriedades interessantes que
permitem construir com facilidade a linha seguinte.
TRIÂNGULO DE PASCAL
EXERCÍCIO
Construa um triangulo de Pascal utilizando o laço de repetição FOR.
Saiba que seus lados esquerdo e direito sempre devem possuir o
número e deve ser simétrico. Cada linha possui um número a mais que
a linha anterior.
Compile-o e execute. PascalsTriangle.java
class PascalsTriangle
public class PascalsTriangle {
public static void main(String[] args) {
int[][] a = init (9);
print(a);
}
static int[][] init(int n) {
int[][] a = new int[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j <= i; j++)
if (j == 0|| j == i) a[i][j] = 1;
else a[i][j] = a[i-1][j-1] + a[i-1][j];
return a;
}
static void print(int[][] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j <= i; j++) {
int n = a[i][j];
System.out.print((n<10?" ":" ") +n);
}
System.out.println();
}
}
}
MÉTODOS CONSTRUTORES
Um método construtor é um tipo especial de método que determina como um
objeto é inicializado quando ele é criado.
Diferente dos métodos normais um método construtor não pode ser chamado
diretamente; ao invés disto os métodos construtores são chamados
automaticamente pelo Java. Como já foi estudado anteriormente, no momento
em que o objeto é instanciado, ou seja quando se usa new o Java faz três
coisas:
· Aloca memória para o objeto
· Inicializa as variáveis daquela instância do objeto
· Chama o método construtor da classe
MÉTODOS DESTRUTORES
Os métodos destrutores são chamados logo antes do “coletor de lixo” passar e
sua memória ser liberada. O método destrutor é chamado de finalize(). A classe
Object define um método destrutor padrão, que não faz nada. Para criar um
método destrutor para suas próprias classes basta sobrepor o método finalize ()
com o seguinte cabeçalho:
protected void finalize () {
...
}
Dentro do método finalize você pode colocar tudo que você precisa fazer para a
limpeza do seu objeto.
WINDOW TOOLKIT
As ferramentas de controle de janelas do java também conhecidas por AWT
(Abstract Window Toolkit) são uns dos pontos fortes do java. Estas ferramentas
fornecem toda a funcionalidade que se podia esperar de um sistema moderno de
janelas. O AWT contem os mais usados componentes das interfaces gráficas
atuais portanto habilita a aplicação a ser executada em sistemas gráficos
completamente diferentes.
Possui os seguintes componentes: Buttom, Canvas, Checkbox, Container, Label,
List, Scrollbar e TextComponent. Mas para um bom entendimento destes
componentes é necessário primeiro ter uma base sobre manuseio de eventos.
EVENTOS
Um evento é uma comunicação do mundo externo para o programa que
alguma coisa aconteceu. Podemos citar como exemplos o clique ou
ainda o movimento do mouse. Uma das mais importantes coisas a se
entender sobre o AWT é como é feito o manuseio/tratamento destes
eventos. Sem eventos sua aplicação não poderia responder às ações
do usuário.
EXEMPLOS - EVENTOS
import java.awt.*;
import java.applet.Applet;
public class ex5_1 extends Applet {
Button botão;
public void init() {
botão = new Button("Clique Aqui!");
add(botão);
}
public boolean action (Event evt, Object algum) {
if (evt.target == botão) {
botão.setLabel("OK!!");
return true;
}
else
return false;
}
}
EVENTOS - CONTINUA
Quando um componente que tem a ele uma ação associada é manipulado pelo
usuário, o método action() daquele componente é chamado. Neste caso nós
estamos usando um botão ao invés de usar uma subclasse de nossa autoria. O
tratador de eventos tenta tratar o evento dentro da classe botão, mas como ele
não acha o tratador que iria manusear o evento, ele passa o evento para cima
ao container que contem o componente e assim por diante, até que alguém
trate o evento. Portanto, vamos dar uma olhada de perto no método action():
public boolean action(Event evt, Object algum) {
..
}
EVENTOS - CONTINUA
Todos tratadores de eventos tem uma forma similar a esta. Eles aceitam um parâmetro do
tipo Event que provê informação detalhada sobre o evento. Segundo eles retornam um valor
Boolean indicando True se o evento foi tratado, ou False caso contrario.
if (evt.target == botão) {
Aqui o alvo do evento é checado para se saber se é ou não o botão. Porque evt.target e
botão são ambos objetos, nós podemos checar se ambos são o mesmo objeto.
botão.setLabel("OK!!");
Já que o botão foi pressionado vamos mudar o seu titulo.
return true;
}
else
return false;
Finalmente, se o evento foi tratado é retornado true, caso contrário é retornado false.
INTERFACE
O conjunto de métodos públicos de uma classe é também chamado de
interface da classe, pois esta é a única maneira a qual você se
comunica com objetos dessa classe.
É sempre bom programar pensando na interface da sua classe, como
seus usuários a estarão utilizando, e não somente em como ela vai
funcionar.
A implementação em si, o conteúdo dos métodos, não tem tanta
importância para o usuário dessa classe, uma vez que ele só precisa
saber o que cada método pretende fazer, e não como ele faz, pois isto
pode mudar com o tempo.
ORIENTAÇÃO A OBJETOS - INTERFACES
Imagine que um Sistema de Controle do Banco pode ser acessado, além de
pelos Gerentes, pelos Diretores do Banco. Então, teríamos uma classe Diretor:
class Diretor extends Funcionario {
public boolean autentica(int senha) {
// verifica aqui se a senha confere com a recebida como parametro
}
}
class Gerente.java
E a classe Gerente:
class Gerente extends Funcionario {
public boolean autentica(int senha) {
// verifica aqui se a senha confere com a recebida como parâmetro
// no caso do gerente verifica também se o departamento dele
// tem acesso
}
}
ORIENTAÇÃO A OBJETOS - INTERFACES
Repare que o método de autenticação de cada tipo de Funcionario pode variar muito. MaS vamos
aos problemas. Considere o SistemaInterno e seu controle: precisamos receber um Diretor ou
Gerente como argumento, Veri•ficar se ele se autentica e colocá-lo dentro do sistema.
ORIENTAÇÃO A OBJETOS - INTERFACES
class SistemaInterno {
void login(Funcionario funcionario) {
// invocar o método autentica?
// não da! Nem todo Funcionario tem
}
}
O SistemaInterno aceita qualquer tipo de Funcionario, tendo ele acesso ao
sistema ou não, mas note que nem todo Funcionario possui o método autentica.
Isso nos impede de chamar esse método com uma referência apenas a
Funcionario (haveria um erro de compilação). O que fazer então?
ORIENTAÇÃO A OBJETOS - INTERFACES
class SistemaInterno {
void login(Funcionario funcionario) {
funcionario.autentica(...); // não compila
}
}
Uma possibilidade é criar dois métodos login no SistemaInterno: um para
receber Diretor e outro para receber Gerente. Já vimos que essa não é uma boa
escolha. Por quê?
ORIENTAÇÃO A OBJETOS - INTERFACES
class SistemaInterno {
// design problemático
void login(Diretor funcionario) {
funcionario.autentica(...);
}
// design problemático
void login(Gerente funcionario) {
funcionario.autentica(...);
}
}
Cada vez que criarmos uma nova classe de Funcionario que é autenticável,
precisaríamos adicionar um novo método de login no SistemaInterno.
ORIENTAÇÃO A OBJETOS - INTERFACES
MÉTODOS COM O MESMO NOME:
Em Java, métodos podem ter o mesmo nome desde que não sejam
ambíguos, isto é, que exista uma maneira de distinguir no momento
da chamada.
Isso se chama sobrecarga de método. (Overloading. Não confundir
com overriding, que é um conceito muito mais poderoso).
ORIENTAÇÃO A OBJETOS - INTERFACES
SOLUÇÃO:
Uma solução mais interessante seria criar uma classe no meio da árvore de
herança, FuncionarioAutenticavel:
class FuncionarioAutenticavel extends Funcionario {
public boolean autentica(int senha) {
// faz autenticacao padrao
}
// outros atributos e metodos
}
ORIENTAÇÃO A OBJETOS - INTERFACES
As classes Diretor e Gerente passariam a estender de FuncionarioAutenticavel,
e o SistemaInterno receberiam referências desse tipo, como a seguir:
class SistemaInterno {
void login(FuncionarioAutenticavel fa) {
int senha = //pega senha de um lugar, ou de um scanner de polegar
// aqui eu posso chamar o autentica!
// Pois todo FuncionarioAutenticavel tem
boolean ok = fa.autentica(senha);
}
}
ORIENTAÇÃO A OBJETOS – INTERFACES
Repare que FuncionarioAutenticavel é uma forte candidata a classe abstrata. Mais
ainda, o métodoautentica poderia ser um método abstrato.
INTERFACE SWING
JAppletBorders
JButton
JCheckBox
JCheckBoxMenuItem
JColorChooser
JComboBoxImageIcon
JDialogJFileChooser
JInternalFrame
JLabel
JList
JMenu
JMenuBar
Swing é um kit de ferramentas GUI e faz parte da JFC (Java Foundation Classes).
Swing não é um substituto completo do AWT (Abstract Window Toolkit), simplesmente
fornece à interface de usuário componentes mais capazes.
Galeria de componentes Swing:
JOptionPane
JPopupMenu
JRadioButton
JRadioButtonMenuItem
JScrollBar
JScrollPane
JSlider
JSplitPane
JTabbedPane
JTable
JTextArea
JTextField
JToggleButton
JToolBar
JToolTip
JTree
A API SWING
A API (Application Programming Interface) Swing é poderosa, flexível e imensa, que possui
pacotes públicos, cada um com sua própria finalidade distinta:
javax.swing
Pacote swing de alto nível, consiste primariamente de componentes, adaptadores, modelos padrão
de componentes e interface.
javax.swing.border
O pacote border declara a interface Border e classes, que define especifico estilo de borda.
javax.swing.colorchooser
O pacote colorchooser contem suporte de classes para componentes color chooser .
javax.swing.event
O pacote de event é para eventos e listeners específicos Swing. Adiciona ao java.awt.event types,
componentes Swing podem gerar seus próprios tipos de eventos.
A API SWING - CONTINUA
javax.swing.filechooser
O pacote filechooser contem classes de suporte para componentes de seleção de
arquivos.
javax.swing.plaf
Plug-in look-and-feel (PLAF) pacote que contém Interfaces com usuário(UI) classes
(delegadas) que implementam diferentes look-and-feel aspects
para componentes Swing. Há também alguns pacotes de PLAF sob a hierarquia.
javax.swing.table
O pacote table contem suporte para interfaces e de classes para o componente Swing
table.
javax.swing.text
O pacote text contem classes de suporte para o framework do Swing de documento.
A API SWING - CONTINUA
javax.swing.text.html
O pacote text.html contem classes de suporte para HTML versão 3.2 interpretador e
analisador.
javax.swing.text.rtf
O pacote text.rtf contem classes de suporte para um básico interpretados Rich Text
Format (RTF).
javax.swing.tree
O pacote tree contem interface e classes para o componente tree do Swing.
javax.swing.undo
O pacote undo provê classes de suporte para implementar a capacidade de fazer/desfazer
nos GUI.
javax.accessibility
O pacote de acessibilidade da JFC é incluido nas classes Swing.
COMPONENTES SWING
Quando a linguagem Java 1.0 foi lançada, ela continha uma biblioteca de classes que a SUN chamou
de AWT (Abstract Window Tool-kit – ferramentas de janela abstratas) para programação GUI básica.
A Netscape em 1996 criou uma biblioteca GUI chamada de IFC-Internet Foudation Classes. A SUN
trabalhou junto com a Netscape para aperfeiçoar e criou uma biblioteca de interface de usuário com o nome
código de “Swing”, que alguns chamaram de “conjunto Swing”.
A JFC abrange um grupo das características para construir Interfaces Gráficas com o Usuários (GUIs) e
adição de ricas funcionalidades e interatividade com aplicações Java.
O widget é um termo sem tradução que designa componentes de interface gráfica com o usuário (GUI).
Qualquer item de uma interface gráfica é chamada de widget, por exemplo: janelas, botões, menus ítens de
menus, ícones, barras de rolagem, etc.
O pacote de acessibilidade da JFC é incluído nas classes Swing.
COMPONENTES SWING
O Swing é um pacote derivado da AWT (Abstract Window Toolkit). Assim Swing
tem mais recursos que o pacote AWT.
Vantagem de usar o Swing:
• É muito mais rápido que o AWT. Este possui mais recursos, além de ser
constantemente atualizado pela Sun/Oracle.
HIERARQUIA DE COMPONENTES SWING
HIERARQUIA DOS COMPONENTES SWING - CONTINUA
CRIANDO CAIXAS DE DIÁLOGO EM SWING
Caixas de diálogo de entrada (INPUTBOX) 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 por
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
é: 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 a seguir.
CRIANDO CAIXAS DE DIÁLOGO EM SWING
Porém, há como alterarmos a aparência dessa caixa, costumizando-a
completamente.
Outra forma é utilizar dois argumentos, sendo:
A mensagem que deve ser exibida ao usuário.
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.
CRIANDO CAIXAS DE DIÁLOGO EM SWING
Ex.: O código JOptionPane.showInputDialog("Qual o seu nome?", "Digite seu nome
aqui.") geraria a seguinte caixa:
CRIANDO CAIXAS DE DIÁLOGO EM SWING Uma das formas mais completas desse método inclui alterar, inclusive, o título da caixa.
Assim, usa-se 4 argumentos:
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.
A mensagem que deve ser exibida ao usuário.
O título da caixa de texto.
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 a seguir:
CRIANDO CAIXAS DE DIÁLOGO EM SWING
CRIANDO CAIXAS DE DIÁLOGO EM SWING
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:
import javax.swing.JOptionPane;
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);
}
}
INPUTDIALOG 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.
2 - A mensagem que deve ser exibida ao usuário.
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.
INPUTDIALOG COM LISTA DE OPÇÕES
5 - O quinto argumento é representado pelo objeto Icon, que é um ícone que podemos criar
a partir de um jpg, gif, png, etc. O objeto Icon será comentado com mais detalhes em breve.
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 item 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.
INPUTDIALOG COM LISTA DE OPÇÕES Veja o exemplo abaixo:
import javax.swing.JOptionPane;
public class CaixaComComboBox {
public static void main(String[] args) {
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"));
}
}
INPUTDIALOG COM LISTA DE OPÇÕES
No exemplo anterior, 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.
Esta iteração já foi estudada anteriormente.
CAIXAS DE DIALOGO 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.
No método padrão chamado showConfirmDialog usamos dois argumentos:
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.
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.
EXEMPLO EM CÓDIGO - CAIXA DE DIÁLOGO
import javax.swing.JOptionPane;
public class CaixasDeDialogo {
public static void main(String[] args) {
String nome = null;
nome = JOptionPane.showInputDialog("Qual é o seu nome?");
JOptionPane.showConfirmDialog(null, "O seu nome é " + nome + "?");
}
}
EXEMPLO VISUAL - CAIXA DE DIÁLOGO
EXERCÍCIO
Um exercício 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.
Salve o jogo como JogoDeAdivinhar.java e o compile em seguida.
class JogoDeAdivinhar.java import javax.swing.JOptionPane;
public class JogoDeAdivinhar {
public static void main(String[] args) {
// define um número qualquer entre 0 e 10
int mdNr = (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
*/
class JogoDeAdivinhar.java – Parte 2 JOptionPane.showMessageDialog(null, "Game Over!\nVocê desistiu do jogo!");
break;
}
if (Integer.valueOf(resposta) > mdNr) {
/*
* 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) < mdNr) {
/*
* Interpreta string como inteiro e compara com o número sorteado
* para ver se é maior
*/
class JogoDeAdivinhar.java – Parte 3
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 " + mdNr);
break;
}
}
}
}
JOGO DE ADIVINHAR
Como você pode ver, foi construído um jogo que sorteia qualquer número
entre 0 a 10 através da classe (agrupamento de objetos) Math, de maneira
randômica.
EXERCÍCIO
Construa uma calculadora com as quatro operações básicas utilizando as
janelas de Interface Swing. Essa calculadora deverá ser constituída de
caixas de diálogo. Salve-a como Calculadora.java e a compile.
class Calculadora.java import javax.swing.JOptionPane;
/* Programa: Calculadora em Java: Interface Swing
*Autor: Celio Azevedo
*/
public class Calculadora {
public static void main(String[] args) {
double a;
double b;
String operacao;
double resultado;
double i=0;
a = Double.parseDouble(JOptionPane.showInputDialog("Entre com 1 Numero: "));
while (i==0){
operacao = JOptionPane.showInputDialog("Entre com a Operação: " );
b = Double.parseDouble(JOptionPane.showInputDialog("Entre com 1 Numero: "));
if (operacao.equals("+")) {
resultado = a + b;
JOptionPane.showMessageDialog(null,"O resultado e :"
+resultado,"Resultado", JOptionPane.INFORMATION_MESSAGE);
a = resultado;
}
if (operacao.equals("-")) {
resultado = a - b;
JOptionPane.showMessageDialog(null,"O resultado e :" +resultado,"Resultado",
JOptionPane.INFORMATION_MESSAGE);
a = resultado;
}
if (operacao.equals("*")) {
resultado = a * b;
JOptionPane.showMessageDialog(null,"O resultado e :" +resultado,"Resultado",
JOptionPane.INFORMATION_MESSAGE);
a = resultado;
}
if (operacao.equals("/")) {
resultado = a / b;
JOptionPane.showMessageDialog(null,"O resultado e :" +resultado,"Resultado",
JOptionPane.INFORMATION_MESSAGE);
a = resultado;
}
}
}
}
TRATANDO ERROS COM EXCEÇÕES - RECAPITULAÇÃO
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
}
EXCEÇÕES – Parte 2
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.
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
}
FINALLY A seguir 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 {
public static void main(String[] args) {
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());
}
}
}
FINALLY - CONCLUSÃO
O código anterior 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.
EXCEÇÕES – ERROS
O instante ideal para capturar um erro é durante o tempo de compilação,
antes mesmo de você tentar executar o programa. Porém, nem todos os
erros podem ser detectados durante a compilação. O resto dos problemas
deve ser tratado durante o tempo de execução, através de alguma
formalidade que permita ao originador do erro passar informação
apropriada para o receptor que saberá como tratar a dificuldade
apropriadamente.
EXCEÇÕES E OUTRAS LINGUAGENS
C e outras linguagens mais antigas freqüentemente possuíam múltiplos esquemas de
tratamento de erros, e estes eram geralmente estabelecidos por convenção e não
como parte da linguagem de programação.
Porém, com o passar dos anos, foi descoberto que os programadores que usavam
uma biblioteca tendia a pensar sobre si mesmos como invencíveis - como se, "Sim,
erros podem acontecer com os outros, mas não no meu código". Assim não tão
surpreendentemente, eles não verificam as condições de erros (e algumas vezes as
condições de erro eram muito tolas para serem verificadas). Se você fosse cuidadoso
o suficiente para verificar por uma condição de erro cada vez que você chama um
método, seu código poderia e tornar em um ilegível pesadelo. Como programadores
ainda podiam gerar sistemas com estas linguagens, eles eram resistentes em admitir
que esta alternativa de tratamento de erros era a principal limitação para
criar programas grandes, robustos e de fácil manutenção.
SOLUÇÃO
A solução é tirar a natureza casual do tratamento de erros e obrigar a
formalidade. Isto realmente é longa história, como as implementações
de tratamento de erros vêm desde os sistemas operacionais dos anos 60, e
até mesmo do "on error goto“ do BASIC. Embora o tratamento de erros em
C++ seja baseado no do Ada, e Java baseado principalmente em C++
(embora pareça mais àquele no Object Pascal).
A ORIGEM
Uma condição exepcional é um problema que impede o prosseguimento de
um método ou escopo em que você está. É importante diferenciar uma
condição excepcional de um problema normal, sobre o qual você tem
informação suficiente no contexto atual para de algum modo lidar com a
dificuldade. Dentro de uma condição excepcional, você não pode continuar
processando porque você não tem a informação necessária para lidar com
o problema no contexto atual. Tudo que você pode fazer é sair do
contexto atual e delegar o problema para um contexto superior. Isto é o
que acontece quando você lança uma exceção.
Recapitulando: SYSTEM.OUT
System.out.print
O atributo out da classe System é do tipo PrintStream (e, portanto, é um
OutputStream) do pacote java.io.
As classes abstratas (que não podem ser instanciadas) InputStream e
OutputStream de•finem, respectivamente, o comportamento padrão dos
fluxos em Java: em um fluxo de entrada, é possível ler bytes e, no fluxo de
saída, escrever bytes.
DEFINIÇÕES DE FRAMEWORK
Johnson-1: "Um framework é um conjunto de classes que incorpora
um projeto abstrato de soluções para uma família de problemas
relacionados"
Johnson-2: "Um framework é um conjunto de objetos que colaboram
para realizar um conjunto de responsabilidades para um domínio de
aplicação do subsistema"
Johnson-3: "Um framework é um conjunto de classes abstratas e a
maneira como os objetos dessas classes colaboram."
Gama: “Framework é um conjunto de classes cooperantes que
compõem um projeto reutilizável para uma classe específica de
software“.
DEFINIÇÕES DE FRAMEWORK
Taligent: "Um framework é um conjunto extensível de classes
orientadas a objetos que são integradas para executar conjuntos de
comportamento de computação bem definidos."
Govoni: "Um framework é uma coleção de classes abstratas, interfaces
e padrões dedicados a resolver uma classe de problemas através de
uma arquitetura flexível e extensível"
Rogers: "Um framework é uma biblioteca de classes que capta os
padrões de interação entre os objetos. A estrutura consiste de um
conjunto de classes concretas e abstratas, explicitamente concebidos
para serem utilizados em conjunto.
EM DESENVOLVIMENTO DE SOFTWARE
• Um framework, em desenvolvimento de software, é uma abstração que
une códigos comuns entre vários projetos de software provendo uma
funcionalidade genérica. Um framework pode atingir uma funcionalidade
específica, por configuração, durante a programação de uma aplicação. Ao
contrário das bibliotecas, é o framework quem dita o fluxo de controle da
aplicação, chamado de Inversão de Controle.
ACESSO AO BANCO DE DADOS VIA JDBC
Uma funcionalidade essencial em qualquer sistema é a habilidade para comunicar-se com um repositório de
dados. Podemos definir repositório de dados de várias maneiras, por exemplo, como um pool de objetos num
ORB ou um banco de dados. Os bancos de dados constituem o tipo mais comum de repositório. A linguagem Java
dispõe de uma API para acessar repositórios de dados: a Java DataBase Connectivity API ou JDBC API.
A JDBC implementa em Java a funcionalidade definida pelo padrão SQL Call Level Interface ou SQLCLI.
Um outro exemplo de API que implementa o SQL Call Level Interface é o popularíssimo ODBC das
plataformas Wintel (Plataforma Windows-Intel). A maioria dos fornecedores de bancos de dados oferece
uma implementação particular de SQLCLI. A vantagem de JDBC é a portabilidade da aplicação
cliente, inerente da linguagem Java.
A JDBC compreende uma especificação para ambos: os desenvolvedores de drivers JDBC e os
desenvolvedores de aplicações clientes que precisem acessar bancos de dados em Java. Estaremos dando
uma olhada no desenvolvimento de aplicações em Java, então, é uma boa idéia começar com o suporte de
dados.
ACESSO AO BANCO DE DADOS VIA JDBC
Existem 4 tipos de diferentes de drivers JDBC (para uma lista de fornecedores por especificação e tipo):
- Uma vez que ODBC é uma especificação padrão do mundo Wintel, o tipo 1 é um driver de ponte entre
Java e ODBC. O driver de ponte mais conhecido é o fornecido pela Sun o JDBC-ODBC bridge. Este tipo de
driver não é portável, pois depende de chamadas a funções de ODBC implementadas em
linguagem C e compiladas para Wintel, ou outra plataforma ODBC compatível, as chamadas funções
nativas.
- O driver tipo 2 é implementado parcialmente em Java e parcialmente através de funções nativas que
implementam alguma API específica do fornecedor de banco de dados. Este tipo faz o que se chama de
wrap-out (envolver-cobrir), ou seja, provê uma interface Java para uma API nativa não-Java.
- O tipo 3 é um driver totalmente Java que se comunica com algum tipo de middleware (mediador de software e demais aplicações) que então se comunica com o banco de dados
- O tipo 4 é um driver totalmente Java que vai diretamente ao banco de dados.
HIBERNATE
Definição: O Hibernate é o framework que fornece ferramentas para o
mapeamento relacional de objeto (ORM). Assim demonstramos o
suporte para o framework do Hibernate no IDE e como usar os
assistentes para criar os arquivos necessários do Hibernate.
Depois de criar objetos Java e configurar a aplicação para usar o
Hibernate, você cria uma interface GUI (Graphical User Interface) para
a pesquisa e exibição dos dados.
DAO O padrão Data Access Object (DAO) é um padrão introduzido no ambiente JEE (Java
Enterprise Edition) para simplificar e desacoplar a interação das aplicações Java com
a API JDBC.
O Problema
A grande maioria das aplicações de nível corporativo usa algum tipo de persistência
de dados. Entre eles o mais usado é o Banco de Dados. A linguagem SQL é
amplamente utilizada para comunicar com os sistemas gerenciadores de banco de
dados (SGBD). Java suporta esta necessidade desde cedo através da API JDBC (Java
Database Connectivity).
Antes do uso de Java em sistemas corporativos as aplicações eram majoritariamente
escritas em linguagens orientadas a processo e a ordem e instruções SQL específicas
continham regras de negócio.
DAO
DAO - Data Access Object
É O Objeto que abstrai tudo que for referente ao acesso a dados da aplicação.
Por exemplo, é onde ficam o acesso JDBC (Java Database Connectivity) em
uma aplicação que use Banco de Dados.
Um padrão para a persistência de dados que permite separar regras de negócio
das regras de acesso a banco de dados. Numa aplicação que utilize a
arquitetura MVC - Model View Control, todas as funcionalidades de bancos de dados,
tais como obter as conexões, mapear objetos Java para tipos de dados SQL ou executar
comandos SQL, devem ser feitas por classes de DAO.
DAO
Uma pagina JSP (JavaServer Faces) que coleta entradas de texto envia para uma servlet (um
componente como um servidor, que gera dados HTML e XML para a camada de apresentação de
uma aplicação) que instancia uma entidade para receber essas três entradas, passa essa
entidade para a DAO que deve conectar com o banco mySQL usando hibernate e criteria,
que representa a consulta ao invés de uma classe persistente particular, para persistir os
dados.
O Criteria Query API permite construir query expression em Java, possibilitando, assim, a
checagem em tempo de compilação - ao contrário do HQL ou SQL. O Criteria API permite,
de forma programática, construir objetos query a partir da interface org.hibernate.Criteria,
que define os métodos disponíveis que precisamos para trabalhar com o Criteria.
HQL
O Hibernate vem com uma poderosa linguagem de consulta (HQL) que é muito
parecida com o SQL.
No entanto, comparado com o SQL o HQL é totalmente orientado à objetos, e
compreende noções de herança, polimorfismo e associações.
As Consultas não diferenciam maiúscula de minúscula, exceto pelo nomes das
classes e propriedades Java. Portanto, SeLeCT é o mesmo que sELEct que é o
mesmo que SELECT, mas org.hibernate.EXEMPLO não
é org.hibernate.Exemplo e exemplo.Teste não é exemplo.tEsTe.
EXEMPLOS DE HQL
// SELECT
Query query = session.createQuery("from pessoas where id = :id ");
query.setParameter("id", "2324");
// UPDATE
Query query = session.createQuery("update pessoas set nome = :nome where id = :id");
query.setParameter("nome", "Fulano");
query.setParameter("id", "2324");
// DELETE
Query query = session.createQuery("delete pessoas where id = :id");
query.setParameter("id", "2324");
HQL - CONCLUSÃO
Para realizarmos um INSERT, UPDATE ou DELETE, não precisamos escrever o
HQL como mostra o exemplo acima, apenas precisamos atribuir os devidos
valores para o POJO e utilizarmos um código como o citado abaixo para persistir
os dados:
try {
transacao = sessao.beginTransaction();
sessao.save(pojo);
transacao.commit();
} catch (Exception e) { }
Lazy
O Lazy no mapeamento dos relacionamentos determina se quando eu
acessar a class X, se ela irá trazer a classe Y.
Lazy=true não carrega o mapeamento de imediato.
Por exemplo: Pessoa e Endereço
A HQL "from Pessoa" carrega simplesmente Pessoa e não Endereço.
Quando você executar um getEndereco, aí ele vai no banco e busca os
dados.
INTRODUÇÃO A ARQUITETURA HIBERNATE
O Hibernate é um framework de mapeamento objeto relacional para aplicações Java, ou seja, é uma
ferramenta para mapear classes Java em tabelas do banco de dados e vice-versa. É bastante poderoso
e dá suporte ao mapeamento de associações entre objetos, herança, polimorfismo, composição e
coleções.
O Hibernate não apresenta apenas a função de realizar o mapeamento objeto relacional. Também
disponibiliza um poderoso mecanismo de consulta de dados, permitindo uma redução considerável no
tempo de desenvolvimento da aplicação.
Inicialmente, o mapeamento objeto relacional com Hibernate era feito a partir de um conjunto de
configurações em arquivos XMLS. Com o surgimento das anotações no Java SE 5.0, o framework
Hibernate anexou este recurso, permitindo que as classes Java fossem mapeadas a partir de anotações,
simplificando o seu uso.
ARQUITETURA HIBERNATE
• Session (org.hibernate.Session)
O objeto Session é aquele que possibilita a comunicação entre a aplicação e a persistência,
através de uma conexão JDBC. É um objeto leve de ser criado, não deve ter tempo de vida por
toda a aplicação e não é threadsafe. Um objeto Session possui um cache local de objetos
recuperados na sessão. Com ele é possível criar, remover, atualizar e recuperar objetos
persistentes.
• SessionFactory (org.hibernate.SessionFactory)
O objeto SessionFactory é aquele que mantém o mapeamento objeto relacional em memória.
Permite a criação de objetos Session, a partir dos quais os dados são acessados, também
denominado como fábrica de objetos Sessions. Um objeto SessionFactory é threadsafe, porém
deve existir apenas uma instância dele na aplicação, pois é um objeto muito pesado para ser
criado várias vezes.
• Configuration (org.hibernate.Configuration)
Um objeto Configuration é utilizado para realizar as configurações de inicialização do Hibernate.
Com ele, define-se diversas configurações do Hibernate, como por exemplo: o driver do banco de
dados a ser utilizado, o dialeto, o usuário e senha do banco, entre outras. É a partir de uma instância
desse objeto que se indica como os mapeamentos entre classes e tabelas de banco de dados
devem ser feitos.
• Transaction (org.hibernate.Transaction)
A interface Transaction é utilizada para representar uma unidade indivisível de uma operação de
manipulação de dados. O uso dessa interface em aplicações que usam Hibernate é opcional. Essa
interface abstrai a aplicação dos detalhes das transações JDBC, JTA ou CORBA.
• Interfaces Criteria e Query
As interfaces Criteria e Query são utilizadas para realizar consultas ao banco de dados.
ARQUITETURA HIBERNATE
ESPECIFICANDO O HIBERNATE.CFG.XML
• hibernate.dialect
Implementação do dialeto SQL específico do banco de dados a ser utilizado. Usado para identificar as particularidades do banco de dados;
• hibernate.connection.driver_class
nome da classe do driver JDBC do banco de dados que está sendo utilizado;
• hibernate.connection.url
é a URL de conexão específica do banco que está sendo utilizado;
• hibernate.connection.username
é o nome de usuário com o qual o Hibernate deve se conectar ao banco;
• hibernate.connection.password
é a senha do usuário com o qual o Hibernate deve se conectar ao banco;
• hibernate.show_sql
utilizado para definir se os SQL’S gerados pelo Hibernate devem ou não ser exibidos (true | false).
DIALETOS DO HIBERNATE
DB2 – org.hibernate.dialect.DB2Dialect
HypersonicSQL – org.hibernate.dialect.HSQLDialect
Informix – org.hibernate.dialect.InformixDialect
Ingres – org.hibernate.dialect.IngresDialect
Interbase – org.hibernate.dialect.InterbaseDialect
Pointbase – org.hibernate.dialect.PointbaseDialect
PostgreSQL – org.hibernate.dialect.PostgreSQLDialect
Mckoi SQL – org.hibernate.dialect.MckoiDialect
Microsoft SQL Server – org.hibernate.dialect.SQLServerDialect
MySQL – org.hibernate.dialect.MySQLDialect
Oracle (any version) – org.hibernate.dialect.OracleDialect
Oracle 9 – org.hibernate.dialect.Oracle9Dialect
Progress – org.hibernate.dialect.ProgressDialect
FrontBase – org.hibernate.dialect.FrontbaseDialect
SAP DB – org.hibernate.dialect.SAPDBDialect
Sybase – org.hibernate.dialect.SybaseDialect
Sybase Anywhere – org.hibernate.dialect.SybaseAnywhereDialect
ANOTAÇÕES
Para o mapeamento com anotações das entidades, serão utilizadas tanto anotações do pacote
javax.persistence.*, como do pacote org.hibernate.annotations.
Todas as classes persistentes mapeadas com anotações são declaradas usando a anotação @Entity,
aplicada em nível de classes. Quando o nome da classe é diferente do nome da tabela para a qual é
mapeada é necessário informar na anotação @Table qual o nome da tabela, usando o atributo name.
EXEMPLOS DE ANOTAÇÕES
@Table(name="aluno",schema="anotac
oes")
está informando o nome e o esquema da
tabela para qual está mapeada a classe
aluno.
@Id A chave primária da tabela é mapeada na classe.
@GeneratedValue permite a definição automática para o valor do
identificador, utilizando um dos mecanismos de
geração apresentados anteriormente.
@Column(name=“cod_aluno”) informando o nome da coluna, através do atributo
name.
Primeiro Exemplo
Criando a Classe “Veiculo”
Utilizamos as anotações
@Entity
Informa que a classe é um objeto persistente
@Table
Informa o nome da tabela
@Id
Informa a chave primaria
@Column
Informa que temos uma coluna
Primeiro Exemplo
Criando a tabela Veiculo no SGBD - MYSQL
CREATE DATABASE `hibernate_primeiro_exemplo`;
CREATE TABLE `hibernate_primeiro_exemplo`.`veiculo` ( `id` int(10) unsigned NOT
NULL auto_increment, `modelo` varchar(45) NOT NULL,
`cor` varchar(45) NOT NULL,
`ano` int(10) unsigned NOT NULL,
PRIMARY KEY (`id`));
Primeiro Exemplo
Configurando Hibernate
Instanciar um objeto de configuração (org.hibernate.cfg.Configuration) e inserir
suas propriedades programaticamente;
Usar um arquivo .properties com as suas configurações e indicar as classes
mapeadas programaticamente;
Usar um arquivo XML (hibernate.cfg.xml) com as propriedades de inicialização e os
caminhos das classes mapeadas.
Primeiro Exemplo
Configurando Hibernate
hibernate.dialect: implementação do dialeto SQL específico do banco de dados a ser utilizado. Usado
para identificar as particularidades do banco de dados;
hibernate.connection.driver_class: nome da classe do driver JDBC do banco de dados que está sendo
utilizado;
hibernate.connection.url: é a URL de conexão específica do banco que está sendo utilizado;
hibernate.connection.username: é o nome de usuário com o qual o Hibernate deve se conectar ao
banco;
hibernate.connection.password: é a senha do usuário com o qual o Hibernate deve se conectar ao
banco;
hibernate.connection.pool_size: tamanho do pool de conexões;
Parâmetro opcional:
hibernate.show_sql: utilizado para definir se os SQL’s gerados pelo Hibernate devem ou não ser
exibidos (true | false).
Primeiro Exemplo
Configurando Hibernate
Dialetos Existentes:
DB2 - org.hibernate.dialect.DB2Dialect
HypersonicSQL - org.hibernate.dialect.HSQLDialect
Informix - org.hibernate.dialect.InformixDialect
Ingres - org.hibernate.dialect.IngresDialect
Interbase - org.hibernate.dialect.InterbaseDialect
Pointbase - org.hibernate.dialect.PointbaseDialect
PostgreSQL - org.hibernate.dialect.PostgreSQLDialect
Mckoi SQL - org.hibernate.dialect.MckoiDialect
Microsoft SQL Server - org.hibernate.dialect.SQLServerDialect
MySQL - org.hibernate.dialect.MySQLDialect
Oracle (any version) - org.hibernate.dialect.OracleDialect
Oracle 9 - org.hibernate.dialect.Oracle9Dialect
Progress - org.hibernate.dialect.ProgressDialect
FrontBase - org.hibernate.dialect.FrontbaseDialect
SAP DB - org.hibernate.dialect.SAPDBDialect
Sybase - org.hibernate.dialect.SybaseDialect
Sybase Anywhere - org.hibernate.dialect.SybaseAnywhereDialect
Primeiro Exemplo
Salvando um objeto
Session (org.hibernate.Session)
Possibilita a comunicação entre a aplicação e a persistência, através de uma
conexão JDBC. É um objeto leve de ser criado, não deve ter tempo de vida por
toda a aplicação. Com ele é possível criar, remover, atualizar e recuperar
objetos persistentes.
SessionFactory (org.hibernate.SessionFactory)
Mantém o mapeamento objeto relacional em memória. Permite a criação de
objetos Session, a partir dos quais os dados são acessados, também
denominado como fábrica de objetos Sessions. Deve existir apenas uma
instância dele na aplicação, pois é um objeto muito pesado para ser criado
várias vezes.
Primeiro Exemplo
Configuration (org.hibernate.Configuration)
Utilizado para realizar as configurações de inicialização do Hibernate. Define-se
diversas configurações como por exemplo: o driver do banco de dados a ser
utilizado, o dialeto, o usuário e senha do banco, entre outras.
Transaction (org.hibernate.Transaction)
Representa uma unidade indivisível de uma operação de manipulação de dados. O
uso dessa interface em aplicações que usam Hibernate é opcional.
CONSTRUINDO PRIMEIRA APLICAÇÃO COM
HIBERNATE Para construir o exemplo você precisará das seguintes ferramentas:
a) Uma instalação funcional do Hibernate - Baixe, instale e teste uma versão recente do Hibernate.
b) O banco de dados MySQL - Baixe, instale e teste uma versão recente do MySQL. Você encontrará esta informação no site do MySQL também. c) Netbeans - Certifique-se de estar usando uma versão bem atual do Netbeans. Faça o download aqui: http://netbeans.org/downloads/
d) O Java SDK - Para este exemplo nós vamos usar XML para fazer o mapeamento entre a nossa classe e o banco de dados MySQL (um arquivo *.hbm.xml). Por enquanto não usaremos Annotations. Assim, qualquer Java SDK maior que 1.4 servirá. e) MySQL Connector/J - Este é o driver usado para fazer a ponte JDBC e o banco de dados MySQL.
PREPARANDO BANCO DE DADOS
A aplicação que vamos construir é bem simples. Teremos apenas o id, nome, e-mail e
senha de um usuário. Assim, crie uma base de dados chamada "estudos" e crie a
seguinte tabela MySQL: Código:
CREATE DATABASE estudos.usuario;
CREATE TABLE estudos.usuarios ( id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, nome VARCHAR(45) NOT NULL, email VARCHAR(45) NOT NULL, senha VARCHAR(10) NOT NULL, PRIMARY KEY (id) ) ENGINE = InnoDB;
Veja que o campo id é do tipo int, auto-incremento e chave primária. Desta forma, o
Hibernate deverá saber como incrementar os valores deste campo automaticamente.
Hora de passarmos para o IDE Netbeans.
CRIANDO A APLICAÇÃO NO NETBEANS
Se você ainda não o fez, abra o Netbeans e crie um novo projeto. Vá em Arquivo
-> Novo Projeto -> Java -> Aplicativo Java. Dê o nome "exemplo_hibernate" ao
projeto e salve-o no diretório de sua preferência. Sugiro que deixem na pasta
"C:\estudos_hibernate" . Clique no botão Finalizar.
Agora vamos criar um POJO (Plain Old Java Object). Qualquer classe Java pode ser
persistida em um banco de dados por meio do Hibernate. Assim, vá em Arquivo ->
Novo Arquivo -> Java - Classe Java. Dê o nome "Usuario" para a classe e coloque-a
em um pacote com um nome, exemplo, "osmar“.
Sua estrutura de arquivo e pacotes deverá agora estar semelhante à imagem a seguir:
CRIANDO A APLICAÇÃO NO NETBEANS
CRIANDO A APLICAÇÃO NO NETBEANS Usuario.java:
package osmar; public class Usuario{ private int id; private String nome; private String email; private String senha; public int getId(){ return id; } public void setId(int id){ this.id = id; } public String getNome(){ return nome; } public void setNome(String nome){ this.nome = nome; } public String getEmail(){ return email; } public void setEmail(String email){ this.email = email; } public String getSenha(){ return senha; } public void setSenha(String senha){ this.senha = senha; } }
CRIANDO A APLICAÇÃO NO NETBEANS Analise o código desta classe cuidadosamente e vamos passar para o arquivo de mapeamento. Clique com
o botão direito em "Pacotes de Códigos Fonte" e escolha Novo -> Documento XML. Dê o
nome usuario.hbm.xml e deixe o campo pasta como "src". Agora altere seu conteúdo para:
Conteúdo para usuario.hbm.xml:
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="osmar.Usuario" table="usuarios"> <id name="id" type="int" column="id"> <generator class="increment"/> </id> <property name="nome"> <column name="nome"/> </property> <property name="email"> <column name="email"/> </property> <property name="senha"> <column name="senha"/> </property> </class> </hibernate-mapping>
CRIANDO A APLICAÇÃO NO NETBEANS Temos agora a tabela no banco de dados, a classe Usuario e o arquivo de mapeamento entre a classe e a tabela do banco de
dados. Podemos passar agora para o arquivo de configuração do Hibernate. Clique com o botão direito em "Pacotes de Códigos
Fonte" e escolha Novo -> Documento XML. Dê o nome "hibernate.cfg.xml" ao arquivo e deixe o campo pasta como "src". Isso fará
com que o arquivo de configuração do Hibernate seja colocado no raiz do projeto. Veja o conteúdo para este arquivo:
Conteúdo para hibernate.cfg.xml:
<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url"> jdbc:mysql://localhost/estudos</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">123456</property> <property name="hibernate.connection.pool_size">10</property> <property name="show_sql">true</property> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.hbm2ddl.auto">update</property> <!-- Arquivos de Mapeamento --> <mapping resource="usuario.hbm.xml"/> </session-factory> </hibernate-configuration>
CRIANDO A APLICAÇÃO NO NETBEANS
Até este momento sua estrutura de arquivos e pacotes deverá estar assim:
CRIANDO A APLICAÇÃO NO NETBEANS
Vamos passar para a classe principal da aplicação. Antes, clique com o botão
direito em Bibliotecas -> Adicionar JAR/Pasta e localize o JAR hibernate3.jar.
Marque Caminho Absoluto e clique o botão Open. Faça o mesmo com o driver
do banco de dados MySQL (ex: mysql-connector-java-5.1.10-bin.jar).
Em seguida o código da classe principal (Main.java).
CRIANDO A APLICAÇÃO NO NETBEANS - Código
para Main.java package exemplo_hibernate;
import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; import osmar.Usuario; public class Main { public static void main(String[] args) { Session session = null; try { // aqui nós lemos as configurações do arquivo hibernate.cfg.xml // e deixamos o Hibernate pronto para trabalhar SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); session = sessionFactory.openSession(); // vamos criar uma nova instância da classe Usuario // e definir valores para seus atributos // note que não precisamos atribuir valores para // o atributo id System.out.println("Vou gravar um novo usuário"); Usuario u = new Usuario();
u.setNome("Osmar J. Silva");
u.setEmail("[email protected]");
u.setSenha("1234");
Transaction tx = session.beginTransaction();
session.save(u); // vamos salvar o usuário
session.flush();
tx.commit();
System.out.println("Finalizei. Veja a tabela usuarios");
}
catch(Exception e){
System.out.println(e.getMessage());
}
finally{
session.close();
}
}
}
CRIANDO A APLICAÇÃO NO NETBEANS
Vamos executar o programa. Aperte a tecla F6 e se prepare para a primeira
mensagem:
Exception in thread "main" java.lang.NullPointerException
at exemplo_hibernate.Main.main(Main.java:40)
CRIANDO A APLICAÇÃO NO NETBEANS
Essa é fácil. Mova as linhas:
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
session = sessionFactory.openSession();
CRIANDO A APLICAÇÃO NO NETBEANS
Para fora do bloco try:
SessionFactory sessionFactory =
new Configuration().configure().buildSessionFactory();
session = sessionFactory.openSession();
try {
.
.
.
CRIANDO A APLICAÇÃO NO NETBEANS
E execute novamente. Agora temos mais informações sobre o motivo da
exceção:
Exception in thread "main" java.lang.NoClassDefFoundError:
org/dom4j/DocumentException
at exemplo_hibernate.Main.main(Main.java:14)
Caused by: java.lang.ClassNotFoundException: org.dom4j.DocumentException
at java.net.URLClassLoader$1.run(URLClassLoader.java: 200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.j ava:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:3 07)
at sun.misc.Launcher$AppClassLoader.loadClass(Launche r.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:2 52)
at java.lang.ClassLoader.loadClassInternal(ClassLoade r.java:320)
... 1 more
CRIANDO A APLICAÇÃO NO NETBEANS
SLF4J: The requested version 1.6 by
your slf4j binding is not compatible
with [1.5.5, 1.5.6, 1.5.7,1.5.8]
SLF4J: See [...] for further details.
org.hibernate.cfg.Environment <clinit>
INFO: Hibernate 3.5.1-Final
org.hibernate.cfg.Environment <clinit>
INFO: hibernate.properties not found
org.hibernate.cfg.Environment
buildBytecodeProvider
INFO: Bytecode provider name :
javassist
org.hibernate.cfg.Environment <clinit>
INFO: using JDK 1.4 java.sql.Timestamp handling
org.hibernate.cfg.Configuration configure
INFO: configuring from resource: /hibernate.cfg.xml
org.hibernate.cfg.Configuration
getConfigurationInputStream
INFO: Configuration resource: /hibernate.cfg.xml
Exception in thread "main"
org.hibernate.HibernateException: /hibernate.cfg.xml not
found
at org.hibernate.util.ConfigHelper.getResourceAsStrea
m(ConfigHelper.java:170)
at org.hibernate.cfg.Configuration.getConfigurationIn
putStream(Configuration.java:1497)
at org.hibernate.cfg.Configuration.configure(Configur
ation.java:1519)
at org.hibernate.cfg.Configuration.configure(Configur
ation.java:1506)
at exemplo_hibernate.Main.main(Main.java:14)
Isso aconteceu porque não importamos os JARs obrigatórios do pacote required do Hibernate. Em uma
máquina estes JARs podem estar em "C:\hibernate\lib\required". Assim, clique com o botão direito em
Bibliotecas –> Adicionar JAR/Pasta e importe todos os JARs desta pasta. Execute a aplicação
novamente. Se tiver sorte, a aplicação será iniciada com sucesso. Para alguns, uma exceção parecida
com o conteúdo abaixo será exibida:
CRIANDO A APLICAÇÃO NO NETBEANS
org.hibernate.cfg.Environment <clinit>
INFO: Hibernate 3.5.1-Final
org.hibernate.cfg.Environment <clinit>
INFO: hibernate.properties not found
org.hibernate.cfg.Environment
buildBytecodeProvider
INFO: Bytecode provider name : javassist
org.hibernate.cfg.Environment <clinit>
INFO: using JDK 1.4 java.sql.Timestamp
handling
org.hibernate.cfg.Configuration configure
INFO: configuring from resource:
/hibernate.cfg.xml
org.hibernate.cfg.Configuration
getConfigurationInputStream
INFO: Configuration resource: /hibernate.cfg.xml
Exception in thread "main"
org.hibernate.HibernateException: /hibernate.cfg.xml not
found
at org.hibernate.util.ConfigHelper.getResourceAsStrea
m(ConfigHelper.java:170)
at org.hibernate.cfg.Configuration.getConfigurationIn
putStream(Configuration.java:1497)
at org.hibernate.cfg.Configuration.configure(Configur
ation.java:1519)
at org.hibernate.cfg.Configuration.configure(Configur
ation.java:1506)
at exemplo_hibernate.Main.main(Main.java:14)
Este é um exemplo clássico de diferença da versão de biblioteca exigida pelo Hibernate e aquela
disponível ou disponibilizada junto com o download. Para esta simulação, basta substituir o JAR slf4j-api-
1.5.8.jar por slf4j-api-1.6.0.jar. Outra exceção que você poderá encontrar é:
CONCLUINDO A APLICAÇÃO NO NETBEANS OBS. Isso acontece quando o arquivo de configuração hibernate.cfg.xml não é encontrado. Para solucionar,
verifique se o arquivo está realmente na raiz da aplicação, ou seja, sua estrutura de arquivos e
diretórios deve ser parecida com:
OS HÁBITOS MAIS EFICAZES NO DESENVOLVIMENTO E
OS PRINCIPAIS ERROS
Connection Pool – Utilizar o pool de conexões embutido com o Hibernate é um erro comum, e
a própria documentação diz que você não deve usá-lo em produção. Podendo dar Conexions
Leak.
Second Level Cache – Todos já passamos por situações em que precisamos criar caches
para as linhas de banco de dados mais acessadas. Aqui temos diversos problemas:
sincronismo, gasto de memória, memory leak, tamanho do cache, política de prioridade da
fila (LFU, LRU, FIFO, etc), tempo de expiração e modos de invalidar o cache. Escrever um
cache eficiente e seguro é um grande trabalho, imagine ainda dar suporte a um cache
distribuído e que possa se aproveitar do disco rígido para não gastar tanta memória? Esse é
o papel do second level cache. Você pode usá-lo com diversos providers, sendo
o EhCache um dos mais conhecidos.
OS HÁBITOS MAIS EFICAZES NO DESENVOLVIMENTO E
OS PRINCIPAIS ERROS
Query Cache (cache de busca)– Um recurso fantástico do Hibernate. No caso de você ter
queries que são executadas inúmeras vezes, você pode pedir para o Hibernate fazer o
cache do resultado desta query. O interessante é que ele não vai armazenar todos os
objetos resultantes, e sim apenas suas primary keys: no momento que ele precisar executar
novamente aquela query, ele já tem todos os IDs resultantes, e através destes ele consulta o
second level cache, sem fazer um único hit ao banco de dados! Esse cache será invalidado
quando alguma das tabelas envolvidas nesta query for atualizada, ou um determinado tempo
passar.
Controle do Lazy – Algumas pessoas costumam reclamar do lazy loading, dizendo que em
alguns casos teria sido melhor ele carregar tudo em uma única query. Você sempre pode
redefinir o comportamento desses relacionamentos quando fizer uma query.