Cursojava
Cursojava
Coordenação
Prof. Francisco Eugenio BARRELLA barrella@[Link]
Prof. EDSON Gonzalez Martins emartins@[Link]
Consultoria Técnica
Prof. UIRES Tapajós Cabral uires@[Link]
Docentes da Disciplina
Prof. FERNANDO José Moura Marcellino fmarcellino@[Link]
Prof. JULIANO Ribeiro Ipolito jipolito@[Link]
Prof. RILDO Ferreira dos Santos rildosan@[Link]
● E-mail da Equipe;
● Código da turma;
O que é o Java ?
O Java é:
● Uma linguagem de programação;
● Um ambiente de desenvolvimento;
● Um ambiente de aplicação.
O Java é resultado de uma busca por uma plataforma de programação que pudesse
fornecer segurança, portabilidade (independência de sistema operacional) e
escalabilidade.
Os primeiros objetivos alcançados com desenvolvimento desta nova linguagem foram:
* Orienta a objetos: A linguagem é orienta a objetos a partir de sua arquitetura,
permitindo herança, polimorfismo, encapsulamento, abstração de dados e persistência
de objetos e reúso de código.
* Velocidade no desenvolvimento - eliminando o ciclo de compilar-linkedição;
* Portabilidade do Código - com um interpretador que especifica a forma do nível
do sistema operacional. (Pode rodar em qualquer tipo de sistema operacional, tais
como Solaris, AIX, Linux, MacOS, Win32, PalmOS e etc);
* Dinamismo: A natureza dinâmica do Java, sendo uma extensão natural de seu
projeto orientado a objetos, permite a extensibilidade durante a execução.
* Alto desempenho: Suporte há vários recursos, como multhreading, compilação
em Jus-in-time, atomização do código e suporte a protocolos de rede (TCP/IP)
* Facilidade de manutenção de programas;
Linguagem não tem:
● Ponteiros do sistema operacional;
● Defines;
● Sobrecarga de operadores;
Paradigma:
"Paradigma é um conjunto de regras que estabelecem fronteiras e descreve como
resolver os problemas dentro destas fronteiras.
Os paradigmas influenciam nossa percepção, ajudam-nos a organizar e a coordenar a
maneira como olhamos para o mundo..."
Reengenharia - Reestruturando a Empresa
Daniel Morris e Joel Brandon
Orientação a Objetos:
O termo orientação a objetos significa organizar o mundo real como uma coleção de
objetos que incorporam estrutura de dados e um conjunto de operações que
manipulam estes dados
Exemplos
Coisas tangíveis = um livro
Incidente = Copa do Mundo de Futebol
(evento/ocorrência)
Interação = Débitos de CPMF
(transação/contrato)
Metáfora
Declaração finally
A declaração finally é utilizada para definir o bloco que irá ser executado tendo ou
não uma exception, isto após o uso da declaração de try e catch.
try {
// código que pode ocasionar uma exception
}
catch{
// tratamento do erro
}
finally {
// código
}
Exceptions mais comuns
ArithmeticException - int i = 12 / 0
O Pacote [Link]
No pacote [Link] contém as classes para a geração de componentes Gui. Os
componentes Gui geralmente são de aspectos visíveis, como butões ou labels.
Posição dos componentes
A posição dos componentes no container é determinado pelo gerente de layout. O
tamanho dos componentes é também de responsabilidade do gerente de layout.
O método main()
É responsável pela criação da instância de objetos e pela inicialização do método go().
O new Frame
Cria uma instância da classe [Link]. O Frame no java é o nível mais alto da
janela, aonde ficam por exemplo o barra de títulos.
O setLayout()
Cria uma instância do fluxo do gerente de layout, aonde é colocado o Frame.
O new Button()
Cria uma instância da classe [Link]. O botão é o local na janela aonde é
empurrado para que se tenha uma ação.
O add()
Éste método adiciona elementos (butões, caixas de texto, etc.) ao frame.
O pack()
Este método fixa o tamanho dos elementos no frame.
O setVisible()
Este método torna os elementos visíveis no frame.
O Flow Layout Manager
O flow layout para posicionar componentes em uma determinada linha ou conjunto de
linhas. A cada instante uma nova linha fica cheia e uma nova linha é começada.
O Border Layout Manager
É mais complexo do que o Flow Layout Manager, pois fornece componentes que
possibilitam manusear o posicionamento do elemento dentro do container.
O Grid Layout Manager
Você pode criar linha e colunas dentro de seu container.
O CardLayout
Permite você criar duas interfaces semelhantes a butões, sendo entretanto o painel
completo.
Frame
É uma armação aonde são inseridos diversos elementos como: botões, labels, etc.
O que é um Applet?
Um applet é um pedaço de código de Java que corre em um ambiente de browser.
Difere de uma aplicação do modo que é executado. Uma aplicação é começada
quando seu método main() é chamado. Através de contraste, o ciclo de vida de
um applet é um pouco mais complexo. Este módulo examina como um applet é
corrido, como carregar isto no browser, e como escrever o código para um applet.
Carregando um Applet
Você tem que criar um arquivo de HTML que conta para o browser o que carregar
e como correr isto. Você então "aponta" o browser ao URL que especifica aquele
arquivo de HTML.
Segurança e Restrições nos Applet
Existem Seguranças e Restrições nos Applets porque applets são pedaços de
código que são carregados em cima de arames, eles representam um prospecto
perigoso; imagine se alguém escrever um programa malicioso que lê seu arquivo
de contra-senha e envia isto em cima da Internet?
O modo que Java previne isto está contido na classe de SecurityManager que
controla acesso para quase toda chamada de sistema-nível no Java Máquina
Virtual (JDK).
Portanto Applets não faz chamadas ao seu sistema operacional.
Métodos de Applet chaves
Em uma aplicação, no programa é entrado ao método main(). Em um applet,
porém, este não é o caso. O primeiro código que um applet executa é o código
definido para sua inicialização, e seu construtor.
Depois que o construtor é completado, o browser chama um método no applet
chamado init (). O método init () executar inicialização básica do applet . Depois de
init () é completado, o browser chama outro método chamado start ().
Applet Display
Você pode puxar sobre a exibição de um applet criando um método paint(). O
método paint() é chamado pelo ambiente de browser sempre que a exibição do
applet precise ser refrescado. Por exemplo, isto acontece quando a janela de
browser é aparecida depois de ser minimizado.
Camada de abstração que permite um aplicativo Java utilizar uma interface padrão (que
adere ao ANSI-2 SQL) para fazer acesso a banco de dados relacional, através da linguagem
SQL.
ODBC (Open Database Connectivity) também é uma interface de acesso a banco de dados
relacionais que possui drivers para um grande número de banco de dados.
Uma aplicativo Java pode utilizar diretamente uma interface ODBC, mas isto implica em
executar chamadas, dentro do código Java, a rotinas C da API do ODBC, chamadas com
código nativo Java são trabalhosas e elimina a portabilidade de uma aplicação.
Um programa Java (API Java Servlet é uma extensão da plataforma Java) que expande
a funcionalidade de Servidor Web, gerando conteúdo dinâmico e interativo com
Clientes Web usando o paradigma requisição-resposta.
Principal características:
● Um servlet executa somente no Side Server (lado servidor).
Serviços:
Um servlet pode fornecer vários serviços ao servidor web como por exemplo:
● processar formulários de pedido;
● persistência de conexões http;
● acesso a Banco de Dados;
● envio de e-mails automáticos;
● agentes de procura;
● compatibilidade com vários protocolos (http, url, ftp)
O que são aplicação web ?
São Aplicações que estão armazenadas em um único local e são acessadas
remotamente por dispositivos conectados a internet.
As principais vantagens são:
● clientes leves;
● facilidade de manutenção (centralização);
● grande abrangência do software;
● baixo custo de operação;
● Custo médio por transação bancária.
É uma script Java para desenvolvimento de aplicações Web dinâmica utilizando HTML, Em
segundo plano todo arquivo JSP é convertido em um arquivo Servlet e enviado ao cliente. As
outras tecnologias Java são acionadas pelo JSP via tags específicos. Veio para atender a
facilidade de manipulação do HTML.
Características do JSP - JavaServer Pages:
● Estrutura básica do JSP
● Elementos de script
● Trabalhado com um JavaBean
● Tipos de variáveis
● Estruturas de controle
● Declaração de funções
● Definindo classes
● Passagem de parâmetros
Exemplos:
<HTML>
<HEAD>
<TITLE>JSP JDBC Example 1</TITLE>
</HEAD>
<BODY>
<!-- Set the scripting language to java and -->
<!-- import the [Link] package -->
<%@ page language="java" import="[Link].*" %>
<%
Connection con = null;
try {
// Load the Driver class file
[Link]("[Link]");
// Make a connection to the ODBC datasource Movie Catalog
con = [Link]("jdbc:odbc:Movie Catalog", "", "");
// Create the statement
Statement statement = [Link]();
// Use the created statement to SELECT the DATA
// FROM the Titles Table.
ResultSet rs = [Link]("SELECT * " + "FROM Titles");
// Iterate over the ResultSet
%>
<!-- Add an HTML table to format the results -->
<TABLE BORDER="1">
[Link] (1 of 3) [01/09/2000 19:18:39]
JSP
<TR>
<TH>Title</TH><TH>Rating</TH><TH>Price</TH><TH>Quantity</TH>
<%
while ( [Link]() ) {
// get the title_name, which is a String
[Link]("<TR>\n<TD>" + [Link]("title_name") + "</TD>");
// get the rating
[Link]("<TD>" + [Link]("rating") + "</TD>");
// get the price
[Link]("<TD>" + [Link]("price") + "</TD>");
// get the quantity
[Link]("<TD>" + [Link]("quantity") + "</TD>\n</TR>");
}
// Close the ResultSet
[Link]();
}
catch (IOException ioe) {
[Link]([Link]());
}
catch (SQLException sqle) {
[Link]([Link]());
}
catch (ClassNotFoundException cnfe) {
[Link]([Link]());
}
catch (Exception e) {
[Link]([Link]());
}
finally {
try {
if ( con != null ) {
// Close the connection no matter what
[Link](); }
}
catch (SQLException sqle) {
[Link]([Link]());
● Utilizar um pool de conexões para acesso ao banco de dados é uma das formas de
contornar o problema de compartilhamento de recursos.
● É possível iniciar o pool de conexões no método init( ) abrindo 20 conexões
simultaneas ao BD e compartilhando-as nas várias chamadas ao método service(
).
Conclusões
Para desenvolver este servlet foram necessárias três horas para implementar toda a
sua funcionalidade, desde a fase de planejamento, passando pelo design, codificação,
compilação e testes e utilizadas pouco mais de 120 linhas de código. Isto é um ponto
muito importante que deve ser ressaltado. É impressionante como Java, sendo uma
linguagem comparada a C++, pode ser tão produtiva, tanto em funcionalidade quanto
em facilidade de desenvolvimento. Isso não é papo de vendedor, é uma análise feita
por grande parte dos desenvolvedores java.
Você viu como fazer a conexão de um servlet a um banco de dados e partindo deste
exemplo você pode criar os mais variados tipos de aplicações para seu site Web ou
para a Internet de sua empresa, como um guestBook ou um fórum de discussão.
Você percebeu como a migração de aplicações Java para a Internet pode ser feita de
forma fácil com os Servlets, construindo inclusive aplicações em camadas. Você pode
ter um applet fazendo a interface com o cliente e enviando informações para um
servlet no servidor, fazendo um balanceamento de carga nas tarefas de cada camada.
Foi descrito também o ciclo de vida de um servlet e seus métodos mais utilizados.
Considerações
Este serviço de busca foi desenvolvido com o intuito de apresentar as funcionalidades
de um servlet e seu acesso a banco de dados, não tendo em momento algum a
intenção de ser um serviço de busca completo e final. Você tem toda a liberdade de
alterar o código fonte e implementar novas funcionalidades ao servlet.
Livros:
● Aplicações e Banco de Dados para Internet 199 - Editora Érica - Antonio Marcos Marcon e
Denise Neves
● Programando Banco de Dados em JAVA - 1997 - Editora Makrn Books - Brian Jepson
● Java Servlet Programming - 1998 - Editora O'Reilly - Jason Hunter e Willian Crawford
[Link]
[Link]
[Link]
Foruns: [Link]
1. BeanBox - [Link]
2. Virtual Instrumentation Beans - [Link]
3. Spirit - [Link]
4. JClass Enterprise Suite - [Link]
5. JSuite - [Link]
6. Java SpatialX Toolkit - [Link]
7. StudioJ - [Link]
8. CocoBase - [Link]
9. Formula One for Java - [Link]
10. J-Spell - [Link]
11. alphaBeans - [Link]
12. ICE Browser - [Link]
1. J'Express - [Link]
2. InstallShield Java Edition - [Link]
3. DashO-Pro - [Link]
4. InstallAnywhere - [Link]
5. Install Toolkit for Java - [Link]
6. InstallWiz Professional Edition - [Link]
1. SourceGuard - [Link]
2. Jcloak - [Link]
3. ObfuscatePro - [Link]
4. RetroGuard - [Link]
5. OuyaSafe - [Link]
6. Elixir IDE - [Link]
· Uma aplicação web é constituída de forma semelhante ao mundo real, onde temos
um fornecedor de serviços (Servidor) e o cliente.
· Nos servidores temos as páginas HTML, applets/Servlets Java, imagens, e-mails e
dados.
· Cliente envia uma requisição para o servidor solicitando alguma informação.
O software necessário no servidor para uma aplicação web na maioria das vezes:
● Servidor Web;
● Servidor de Mail;
● Java.
No cliente:
● Browser
● Telefone Celular
● Palm Pilot
● performance;
● extensibilidade;
● facilidade;
Independência de plataforma
● Os Servlets podem rodar em qualquer plataforma sem serem reescritos e até
mesmo compilados novamente.
● Os servlets podem ser executados em vários sistemas operacionais (Linux, AIX,
NT, Solaris) utilizando um grande número de servidores Web com acesso a
vários tipos de bancos de dados.
Performance
● Um novo programa CGI é carregado para cada requisição ao servidor. Um
Servlet é carregado apenas uma vez e para cada nova requisição este Servlet
gera um novo thread.
● método init() do Servlet, assim como nas Applets, ocorre apenas na primeira
vez que a classe é carregada.
● A SUN liberou a pouco tempo uma nova versão do HotSpot, um compilador
dinâmico, focado principalmente para servidores. Você pode conseguir uma
cópia em [Link]
● HotSpot verifica em tempo de execução o código do servlet java em busca de
pontos com lentidão de performance e tenta resolver estes problemas on the
fly.
Extensibilidade
● Com Java você pode criar aplicações muito mais modulares, tirar todo o
proveito da orientação a objetos e utilizar o grande número de APIs disponíveis
pela Javasoft e terceiros.
● Que tal acessar o banco de dados usando JDBC, gravar os dados do cartão de
crétido do cliente usando JCE para criptografar e confirmar informações com o
JavaMail ?
Facilidade de desenvolvimento
● Programar em Java é muito mais fácil que programar em C ou PERL. Algumas
IDEs Java, como o Visual Age da IBM e o Borland JBuilder, auxiliam na criação
de servlets Java.
● Quem já desenvolve Applets ou programas java simples já está capacitado a
desenvolver Servlets Java e páginas JSP.
Servlets Engines
● Allaire JRun
● Apache Web Server JServ
● Caucho Resin
● iServer
● New Atlanta Communication - ServletExec
● Gefion Software - WAICoolRunner
● Veja mais em:
[Link]
Application Server
● BEA Weblogic Application Server
● IBM WebSphere Application Server
● Inprise Application Server
● iPlanet Application Server 6.0
● Lutris Technologies Enhydra
● Orion Application Server
● NetDynamics Application Server
● Silverstream Application Server
● Veja mais em:
[Link]
O método service( )
● Este é o núcleo de um servlet, é neste método que as requisições são recebidas,
onde ocorre o processamento e o envio da resposta para o cliente.
● Este método recebe dois parâmetros um ServletRequest e um ServletResponse
que correspondem a Requisição e Resposta.
O Objeto ServletRequest
● O objeto ServletRequest contém os dados enviados pelo cliente.
● Estes dados são formados em pares de nome/valor e obtidos através do método:
String getParameter(String)
● Usaremos este objeto ou uma especialização dele para obter uma série de
informações sobre o cliente.
O objeto ServletResponse
● Representa a resposta do servlet para o cliente. Quanto todo o processamento
estiver concluído usaremos este objeto para enviar as informações.
● O método void setContentType(String) deve ser chamado para definir o tipo de
resposta.
● método getOutputStream( ) ou getWriter() deve ser usado para enviar os dados
para o cliente.
O método service( )
O método service() manipula as requisições HTTP recebidas do cliente através do
parâmetro ServletRequest e em seguida envia a requisição ao método
desenvolvido especificamente para manipular aquele tipo de requisição.
● Alguns destes métodos são:
● doGet para requisições GET e HEAD
● doPost para requisições POST
● doPut para requisições PUT
● doDelete para requisições DELETE
● doOptions para requisições OPTIONS
O método destroy( )
● É chamado antes que o servlet seja finalizado a fim de possibilitar a liberação dos
recursos que estão sendo usados pelo servlet.
● É importante usar alguns flags para certificar que o todos os outros métodos já
foram concluídos antes de finalizar o servlet.
● Compile o Servlet.
Código:
Source Code for HelloWorld Example
import [Link].*;
import [Link].*;
import [Link].*;
Classes Utilitárias
● [Link]
● Esta interface faz com o que o servlet trabalhe sempre com apenas uma linha
de execução para o método service.
● O servlet fica mais fácil porém mais lento em requisições concorrentes.
● [Link]
● [Link]
Suporte HTTP
● O pacote [Link] é fornecido para manipular o protocolo HTTP.
● GET
● HEAD
● POST
● PUT
● DELETE
● TRACE
● CONNECT
● OPTIONS
import [Link].*;
import [Link].*;
import [Link].*;
public class CookieExample extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
[Link]("text/html");
PrintWriter out = [Link]();
Exercício 01
class Prog1 extends Thread
{ int a = 0;
public void run(){
for(int r=0;r<7;r++)
{ a = a+1; [Link](getName()+" "+a);}
}
}
Tipos de Drivers
1- Ponte JDBC-ODBC com driver ODBC
2- Driver com API parcialmente nativa
3- Driver puro-Java JDBC-rede
4- Driver puro-Java com protocolo nativo
O Tipo 1 - Ponte
O acesso ao banco de dados via driver ODBC convencional. A ponte possui código
nativo a fim de fazer chamadas à API ODBC. Como pode ser visto na figura abaixo,
tanto a ponte quanto o driver ODBC devem residir na máquina onde está o
programa Java (uma vez que as chamadas são locais). Isso exige um controle maior
sobre a distribuição do aplicativo Java (Cliente/Servidor)
Desvantagens
- Maior custo de manutenção
- Maior custo de aquisição (lincesas do Client)
- Nem sempre é portavel (dependencia do Banco de Dados)
Tipo 3 – Driver puro-Java JDBC-Rede
Este é tipo mais flexível de driver. Pode ser escrito totalmente em Java. Odriver
acessa um servidor usando um protocolo neutro (HTTP, RMI, IIOP e etc). Este
servidor por sua vez estabelece a conexão com um ou mais gerenciadores de
banco de dados. Pelo fato do protocolo usado ser neutro, este driver pode ser
usado para acessar um banco de dados protegido por "firewall". Este é um
exemplo de três camadas.
Geralmente não é instalar o driver, já que é uma classe Java que pode ser
carregada como as outras (inclusive em Applets).
Vantagem
- Não instalação do Client
- Tamanho do driver
- Melhor performance em relação ao driver que Ponte
Um desenvolvedor que utiliza um driver não precisa saber como ele foi codificado,
entretanto deve saber que é suficiente carregar o driver para que ele se registre no
DriverManager.
Para carregar o driver pode-se usar um dos 3 modos:
- Carga dinâmica da classe com o método ClassforName:
[Link]("[Link]");
- Instanciação de um objeto para forçar a carga da classe:
new [Link]();
- Atribuição a variáveis do sistema, no momento de invocação do aplicativo Java, com a
opção –D
Java –[Link]=[Link] Aplicativo
Programa exemplo: PASSO A PASSO:
Para fazermos uma conexão com banco de dados devemos seguir os passos:
Primeiro: Importar [Link] (import [Link])
Segundo: Carregar Driver JDBC;
Terceiro: Especificar um banco de dados (através da URL de conexão).
Quarto: Abrir uma conexão com o banco de dados;
Quinto: Criar um Statement;
Sexto: Submeter um comando SQL (select, update, insert, delete);
Sétimo: Receber os resultados
[Link] (1 of 4) [01/09/2000 19:19:04]
Driver Manager
Oitavo: Encerrar a sessão
Exemplo 1: Tipo 1 – Ponte:
//passo 1
import [Link];
public class DBConexao {
//Construtor
public void DBConexao() {
try {
//passo 2
[Link] ("[Link]:[Link]");
//passo 3 – URL de conexão com a ponte jdbc-odbc
String URL = "jdbc:odbc:data"
//passo 4 – URL : da etapa anterior + usuário + senha
Connection con = [Link](URL, "nome do usuário", "senha");
//passo 5
Statement stmt = [Link]();
//passo 6 – query
String sql = "Select * from Tabela"
ResultSet rs = [Link](sql);
//passo 7 – laço
while ([Link]()) {
//getstring(n) = onde n posição da coluna na tabela (resultset)
[Link]([Link](1));
[Link]([Link](2));
[Link]([Link](3));
[Link]([Link](4));
}
} catch([Link] e)
{ [Link]():
}finally {
//passo 8 – encerrando a sessão
[Link]();
[Link]();
[Link]();
[Link] (2 of 4) [01/09/2000 19:19:04]
Driver Manager
}
Exemplo 2: Tipo 4 thin driver
import [Link].*;
public class TesteJdbc {
public static void main(String[] args) {
try {
// [Link]("[Link]");
new [Link]();
String strCon = "jdbc:oracle:thin:@[Link]:1521:ORCL";
String sql;
Connection con =
[Link](strCon,"jcurso","jcurso");
sql="DELETE TABELA WHERE CHAVE like ? AND DATAINI = ?";
PreparedStatement pstmt = [Link](sql);
[Link](1, "C");
[Link](2, new Date());
[Link]();
Statement stmt = [Link]();
sql = "SELECT * FROM TABELA";
ResultSet rs = [Link](sql);
while([Link]()) {
String chave = [Link]("CHAVE");
String valor = [Link]("VALOR");
[Link](chave + ": " + valor);
}
[Link]();
[Link]();
[Link]();
} catch(SQLException e) {
[Link]();
} catch(Exception e) {
[Link]();
}
JDBC permite definir transações nos acessos aos banco de dados. Transações são
grupos de comandos SQL que devem ser executados por inteiro. Assim, o processo de
COMMIT finaliza a transação anterior e começa outra, que vai terminar no próximo
instrução COMMIT e assim por diante. Um ROLLBACK, desfaz todos os comandos
anteriores deste o último COMMIT.
O banco de dados garante que a transação iniciada, mas terminada com um COMMIT,
seja automaticamente cancelada (ROLLBACK). Isso assegura que os processos
dependentes de várias instruções SQL sejam integralmente feitos ou integralmente
desfeitos.
Um exemplo clássico de transação é o processo de débito entre contas correntes
(exemplo: DOC), deve existir o débito e crédito nas respectivas contas, caso contrário
a operação deve ser desfeita.
Autocommit, commit e rollback
O método setAutoCommit da classe Connection permite mudar esta propriedade:
[Link](true);
faz com que a mensagem de commit seja enviada após cada commando SQL, e
[Link](false);
desabilita o commit automático. Neste caaso devewm ser usados métodos commit e
rollback, da classe Conection, para controlar as transações. (Ver a classe Connection –
Javadoc)
void commit()
Efetiva todos as instruções enviadas ao banco de dados desde a última mensagem
semelhante. Termina a transação e começa uma nova.
void rollback()
Desfaz todos as instruções SQL foram envidas ao banco de dados desde o último
commit(). Recomeça a última transação. Por exemplo:
[Link](false);
try {
[Link](valor);
[Link](valor);
// instruções SQL;
[Link](); //envia commit para o banco
} catch(Error e) {
[Link](); //Desfaz a transação
}
}
Exercício 01
import [Link].*;
import [Link].*;
Exercício 02
import [Link].*;
import [Link].*;
import [Link].*;
{
setLayout(new FlowLayout());
b1 = new TextField(10);
b2 = new TextField(10);
[Link](this);
[Link](this);
add(b1);
add(b2);
k = new Thread(this);
[Link]();
}
{
int cont = 0;
while(true)
{ cont = cont + 1;
[Link](""+cont);}
}
{
[Link]();
}
{
[Link]();
}
{
x = [Link]();
repaint();
}
}
Exercício 03
import [Link].*;
public class Prog1101 extends Vector
{
public Prog1101()
{
super(1,1);
}
public void addInt(int i)
{
addElement(new Integer(i));
}
public void addFloat(float f)
{
[Link](real);
[Link](s);
[Link](letters);
[Link]();
}
}
Exercício 01
import [Link].*;
import [Link].*;
class Prog0701 extends Frame implements ActionListener{
String x;
public void paint(Graphics g)
{if (x != null)
[Link](x,100,100);
}
Exercício 02
import [Link].*;
import [Link].*;
public Prog0702()
{ setLayout(new FlowLayout());
b = new Button();
c = new Button();
add(b);
add(c);
[Link](this);
[Link](this);
setSize(300,300);
show();
}
Exercício 03
import [Link].*;
import [Link].*;
public Prog0703()
{ setLayout(new FlowLayout());
b = new Checkbox("one",null,true);
c = new Checkbox("two");
add(b);
add(c);
[Link](this);
[Link](this);
setSize(300,300);
show();
}
O que é um evento?
Quando o usuário executa uma ação à interface de usuário, isto causa um evento a
ser emitido. Eventos são objetos que descrevem o que aconteceu. Vários tipos
diferentes de classes de evento existem para descrever categorias gerais diferentes de
ação de usuário.
Fontes de evento
Uma fonte de evento (ao nível de interface de usuário) é o resultado de alguma ação
de usuário em um componente de AWT. Por exemplo, um trinco de rato em um
componente de botão gerará (fonte) um ActionEvent.
Manipuladores de evento
Quando um evento acontece, o evento é recebido pelo componente com o que o
usuário interagiu; por exemplo, o botão, slider, campo de texto, e assim por diante.
Um manipulador de evento é um método que recebe o objeto de Evento de forma que
o programa pode processar a interação do usuário.
Como são processados Eventos
Entre JDK 1.0 e JDK 1.1, houve mudanças significantes do modo que são recebidos
eventos e são processados.
JDK 1.0 x JDK 1.1 Modelo de Evento
JDK 1.0 usa um modelo de evento de hierarquia, e partir da versão JDK 1.1 usa um
modelo de evento de delegação. Abaixo faremos uma comparação sobre os dois tipos
de eventos .
Modelo de hierarquia (JDK 1.0)
O modelo de evento de hierarquia é baseado em hierarquia de retenção. Eventos que
não são dirigidos ao componente continuarão propagando ao recipiente do
componente automaticamente.
Modelo de delegação (a partir da versão JDK 1.1)
O JDK 1.1 introduziu um modelo de evento novo, chamou-o de evento de delegação.
No modelo de evento de delegação, são enviados eventos a componente, onde cada
componente registrar uma rotina de manipulação de eventos (chamado de ouvinte)
para receber o evento. Deste modo o manipulador de eventos pode estar em uma
classe separada do componente. A manipulação do evento é delegada então à classe
separada.
Vantagens do Modelo de delegação
* Não são dirigidos eventos acidentalmente; no modelo de hierarquia é possível para
um evento propagar a um recipiente e é dirigido a um nível que não é esperado.
* É possível criar filtro (adaptador) de classes para classificar ações de evento.
* O modelo de delegação é muito melhor para a distribuição de trabalho entre
classes.
* O modelo de evento novo provê apoio por feijões de Java.
Desvantagens do Modelo de delegação
* É mais complexo, pelo menos inicialmente, entender.
* A migração do JDK 1.0 para o JDK 1.1 não é fácil.
● Embora o JDK atual apóia o JDK 1.0, os modelos podem ser misturados.
Instalações do AWT
O AWT provê uma variedade larga de instalações standards.
Buttons
É uma das interfaces básicas, que é ativa após ser precionada.
Checkboxes
Checkboxe fornece uma interface simples, aonde as opções possíveis são
"on/off".
CheckboxGroups
CheckboxGroups é um tipo de Checkboxe especial, diferenciando do anterior
pelo sinal de seleção, no caso uma bolinha, e aonde apenas uma opção poderá
ser marcada.
Choice
O Choice fornece uma seleção simples dentro de uma lista de opções.
Canvas
Canvas é uma tela de fundo (papel de parede) aonde irão ser adicionados
componentes.
Label
Label é um objeto simples que mostra uma linha simples de texto.
TextField
TextField é um objeto simples que permite a digitação dentro dele.
TextArea
TextArea é um objeto mais completo que permite a digitação de várias linhas
dentro dele.
List
O List é um tipo de Choice, mas que permite a seleção múltipla dentro da lista
de opções.
Exercício 01
import [Link].*;
import [Link].*;
public Prog0801()
{ setLayout(new FlowLayout());
add(one);
add(two);
add(three);
[Link](this);
[Link](this);
[Link](this);
setSize(300,300);
show();
}
Exercício 02
import [Link].*;
import [Link].*;
public Prog0802()
{ setLayout(new FlowLayout());
[Link]("one");
[Link]("two");
[Link](this);
add(cgb);
setSize(300,300);
show();
}
import [Link].*;
import [Link].*;
public Prog0803()
{ setLayout(new FlowLayout());
b = new TextField(20);
add(b);
[Link](this);
setSize(300,300);
show();
}
Exercício 04
import [Link].*;
import [Link].*;
public Prog0804()
Frame
Frame é uma armação aonde serão inseridos objetos.
Panel
Panel é um tipo de container aonde serão inseridos objetos.
Dialog
Um Dialog é semelhante ao Frame, nisso é uma janela parada grátis com algumas
decorações.
Não são feitos Dialog normalmente visível para o usuário quando eles são criados
primeiro.
FileDialog
FileDialog é um tipo de implementação que permite ao usuário selecionar pastas dentro
de uma lista de opções.
ScrollPane
ScrollPane são as barras de rolagens de um panel.
Menus
Menu é uma série de opções disponível.
Um fator importante da criação de menus no Java é a respeito do Help. O help pode ser
deslocado para ficar o mais a direita possível dos demais itens.
O MenuBar é um tipo de menu horizontal.
O MenuItem são os itens do menu.
CheckboxMenuItem
É uma variação dos tipos de menu, aonde o usuário seleciona uma das opções e esta
opção selecionada fica marcada com "quique".
PopupMenu
É um tipo de menu acionado a partir de qualquer posição na tela.
Controlando Aspectos Visuais
Colors
Existem dois métodos para controlar as cores:
● SetForeground()
● SetBackground()
Fonts
É utilizado para controlar os tipos de fontes.
Printing
Frame f = new Frame("Print test")
...
Exercício 01
import [Link].*;
import [Link].*;
public Prog0901()
{ setLayout(new FlowLayout());
[Link]("a");
[Link]("b");
[Link]("c");
[Link]("d");
[Link]("e");
[Link]("f");
[Link](this);
add(lst);
setSize(300,300);
show();
}
Exercício 02
import [Link].*;
public Prog0902()
{ setLayout(new FlowLayout());
[Link]("a");
[Link]("b");
[Link]("c");
[Link]("d");
[Link]("e");
[Link]("f");
[Link](this);
add(lst);
add(a);
setSize(300,300);
show();
}
Exercício 03
import [Link].*;
import [Link].*;
Exercício 05
import [Link].*;
import [Link].*;
public Prog0905()
{ setLayout(new FlowLayout());
[Link](mi11);
[Link](mi12);
[Link]();
[Link](m1);
[Link](m2);
[Link](m3);
[Link](this);
[Link](this);
[Link](this);
setMenuBar(mb);
setSize(300,300);
show();
}
class Prog0601
{
public static void main (String args[ ])
{
int i = 0;
int scap = 0;
String greetings [ ] = { "Hello word" , "No, I mean it!", "HELLO WORLD!"};
While (i < 4)
{
try
{
[Link](greetings[i]);
}
catch(ArrayIndexOutOfBoundsException e)
{
scap++;
[Link]("Valor do Índice foi refixado " + scap);
if (scap < 5)
{
i = -1;
}
}
catch(Exception e)
{
[Link]([Link]());
}
finally
{
[Link]("Esta mensagem será sempre impressa.");
}
i++;
Definição de Métodos
Em Java, métodos são definidoss usando uma aproximação que é muito similar à usada em
outras linguagens, como por exemplo C e C++. A declaração é feita da seguinte forma:
< modifiers > < tipo de retorno > < nome > ( < lista de argumentos > ) < bloco >
< modifiers > -> segmento que possue os diferentes tipos de modificações incluíndo public,
protected e private.
< tipo de retorno > -> indica o tipo de retorno do método.
< nome > -> nome que identifica o método.
< lista de argumentos > -> todos os valores que serão passados como argumentos.
public void addDays (int days)
Passagem de Valores
Encapsulamento
É uma proteção adicional dos dados do objeto de possíveis modificações impróprias,
forçando o acesso a um nível mais baixo para tratamento do dados.
Sobrescrevendo Métodos
O Java permite que você tenha métodos com o mesmo nome, mas com assinaturas
diferentes. Isto permite a reusabilidade dos nomes dos métodos.
public void print( int i )
public void print( float f )
public void print( String s)
Quando você escreve um código para chamar um desses método, o método a ser
chamado será o que coincidir com tipos de dados da lista de parâmetros.
Subclasses (Relacionadas)
Na classe Pai você deve declarar os objetos comun a todos, e nos sub-níveis (Subclasses),
você declara as particulariedades:
public class Employee {
private String name;
private Date hireDate;
private Date dateOfBirth;
private String jobTitle;
private int grade;
.......
}
Subclasses (Extensões)
Em linguagens de orientação a objetos, um mecanismo especial é fornecido para que
permita ao programa defina classes e termos previstas na definição de outras classes. Esta
arquitetura em Java usa a palavra extends.
public class Employee {
private String name;
private Date hireDate;
private Date dateOfBirth;
private String jobTitle;
private int grade;
}
O Operador instanceof
Fornece o dado que você adquiriu através da passagem de parâmetros.
Caso você receba um object por referência do tipo Employee, esta referência poderia
não ser mostrado para Manager. Se você quiser testar isso use instanceof.
public void method(Employee e) {
if (e instanceof Manager) {
}
else if ( e instanceof Contractor) {
}
else {
}
}
Objetos Lançados
Em circunstâncias onde você recebeu uma referência para uma classe pai, e você
determinou que o objeto é de fato uma subdivisão de classe particular usando o
operador de instanceof, você pode restabelecer a funcionalidade completa do objeto
lançado.
Sobre-escrevendo Métodos
O Java permite que você declare métodos na classe pai e não desenvolva nenhuma
lógica dentro desses métodos, permitindo com isso que o desenvolvimento desses
métodos venha a ser trabalhados dentro das sub-classes posteriores.
Class Funcionario( )
ler( )
Class Motorista( )
ler ( )
[Link]( ) -> Referencia o método da classe pai
Comparando Java com outras Linguagens
Em C++ você pode adquirir este comportamento, desde que você marque o método
como virtual na fonte.
Classes se agrupando - Pacotes
Java provê o mecanismo de pacotes como um modo de se agrupar classes
relacionadas. Tão longe, todos nossos exemplos pertencem à falta ou pacotes não
mencionados.
A declaração import
Em Java, quando você quer usar instalações de pacotes, você usa a declaração de
importação para contar para o compilador onde achar as classe que você vai usar.
A declaração de importação (import) deve preceder a declaração de todas as classes.
class Prog0501
{
public static void main(String arg[ ])
{
int a, b=10, c=3;
a = func(b,b+c); //chamada de funcao. O retorno é passado para a
variável a
[Link]("valor de a = " + a);
}
// A definicao da funcao esta logo abaixo
public static int func(int x, int y)
{
int ret;
ret = x+y;
return ret;
}
}
Todo o acesso aos dados do objeto é feito através da chamada a uma operação
(método) da sua interface Mudanças na implementação de um objeto, que
preservem a sua interface externa, não afetam o resto do sistema.
Benefícios
Segurança
protege os atributos dos objetos de terem seus valores corrompidos por outros
objetos.
Independência
"escondendo" seus atributos, um objeto protege outros objetos de complicações de
dependência de sua estrutura interna.
Mensagens
Objetos interagem e comunicam-se através de mensagens...
Métodos
...as mensagens identificam os métodos a serem executados no objeto receptor.
Mensagens e Métodos
Para invocar um método de um objeto, deve-se enviar uma mensagem para este
objeto.
Para enviar uma mensagem deve-se:
● identificar o objeto que receberá a mensagem;
Métodos
O que um determinado método pode fazer com os valores dos atributos do objeto?
Um objeto possui:
● um estado (definido pelo conjunto de valores dos seus atributos em determinado
instante)
● um comportamento (definido pelo conjunto de métodos definido na sua interface)
Abstração
Focalizar o essencial, ignorar propriedades acidentais.
A abstração deve ser sempre feita com algum objetivo, porque este determina o que é
e o que não é importante.
Classes
Uma classe descreve um conjunto de objetos com:
● propriedades semelhantes;
● comportamentos semelhantes;
Uma operação que pode assumir múltiplas formas, de acordo com a implementação:
Operadores
No Java os operadores são muito similares ao estilo e funcionalidade de
outras linguagens como por exemplo o C e o C++.
Pré-incremento:
x = 10;
x = x + 1;
O valor da variável x é 11
ou
x = 10;
++x
O valor da variável x é 11.
Pós-Incremto:
x = 10;
x = x + 1;
O valor da variável x é 11
ou
x = 10;
x++
O valor da variável x é 11.
Diferença entre o Pré-Incremento e o Pós-Incremento:
x = 10
++x => neste exato momento a variável a vale 11
x =10
x++ => neste exato momento a variável x vale 10
Separadores:
.[]();,
Operadores:
Operadores Descrição
== Igualdade
!= Negação
+-*/ Aritméticos
&& e
|| ou
O operador + é utilizado para concatenar objetos do tipo String, produzindo uma nova
String:
String PrimeiroNome = "Antonio";
String SegundoNome = "Carlos";
String Nome = PrimeiroNome + SegundoNome;
Casting ( Conversão de tipos )
A linguagem Java não suporta conversões arbitrárias de tipos de variáveis. Você deve
explicitar a conversão entre tipos de variáveis.
Exemplo:
long bigval = 6; // Operação válida
int smallval = 99L; // Operação inválida porque são de tipos diferentes
float z = 12.414F; // Operação válida
float zp = 12.414; // Operação inválida porque esta tentando atribuir um valor double.
Convertendo
Long bigValue = 99L;
Int squashed = (int)(bigValue);
Declarações de Fluxos
If, else
if (expressão) // expressão cujo retorno é um valor do tipo boolean
{ Declarações ou blocos }
else // caso a condição anterior não seja satisfeita
{ Declarações ou blocos }
switch
switch (expressão) // Esta expressão deve ser do tipo int ou char
{
case cond01:
declarações;
break; // usado para sair do case.
case cond02:
declarações;
break;
case cond03:
declarações;
break;
}
for Loops
for (expr_inicial; condição_boolean; incremento)
{
Declarações ou blocos;
}
while Loops
while(condição_boolean)
{
Declarações ou blocos;
}
do Loops
do
{
Declarações ou blocos;
[Link] (1 of 2) [01/09/2000 19:19:28]
Fluxos de Controle
}
while(condição_boolean);
Exercício 01
public class Prog0301
{
public static void main(String arg[ ])
{
int x = (int)([Link]()*100);
int z ;
int y ;
if (x > 50)
{
y = 9;
}
z = y + x;
}
}
Exercício 02
public class Prog0302
{
public static void main(String arg[ ])
{
int x = (int)([Link]()*100);
int z = 0;
int y = 0;
if (x > 50)
{
y = 9;
}
else
{
[Link]("O valor de x é menor que 50");
y = (int)([Link]() * (3.14));
}
z = y + x;
[Link]("O valor da variável x = " + x);
Declaração de Arrays
char s [ ];
Point p [ ];
Em Java um Array é uma classe.
Criando um Array
Você pode criar arrays, ligando-o a todos os objetos, usando a palavra new, da
seguinte forma:
s = new char[20];
p = new Point[100];
String names[ ];
names = new String[4];
names[0]= "Georgina";
names[1]="Jen";
names[2]="Simon";
names[3]= "Tom";
ou
String names[ ];
names = new String[4];
String names [ ] = { "Georgina", "Jean", "Simon", "Tom"};
Arrays Multi-dimencionais
Java não possui arrays multi-dimencionais, mas ele permite declarar um array que
é baseado em um outro array.
int twoDim [ ] [ ] = new int [4] [ ] ;
twoDim[0] = new int [5] ;
twoDim[1] = new int [5] ;
classe Prog0401
{
thisArray int;
thatArray int;
public static void main (String args [ ])
{
int[ ] thisArray = {1,2,3,4,5,6,7,8,9,10}
for (int i =0; i < [Link]; i++)
{
[Link]( " Conteúdo do Array " + thisArray[i]);
}
}
}
class Prog0402 {
public static void main(String arg[ ])
{
int A[] = new int[3];
A[0] = 50;
A[1] = 100;
A[2] = 150;
[Link]("Tamanho do vetor = " + [Link]);
int conta;
for(conta = 0; conta< [Link] ; conta++)
{[Link]("indice = " + conta + " valor= " + A[conta] );}
}
}
class Prog0101
{
public static void main (String arg [])
{ int a = 6, b = 10;
a = a + 1;
[Link](" O valor da variavel a = " + a);
}
}
❍ forma Hexadecimal.
❍ '\t' – tabulação
❍ '\\' - \
Tipo Textual
String (String é uma classe)
O tipo String, como não é primitivo, é usado para representar uma
seqüência de caracteres.
Palavras Reservadas
abstract do implements private throw
boolean double import protected throws
breaak else instanceof public transient
byte extends int return true
case false interface short try
catch final long static void
char finally native super volatile
class float new switch while
continue for null synchronized
default if package this
Exercício 01
class Prog0201
{
public static void main (String arg [])
{ int a = 5, b = 10;
a = a + 5;
// b = b*2;
[Link]("Valor da variavel a: " + a);
[Link](" Valor da variavel b: " + b);
}
}
Exercício 02
class Prog0202
{
public static void main (String arg [])
{ int a = 5, b = 10;
a = a + 5;
b = b*2;
[Link]("Valor da variavel a: " + a);
[Link](" Valor da variavel b: " + b);
}
}