Programando em Java, Notas de estudo de Ciências Biologicas

Baixe Programando em Java e outras Notas de estudo em PDF para Ciências Biologicas, somente na Docsity!

Programação

em JAVA

Daniela Barreiro Claro

João Bosco Mangueira Sobral

Prefácio

Este livro foi originado a partir de nossas experiências com o ensino da linguagem Java em laboratório nos Cursos de Extensão no Departamento de Informática e Estatística, Centro Tecnológico, Universidade Federal de Santa Catarina.

Desde sua primeira versão no primeiro semestre de 2000, algumas revisões foram realizadas e aplicadas nos cursos dos anos subseqüentes.

A partir de 1996, o intercâmbio de conhecimento utilizando a linguagem Java veio se consolidando no meio acadêmico e empresarial. A introdução da linguagem Java no Departamento de Informática e Estatística, mais especificamente no Curso de Pós- Graduação em Ciência da Computação, ocorreu no ano de 1999. A partir desta época, a linguagem Java foi sendo consolidada nos cursos de computação da UFSC, tanto graduação quanto pós-graduação, sendo utilizada em conjunto com outros paradigmas do meio computacional. Atualmente, a linguagem vem sendo bastante utilizada em implementações nos trabalhos de conclusão de curso de graduação, nas dissertações de mestrado e teses de doutorado deste Departamento.

No meio empresarial e corporativo, a cultura do Java vem se expandindo de uma forma gradual e constante, permitindo que diversas empresas desenvolvam aplicações utilizando esta linguagem.

Na literatura, já existem muitos livros explicando e utilizando a programação em Java, nos aspectos gerais, tanto em livros específicos, abordando APIs mais avançadas. Atualmente, em âmbito nacional, existem publicações periódicas referenciando detalhes da programação em Java.

Este livro aborda a linguagem Java de uma forma mais objetiva, considerando o histórico da linguagem, as características principais, os seus fundamentos, a orientação a objetos em Java, programação de interfaces gráficas, manipulação de programas para Web(Applets), simulação de processamento concorrente(Threads), programação em redes com Sockets e acesso a banco de dados utilizando o JDBC.

João Bosco M. Sobral Daniela Barreiro Claro

© 2008, Daniela Barreiro Claro e João Bosco Mangueira Sobral.

Este livro, eventualmente utilizado por terceiros, participantes ou não da comunidade Copyleft Pearson Education, não pode ser alterado ou adaptado sem a devida autorização dos respectivos autores, respeitando-se, sempre, o que prescreve a legislação autoral vigente, sendo intangíveis os direitos morais dos autores, nos termos do que prescrevem os artigos 24 e seguintes da lei 9 610/98.

Fica autorizada a utilização deste material para qualquer fim que não o comercial desde que os seus autores sejam devidamente citados.

Claro D. B. e Sobral J. B. M. PROGRAMAÇÃO EM JAVA. Copyleft Pearson Education. Florianópolis, SC.

Índice

• PREFÁCIO
• AGRADECIMENTOS
• ÍNDICE..................................................................................................................................
• 1. ORIENTAÇÃO A OBJETOS
• 2. INTRODUÇÃO AO JAVA............................................................................................
  • 2.1 HISTÓRICO
  • 2.2 WEB X APLICATIVOS
  • 2.3 JAVA DEVELOPEMENT KIT - JDK
  • 2.4 MANIPULAÇÃO DO JDK(JAVA DEVELOPEMENT KIT)
  • 2.5 CARACTERÍSTICAS DA LINGUAGEM
  • 2.6 COMPILAÇÃO DOS PROGRAMAS
  • 2.6.1 COMPILAÇÃO JAVA
  • 2.6.2 COMPILAÇÃO DE OUTRAS LINGUAGENS
  • 2.7 AMBIENTES INTEGRADOS DE DESENVOLVIMENTO
  • 2.7 AMBIENTES INTEGRADOS DE DESENVOLVIMENTO
  • 2.8 INSTALAÇÃO DO COMPILADOR/INTERPRETADOR ( JDK )
  • 2.9 ESTRUTURA DAS APLICAÇÕES JAVA
    • 2.9.1 Elementos da Aplicação
    • Passagem de Parâmetros da Linha de Comando.........................................................
• 3. FUNDAMENTOS DA LINGUAGEM
  • 3.1 COMENTÁRIOS
  • 3.2 PALAVRAS CHAVES
  • 3.3 TIPOS DE DADOS..........................................................................................................
  • 3.4 VARIAVEIS OU ATRIBUTOS...........................................................................................
  • 3.5 CONSTANTES
  • 3.6 OPERADORES
    • 3.6.1 Operadores Aritméticos.......................................................................................
    • 3.6.2 Operadores Relacionais
    • 3.6.3 Operadores Lógicos
    • 3.6.4 Atribuição Composta...........................................................................................
    • 3.6.5 Operadores Incremental e Decremental
    • 3.6.6 Operador Ternário
  • O VALOR DE A SERA “MENOR ”, VISTO QUE 1 E MENOR QUE 2.
  • 3.7 CONVERSÕES COM TIPOS PRIMITIVOS..........................................................................
  • 3.8 CONTROLE DE FLUXO
    • 3.8.1 Sentenças Condicionais.......................................................................................
    • 3.8.2 Loops Indeterminados
    • 3.8.3 Loops Determinados............................................................................................
    • 3.8.4 Múltiplas Seleções
    • 3.8.5 Manipulações diversas
  • 3.9 ARRAYS
  • 3.10 STRINGS.....................................................................................................................
• 4. ORIENTAÇÃO A OBJETOS EM JAVA
  • 4.1 VANTAGENS DA OO EM JAVA......................................................................................
  • 4.2 COMPONENTES DA ORIENTAÇÃO A OBJETOS
    • 4.2.1 Atributos (Variáveis)
    • 4.2.2. Escopo de variáveis
    • 4.2.3 Métodos
    • #Modificadores de Acesso
    • 4.2.4 Classes.................................................................................................................
    • 4.2.5 Pacote
    • 4.2.6 Objetos.................................................................................................................
  • 4.3 ATRIBUTOS DE INSTANCIA
  • 4.4 METODOS DE INSTANCIA
  • 4.5 ATRIBUTOS E MÉTODOS ESTÁTICOS (STATIC FIELDS / STATIC METHODS)
    • 4.5.1 Atributos Estáticos...............................................................................................
    • 4.5.2 Métodos Estáticos ou Métodos de Classe
  • 4.6 PASSAGEM DE PARAMETROS: POR VALOR E POR REFERENCIA......................................
  • 4.7 HERANÇA
  • 4.8 CLASSES E MÉTODOS FINAL
  • 4.9 CLASSES E MÉTODOS ABSTRATOS
  • 4.10 CONVERSÕES EXPLICITAS E IMPLICITAS
  • 4.11 INTERFACES
• 5. TRATAMENTO DE EXCEÇÕES
  • 5.1 CRIANDO UMA EXCEÇÃO
  • 5.2 CLAUSULA THROWS
• 6. ABSTRACT WINDOW TOOLKIT - AWT
  • 6.1 ELEMENTOS DA INTERFACE AWT
  • 6.2 TRATAMENTO DE EVENTOS
    • 6.2.1 Classes de Eventos
    • 6.2.2 Tratadores de Eventos ou Listeners
    • 6.2.3 Classe Adapter.....................................................................................................
  • 6.3 COMPONENTES E EVENTOS SUPORTADOS
• 7. INTERFACE GRÁFICA - SWING..............................................................................
  • 7.1 FRAMES
• 8. APPLETS
  • 8.1 HIERARQUIA
  • 8.2 ESTRUTURA
  • 8.3 ARQUIVOS HTML
  • 8.4 EXECUTANDO UM APPLET
    • 8.4.1 Passagem de Parâmetros
  • 8.6 RESTRIÇÕES DE SEGURANÇA
  • 8.7 PRINCIPAIS MÉTODOS..................................................................................................
  • 8.8 OBJETO GRÁFICO – CLASSE JAVA.AWT.GRAPHICS........................................................
  • 8.9 FONTES
  • 8.10 CORES........................................................................................................................
• 9. PROCESSAMENTO CONCORRENTE - THREADS
  • 9.1 SINCRONIZAÇÃO
• 10. SOCKETS
  • 10.1 CLASSE SERVERSOCKET
  • 10.2 CLASSE SOCKET
• 11. ACESSO A BANCO DE DADOS - JDBC
  • 11.1 VERSÕES DO JDBC....................................................................................................
    • 11.1.1 JDBC 1.0
    • 11.1.2 JDBC 2.0
    • 11.1.3 JDBC 3.0
  • 11.2 TIPOS DE DRIVERS
    • 11.2.1 Driver JDBC Tipo
    • 11.2.2 Driver JDBC Tipo
    • 11.2.3 Driver JDBC Tipo
    • 11.2.4 Driver JDBC Tipo
  • 11.3 CLASSES DO JDBC – CONEXÃO COM O BD
    • 11.3.1 Driver
    • 11.3.2 DriverManager..................................................................................................
    • 11.3.3 java.sql.Connection
  • 11.4 CLASSES JDBC – ACESSO AO BD..............................................................................
    • 11.4.1 java.sql.Statement..............................................................................................
    • 11.4.2 java.sql.ResultSet...............................................................................................
    • 11.4.3 java.sql.PreparedStatement...............................................................................
  • 11.5 JDBC 2.0...................................................................................................................
    • 11.5.1 Scrollable ResultSet...........................................................................................
    • 11.5.2 Atualizações de Dados via Programação
    • 11.5.3 Consultas com o SQL
• 12. REFERÊNCIAS BIBLIOGRÁFICAS
  • LINKS
  • LIVROS
• 13. BIBLIOGRAFIA DOS AUTORES.............................................................................

Orientação a Objetos

1. Orientação a Objetos

Inovações tecnológicas surgidas na área de Informática têm criado uma necessidade de utilização e manipulação de informações que antigamente não eram utilizadas. Os tipos de dados complexos, como os objetos, passaram a ser manipulados através das linguagens de programação, que passaram a receber a conotação de Linguagem de Programação Orientada a Objetos.

A programação estruturada, em se tratando, principalmente, de manutenção de sistemas, possui taxas de reutilização muito baixas, dificultando a manutenção dos programas anteriormente desenvolvidos.

A orientação a objetos tem como objetivo principal modelar o mundo real, e garantir que as taxas de manutenibilidade (manutenção) serão maiores diante deste contexto. Isso é possível, pois utilizando uma linguagem de programação orientada a objetos consegue-se obter um desenvolvimento mais rápido, visto que este desenvolvimento ocorre em módulos, em blocos de códigos correspondentes aos objetos e seus acoplamentos. Através da orientação a objetos pode-se obter uma maior qualidade e agilidade no desenvolvimento, pois o fator reusabilidade (reutilização) permite que se re-utilize outros objetos que foram anteriormente desenvolvidos e podem ser facilmente incorporados na aplicação. A reusabilidade também garante uma manuseabilidade melhor do programa, pois os testes referentes aos componentes, já foram previamente executados, garantindo assim a utilização coesa dos objetos.

A orientação a objetos surgiu na década de 60, baseada na Teoria dos Tipos da Álgebra, mas somente na década de 90 começou a ser amplamente utilizada computacionalmente. Ela tem como principio fundamental representar o mundo real e a forma de se interagir com os objetos. Mas, o que é um objeto?

Atualmente, há milhares de milhares de objetos que se pode tocar e perceber. Agora mesmo, você está tocando em um objeto denominado livro e posso garantir que deste livro que você está nas mãos, somente há um exemplar. Há um modelo deste livro, que é responsável pela criação do mesmo em série, mas este livro, que está nas suas mãos, idêntico, que possui um grifo de lápis (caso você já tenha dado um) somente há um, este nas suas mãos. É esta a característica principal dos objetos, eles são únicos e somente há um único objeto no mundo.

Vamos pensar no mundo dos automóveis. Pensemos em uma montadora de veículo, onde há uma fábrica de automóveis. Cada automóvel que sai desta fábrica é único, é identificado por um número de chassi. O meu carro é único, é o único que possui um arranhão na parte traseira esquerda ... Por mais que tenha diversos carros iguais ao meu, com a mesma cor, da mesma marca, mesma categoria, o meu carro é único, por ter características que somente pertencem a ele. E assim são os objetos.

E as classes? As classes são como se fossem as montadoras, é quem detém a “receita” de como montar, quem contém o molde dos carros, é uma abstração do carro. Na verdade a classe contém os moldes do carro, e não o carro propriamente dito. No caso de oreintação a objetos, as classes são as monytadoras dos objetos. As classes são vistas como agrupamento de objetos que contém as mesmas características e os mesmos comportamentos.

Orientação a Objetos

elas podem adicionar variáveis e métodos ao seu escopo. Entre estas características da herança, a manipulação das classes que herdam métodos e atributos permite que se modularize o código de tal forma que cada objeto tem uma funcionalidade própria e garante assim uma coesão das informações.

Outro conceito adicional da orientação a objetos utilizado em Java é o polimorfismo, onde pode-se definir duas abordagens como: sobreposição(override) e sobrecarga(overload). A sobreposição ocorre quando duas ou mais classes derivadas de uma mesma superclasse podem invocar métodos que possuem a mesma identificação(assinatura), mas comportamentos distintos. Enquanto que a sobrecarga dos métodos ocorre quando em uma mesma classe, métodos possuem os mesmos nomes, mas assinaturas diferentes, um exemplo disso são os métodos construtores do Java, que serão abordados mais adiante neste livro.

As interfaces, outro conceito importante e bastante utilizado nas implementações das Interfaces Gráficas no Java, “são invólucros que promovem a interação de contatos externos, com ou sem passagem de dados, com um processamento interno.” (CAMARA,

Um usuário somente precisa saber o que o objeto é capaz de fazer, mas não interessa como ele deverá ser feito. Assim, a interface permite que se utilize o conceito do encapsulamento, onde somente as assinaturas dos métodos estão disponíveis para exibição aos usuários.

Podemos criar uma estrutura mais próxima da manipulação de classes e objetos dentro da linguagem Java, como podemos ter uma classe PESSOA que possui atributos (características) tais como: cor_de_olho, cor_de_cabelo, idade. Esta classe PESSOA também possui métodos (ações, comportamentos) tais como: faz_aniversario, pinta_cor_de_cabelo.

Instanciando esta classe PESSOA, obtemos o que chamamos de objeto, ou seja: daniela = new PESSOA ( ); bosco = new PESSOA ( );

Cada objeto tem suas características (atributos) particulares, por exemplo: daniela.cor_de_olho = ‘verde’; daniela.cor_de_cabelo= ‘castanho escuro’; daniela.idade = 27;

Enquanto que o objeto antonio possui outros valores para seus atributos.

bosco.cor_de_olho = ‘castanho’;

PESSOA

cor_de_olho

cor_de_cabelo

idade

pinta_cor_cabelo()

faz_aniversario()

Orientação a Objetos

bosco.cor_de_cabelo = ‘preto; bosco.idade = 55;

Em relação aos métodos, estes são utilizados para modificar/manipular os valores dos atributos, segue um exemplo:

daniela.faz_aniversario ( );

O método faz_aniversario implementa um procedimento onde irá somar mais um no atributo idade de daniela. Exemplo:

faz_aniversario( ) { daniela.idade = daniela.idade+1; }

daniela.pinta_cor_cabelo(‘preto’);

Este segundo método age sobre o objeto daniela e realiza a ação de pintar a cor do cabelo passando como parâmetro a cor desejada.

Assim, através de classes, objetos, atributos, métodos, dentre outras características da orientação a objetos, consegue-se modelar o mundo real e abstrair informações incorporando-as à linguagem Java.

Introdução ao Java

2.2 Web x Aplicativos

Programas escritos em Java, podem ser Applets, Aplicativos ou ainda Servlets. Os aplicativos são programas que necessitam de um interpretador instalado na máquina. Enquanto que Applets são programas carregados juntamente com páginas HTML. O interpretador, no caso das Applets, é o próprio browser. Não necessita instalação, basta que o browser usado ofereça suporte a Java. Já no caso dos Servlets, são programas desenvolvidos em Java que são interpretados pelo Servidor Web. Os servlets são utilizados na geração dinâmica de páginas HTML. Atualmente, são muito utilizados na combinação com JSP (Java Server Pages) para a utilização do MVC (Model View Controller).

2.3 Java Developement Kit - JDK

O JDK é um kit de desenvolvimento Java fornecido livremente pela Sun. Constitui de um conjunto de programas que engloba compilador, interpretador e utilitários. A primeira versão deste Kit foi a 1.0. Atualmente, o JDK está na versão 1.4.x, tendo sido lançado recentemente a versão beta 1.5.x, também denominada Tiger. O JDK é separado em 3 edições: o Java 2 Standard Edition (J2SDK), o Java 2 Enterpise Edition (J2EE) e o Java 2 Micro Edition (J2ME). Cada uma engloba um conjunto de pacotes diferentes fornecendo aos usuarios uma forma organizada e diferenciada para desenvolver aplicações. Ou seja, os usuários que desejem desenvolver aplicações para Palm Tops, celulares, dispositivos pequenos, deve utilizar o J2ME para desenvolver as suas aplicações.

Os principais componentes do kit de desenvolvimento são:

javac ( compilador )

java ( interpretador )

appletviewer ( visualizador de applets )

javadoc ( gerador de documentação )

jar ( programa de compactação )

A utilização do JDK é feita da seguinte forma: primeiro escreve-se o programa fonte em Java, utilizando qualquer editor de texto ou IDE para Java como Eclipse, JCreator, JBuilder, JDeveloper, Bloco de Notas, TextPad(com pluggins), dentre outros. A seguir, o programa deve ser compilado utilizando o compilador javac:

javac <nomedoarquivo.java>

Exemplo: javac Teste.java

A compilação gera o arquivo em código binário (bytecode ), com extensão .class.

Uma vez compilado, basta executar o programa. Se for uma aplicação, utilizar o interpretador java:

java

Exemplo: java Teste

Introdução ao Java

As IDEs para Java já tem o compilador (javac) e o interpretador (java) embutido no aplicativo, o que basta clicar em botões ou usar teclas de atalho para compilar e interpretar os programas desenvolvidos.

2.4 Manipulação do JDK(Java Developement Kit)

Sendo um Applet, deve-se construir uma página HTML para abrigar o applet e carregá-la através de um browser ou do appletviewer (visualidador de applets Java):

appletviewer <nomedoarquivo.html>

Exemplo: appletviewer Teste.html

Código fonte Java Teste.java

Compilador javac Teste.java

Código binário Teste.class

Interpretador java Teste

Figura 2 – Compilação e Interpretação no Java

Código fonte Java AppletTeste.java

Criação da página HTML para o Applet AppletTeste.html

Browser com Interpretador embutido AppletTeste.html

Compilador javac Teste.java

Bytecode AppletTeste.class

Visualizador de Applets (Interpretador) appletviewer AppletTeste.html

Figura 3 – Compilação e Interpretação da Applet

Introdução ao Java

Coletor de Lixo – Garbage Colector

Se não houver nenhuma referência a um objeto que tenha sido criado na memória, o coletor de lixo destrói o objeto e libera a memória ocupada por ele.

O coletor de lixo é executado de tempos em tempos. Quando a JVM percebe que o sistema diminuiu a utilização do processador, ela-JVM- faz com que o coletor de lixo execute e este vasculha a memória em busca de algum objeto criado e não referenciado. Em Java nunca se pode explicitamente liberar a memória de objetos que se tenha alocado anteriormente. O método abaixo PROPOE/SUGERE que a JVM vai utilizar recursos para reciclar objetos que não são mais utilizados. Mas não garante que daqui a 1 milisegundo ou 100 milisegundos o Garbage Collection vai coletar todos os objetos em desuso.

Runtime.gc();

System.gc();

O Garbage Collector é uma grande vantagem para desalocação de memória, que é um grande inconveniente para programadores que trabalham com ponteiros e necessitam liberar o espaço alocado, visto que é o proprio sistema que se encarrega desta limpeza, evitando erros de desalocação de objetos ainda em uso.

Segura

O Java fornece uma série de mecanismos para garantir a segurança dos aplicativos. Um programa em Java não tem contato com o computador real; ele conhece apenas a máquina virtual (JVM). A máquina virtual decide o que pode ou não ser feito. Um programa Java nunca acessa dispositivos de entrada e saída, sistema de arquivos, memória, ao invés disso ele pede a JVM que acesse.

Introdução ao Java

2.6 Compilação dos Programas

2.6.1 Compilação Java

2.6.2 Compilação de Outras Linguagens

Código fonte Java Teste.java Compilador Pentium

Compilador PowerPC

Compilador Sparc

Código binário

Código binário

Código binário

Código fonte Java Teste.java Compilador Java (Pentium)

Código binário Teste.class

Compilador Java (PowerPC)

Compilador Java (Sparc)

Interpretador Java (Pentium)

Interpretador Java (PowerPC)

Interpretador Java (Sparc)

Figura 4. Compilação em Java

Figura 5. Compilação de outras linguagens

Introdução ao Java

set classpath=%classpath%;.;

O “.;” significa justamente que você esta setando o diretorio corrente, ou seja o diretorio onde você esta localizado. Por exemplo, se você esta localizado no diretorio c:\daniela\arquivos, e você seta o classpath com o “.;” é como se voce estivesse setando o proprio diretorio, como segue:

set classpath=%classpath%; c:\daniela\arquivos;

A variavel de ambiente CLASSPATH serve justamente para identificar o caminho das classes.

2.9 Estrutura das Aplicações Java

O desenvolvimento de aplicações em Java sempre é realizado através da manipulação de classes. Uma aplicação Java sempre terá a seguinte estrutura:

class NomeDaClasse { // Atributos // Métodos public static void main( String[] args ) { //corpo principal do programa } }

Claro que uma classe Java tera somente a classe, os métodos e seus atributos, não contendo a parte do método main.

Uma aplicação em Java é caracterizada por possuir um método main(). O método main é o método chamado pelo interpretador Java quando executado. A declaração do método deve ser rigorosamente: public static void main( String[] args), onde define um método de classe de acesso público, sem retorno, que recebe como parâmetro um array de Strings de tamanho indefinido, representado pela variável args. O args é a declaração do objeto do Array de String, por isso pode ser atribuído a ele qualquer nome.

A disposição dos atributos e métodos é feita de forma aleatória, ou seja, não importa a ordem, apenas necessitam respeitar regras de validade de escopo das variáveis, assunto abordado posteriormente.

Abaixo é demonstrada uma primeira aplicação que somente imprime na tela uma mensagem qualquer. Seguem os passos para construção da aplicação:

1. Abrir um editor de textos ou um IDE Java e escrever o programa

class OlaMundo { public static void main( String[] args ) { //corpo do programa //Escreve na tela: Ola Mundo. System.out.println(“Ola Mundo”); } }

Introdução ao Java

2. Salvar o arquivo dando a ele o mesmo nome da classe e com a extensão “.java”. Salvar arquivo com nome “OlaMundo.java”.
3. Compilar o arquivo javac OlaMundo.java

A compilação gerou um arquivo “OlaMundo.class”, que é o bytecode, o arquivo a ser executado.

4. Execute o programa utilizando o interpretador Java, e deve imprimir na tela “Ola Mundo” java PrimeiraApp

2.9.1 Elementos da Aplicação

public

É um quantificador do método que indica que este é acessível externamente a esta classe (por outras classes que eventualmente seriam criadas). Este tópico será abordado posteriormente.

static

É um qualificador que indica que este método é um método de classe, ou seja, há uma cópia somente por classe. Os métodos static podem ser invocados, mesmo quando não for criado nenhum objeto para a classe, para tal deve-se seguir a sintaxe:

.(argumentos)

void

Semelhante ao void do C/C++, corresponde ao valor de retorno da função. Quando a função não retorna nenhum valor ela possui a palavra reservada void no local de retorno, uma espécie de valor vazio que tem que ser especificado.

main

É um nome particular do método que indica para o compilador o início do programa, é dentro deste método e através de interações entre os atributos e argumentos visíveis nele que o programa se desenvolve.

String[] args

É o argumento do método main e por conseqüência, do programa todo, é um array de Strings que é formado quando são passados ou não argumentos através da invocação do nome do programa na linha de comando do sistema operacional.