A implementação da interface Servlet (javax.servlet.Servlet) é usada para todos os servlets, porque é essa interface que encapsula os métodos do ciclo de vida do servlet. Nesse ciclo, existem os métodos init(), service() e destroy(), que estão apresentados abaixo.

O método init()

O Container chama esse método depois que a instância do servlet for criada. Essa ação somente é completada com sucesso depois que o servlet não receber nenhuma solicitação. Esse método consegue sobrecarregar códigos de iniciação que são executados apenas uma vez, antes do tratamento de qualquer solicitação por parte do usuário. Um exemplo são cases que são necessários para carregar driver de banco de dados, ou efetuar alguma inicialização de valores.

Listagem 1: Assinatura do método init

public void init(ServletConfig config) throws ServletException

Comentando sobre a parte prática, o objeto ServletConfig, que foi definido como parâmetro na assinatura do método, contém valores de configuração que são geralmente declarados no arquivo de configuração, o web.xml. Com esse objeto, é permitido informar ações que ajudam a não fazerem “hardcode” no servlet. Essas ações podem ser representadas através de banco de dados ou pesquisa de um dado.

O método service()

Esse método é invocado quando chega a primeira solicitação do cliente, ou seja, depois que o método init permitir ao servlet responder a uma solicitação. O Container inicia uma nova thread ou aloca um thread de pool, onde é ativado o método service.

Listagem 2: Assinatura do método service

public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException

Os parâmetros da assinatura desse método são definidos através de um objeto ServletRequest e um objeto ServletResponse. O objeto ServletRequest contém a solicitação do cliente e o objeto ServletResponse contém a resposta do servlet. Esses objetos persistem na determinação de como o servlet servirá a solicitação do cliente. Na prática, esse método determina qual método HTTP (GET ou POST) chamar no servlet.

O método destroy()

Esse método tem como objetivo remover o servlet, sendo invocado quando todas as sequências dentro do método service() forem finalizadas. Geralmente isso ocorre quando o Container é fechado ou a memória está livre, ou seja, esse método limpa qualquer recurso que está ainda ativo.

Exemplo do ciclo de vida de uma servlet

Na Listagem 3 e Figura 1 são mostrados os ciclos de vida do servlet.

Listagem 3: Código de demonstração do ciclo de vida

package br.com.exemplos;

import java.io.IOException;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;


@WebServlet("/CicloDeVidaJsp")
public class CicloDeVidaJsp implements Servlet{
	public CicloDeVidaJsp() {
        super();
    }


    @Override
	public void init(ServletConfig arg0) thr

Pelo fato do framework JSF para muitos ser uma evolução da linguagem JSP, o ciclo de vida do JSF é parecido com o JSP. Por exemplo, quando o cliente faz uma requisição HTTP para a página, o servidor responde com a página traduzida para HTML. Porém, o que muda no ciclo de vida do JSF, é que na medida que é divido em múltiplas fases, apresenta-se um componente de modelo UI (User Interface) mais sofisticado. O modelo requer que componentes de dados consigam serem convertidos e validados, sendo propagados para os “Beans” de forma ordenada. Como consequência, os componentes de eventos são manipulados.

Durante o ciclo de vida, a implementação JSF deve construir a “view” conhecida como árvore de componentes UI, enquanto considerar o estado salvo de uma submissão passada da página. Quando o cliente submete uma página, a implementação JSF executa várias tarefas, como validações dos dados de entrada dos componentes na “view” e conversões de entrada de dados para tipos específicos do servidor.

A implementação JSF também executa todas as tarefas representadas na Figura 1.

Figura 1: Série de passos no ciclo de vida JSF de solicitações e respostas

O ciclo de vida manipula os seguintes tipos de requisições: requisições iniciais e postagens. Quando um usuário faz uma requisição inicial a uma página, acontece a solicitação da página pela primeira vez.

Na parte da postagem, é submetido o formulário que contém a página que está previamente carregada dentro do browser, como um resultado de execução na requisição inicial. Quando o ciclo de vida manipula uma requisição inicial, ele executa apenas a restauração da “view” e renderiza as fases da resposta, pois que não existe entrada do usuário ou ações para processo. Com isso, são executadas as fases “Restore View” e “Render Response”, por que não existe usuário ou ações para processar. Geralmente, quando o ciclo de vida trata uma postagem na qual são executados todos os processos das fases.

Geralmente, a primeira requisição de uma página JSF vem do resultado de um clique em um link. Para renderizar a resposta que está em outra página JSF, a aplicação cria uma nova “view” e restaura em uma instância FacesContext, que representa todo a informação contextual associada com o processamento de uma solicitação de entrada e criação de uma resposta. A aplicação então adquire referências de objetos necessárias pela “view” e chamadas do FacesContext.renderResponse, a qual força a renderização imediata da “view” partindo para a fase do ciclo de vida “Render Response”.

Algumas vezes, uma aplicação precisa ser redirecionada para um web service, ou gerar uma resposta que não contém componentes JavaServer Faces. Nesse caso, consegue-se renderizar a fase “Render Response” pela ação:

  callingFacesContext.
    resp

No surgimento da Internet, existiam apenas páginas com conteúdos estáticos desenvolvidos em HTML. Com o tempo, foram aparecendo no mercado páginas web com conteúdos dinâmicos através da tecnologia Commom Gateway Interface (CGI). A maioria dos programas CGI é escrita escrita como script em Perl, C, Python e PHP.

O CGI tem o processo que permite ao servidor web chamar o programa externo e passar informações de solicitações HTTP para conseguir processar uma solicitação. A resposta do programa externo é passada de volta ao servidor web, que a encaminha ao browser do cliente. Mas essa tecnologia tem a seguinte falha: Consome muitos ciclos de CPU e memória, com isso, quando acontece o processo de cada solicitação do cliente, o servidor web acaba reproduzindo um novo processo do programa CGI solicitado.

Servlets

A tecnologia Servlet é uma classe Java, que consegue gerar páginas dinâmicas para a camada de apresentação de aplicações web. O principal objetivo é receber chamadas HTTP, sendo processada e devolvida uma resposta para o cliente. Os servlets trabalham juntamente com a tecnologia Java Server Pages (JSP).

Vantagens dos Servlets

• Portabilidade - Os servlets permitem serem movidos para outros aplicações Java e sistemas operacionais.
• Desempenho - Ao contrário da tecnologia CGI, cada solicitação é gerenciada pelo processo do container.
• Agilidade - Possui acesso às bibliotecas Java, que ajudam no ciclo do desenvolvimento.
• Robustez - Pelos servlets serem gerenciados pela JVM, não tem muitos problemas de memória.

Container

O servlet pode ser carregado ou executado através por um servidor web especial, conhecido como “Container”. Isso acontece, porque os Servlets não possuem um método main().

Existem muitos aplicativos desse tipo, sendo que o oficial é o Tomcat. Originalmente projetado pela Sun, seu código fonte foi entregue à Apache Software Foundation. Hoje o Tomcat, é referência quando se trata de implementações em servlet.

O Tomcat é um servidor web, sendo usado para solicitar serviços HTTP processados. O Container trata dos seguintes casos em uma aplicação web, quando envolve servlets que são:

• Criação do servlet ou da nova thread para tratar uma solicitação de resposta.
• Invocação do método doPost() ou doGet() do servlet.
• Tratamento do envio das solicitações de requisição e resposta HTTP.
• Gerenciamento da vida e morte dos recursos do servlet.

Vantagens do Container

O Container proporciona uma série de benefícios que são:

• Suporte para comunicações;
• Suporte a multithread;
• Segurança;
• Suporte ao JSP;
• Gerenciamento do ciclo de vida;

Pontos importantes

Para começar a construir um servlet é necessário o JDK, Eclipse, o Tomcat instalado e configurado.

Mais informações sobre essa preparação pode ser encontrada nos links abaixo:

http://www.devmedia.com.br/conhecendo-o-eclipse-uma-apresentacao-detalhada-da-ide/25589

http://www.devmedia.com.br/instalacao-e-configuracao-do-apache-tomcat-no-eclipse/27360

Arquitetura do servlet

Na Figura 1 é mostrado como o Container trata uma solicitação de servlet. A simulação desse diagrama acontece quando o Cliente (usuário) clica em um link que é chamado um servlet. Após isso, quando o container visualiza que a requisição (request) aponta para um servlet, ele cria dois objetos: HttpServletResponse e HttpServletRequest. Sendo assim, o Container encontra o servlet correto baseado na URL da requisição, podendo criar ou alocar uma thread para essa requisição, passando os objetos de requisição (request) e resposta (response) para a thread do servlet.

Dependendo de como foi o tipo de solicitação, o Container chama o método doPost() ou doGet() ou service() do servlet. Esse método gera uma página dinâmica e a insere no objeto response. Esse processo termina com a thread, e o Container converte o objeto response em uma resposta HTTP, aonde envia de volta ao cliente e apaga os objetos request e response.

Figura 1: Arquitetura de um servlet

Em uma aplicação Servlet, podem ser incluídos conteúdos estáticos (páginas HTML, arquivos de imagem, entre outros). Como boas prátic

Introdução

Podemos destacar que a exceção é um evento não esperado que ocorre no sistema quando está em tempo de execução (Runtime). Geralmente quando o sistema captura alguma exceção o fluxo do código fica interrompido.

Para conseguir capturar uma exceção, é preciso fazer antes o tratamento. O uso dos tratamentos é importante nos sistemas porque auxilia em falhas como: comunicação, leitura e escrita de arquivos, entrada de dados inválidos, acesso a elementos fora de índice, entre outros.

Classificação

O uso das exceções em um sistema é de extrema importância, pois ajuda a detectar e tratar possíveis erros que possam acontecer. Entretanto, na linguagem Java existem dois tipos de exceções, que são:

• Implícitas: Exceções que não precisam de tratamento e demonstram serem contornáveis. Esse tipo origina-se da subclasse Error ou RunTimeException.
• Explícitas: Exceções que precisam ser tratadas e que apresentam condições incontornáveis. Esse tipo origina do modelo throw e necessita ser declarado pelos métodos. É originado da subclasse Exception ou IOException.

Existe também a formação de erros dos tipos throwables que são:

• Checked Exception: Erros que acontecem fora do controle do programa, mas que devem ser tratados pelo desenvolvedor para o programa funcionar.
• Unchecked (Runtime): Erros que podem ser evitados se forem tratados e analisados pelo desenvolvedor. Caso haja um tratamento para esse tipo de erro, o programa acaba parando em tempo de execução (Runtime).
• Error: Usado pela JVM que serve para indicar se existe algum problema de recurso do programa, tornando a execução impossível de continuar.

Figura 1: Exceções das classes

Hierarquia de exceções

No Java, todas as classes de exceção herdam direta ou indiretamente da classe Exception, formando uma hierarquia demonstrada na figura 2.

Figura 2: Hierarquia de herança da classe Throwable

A classe Throwable tem duas subclasses:

• Exception (java.lang.Exception) – É a raiz das classes originárias da classe Throwable, onde mostra as situações em que a aplicação pode querer capturar e realizar um tratamento para conseguir realizar o processamento.
• Error (java.lang.Error) – Também é raiz das classes originárias da classe Throwable, indicando as situações em que a aplicação não deve tentar tratar, como ocorrências que não deveriam acontecer.

Existe uma diferença entre “Erro (Error)” e “Exceção (Exception)”. O “Erro” é algo que não pode mais ser tratado, ao contrário da “Exceção” que trata seus erros, pois todas as subclasses de Exception (menos as subclasses RuntimeException) são exceções e devem ser tratadas. Os erros da classe Error ou RuntimeException são erros e não precisam de tratamento, por esse motivo é usado o try/catch e/ou propagação com throw/throws.

Blocos try/catch/finally

O bloco try tenta processar o código que está dentro, sendo que se ocorrer uma exceção, a execução do código pula para a primeira captura do erro no bloco catch. O uso do try serve para indicar que o código está tentando realizar algo arriscado no sistema.

O bloco catch trata a exceção lançada. Caso a exceção não seja esperada, a execução do código pula para o próximo catch, se existir. Portanto, se nenhum do bloco catch conseguir capturar a exceção, dependendo o tipo que for, é causada a interrupção ao sistema, lançando a exceção do erro. Um exemplo do uso desse bloco é visto em transações de Rollback, onde são utilizados para que a informação não persista no banco se for capturada uma exceção nesse bloco catch.

A bloco finally sempre finaliza a sequência de comandos do sistema, independente de ocasionar algum erro no sistema. Esse bloco é opcional, não sendo obrigatório sua inserção na sequência try/catch. É usado em ações que sempre precisam ser executadas independente se gerar erro. Um exemplo é o fechamento da conexão de um banco de dados.

Praticamente, o uso dos blocos try/catch se dá em métodos que envolvem alguma manipulação de dados, bem como:

Introdução

Em qualquer software, sempre existem campos que passam por algumas validações. O objetivo de ter essas validações é simplesmente o fato de que os dados que são informados podem ter o valor e forma determinados pelo sistema. Podemos destacar que essas validações, são como mecanismos de defesa do sistema em relação ao usuário, pois muitos dos problemas são relacionados à gravação de dados incorretos por parte do usuário.

Um exemplo é o sistema permitir apenas letras em alguns campos e o usuário acaba inserindo letras e números. Essa ação pode gerar vários problemas, pois quando esse dado é gravado, pode gerar algum erro relacionado ao banco de dados por somente aceitar números, ou estourar uma exceção do programa por não saber como se comportar com a informação enviada. Enfim, é um fator que deve ser levado a sério.

Expressão Regular

Uma expressão regular é uma String especialmente formatada que mostra um padrão de pesquisa e substituição de textos. O principal objetivo dessas expressões é fazer validações nos dados de um programa, assegurando que estes dados estejam em um determinado formato. Uma expressão consiste em caracteres literais e símbolos especiais.

Para criar uma expressão regular é necessário informar caracteres especiais usados no padrão da expressão. Esses caracteres são conhecidos como metacaracteres, indicando a ocorrência de números, letras entre outros caracteres no texto. Abaixo são exibidos alguns caracteres utilizados para construir a expressão regular.

Figura 1: Lista de caracteres

Método matches

O método matches especifica uma expressão regular e localiza o conteúdo do objeto String em que está sendo aplicada essa expressão. Para saber se essa correspondência foi atendida ou não, é retornado um valor booleano (true ou false).

Nas listagens desse artigo, são mostrados alguns exemplos do que pode ser inicialmente trabalhado. Para fins de ensino, as variáveis estão sendo impressas para mostrar o valor de retorno de cada padrão utilizado.

Listagem 1: Exemplo simples da classe matches

public class TestaExpressoes {
	public static void main(String[] args) {
		boolean nome = "Maria".matches("Maria");
		System.out.println("Retorno = "+nome);
	}
}

Modificadores

Um modificador é um caractere adicionado depois de um o delimitador final, onde acaba mudando o jeito como a função irá tratar a expressão. Abaixo estão relacionados os modificadores que podem ser usados:

• (?i) - Ignora maiúsculas de minúsculas.
• (?m) - Trabalha com multilinhas.
• (?s) - Faz com que o caractere encontre novas linhas.
• (?x) - Permite inclusão de espaços e comentários.

Na listagem 2 foi usado o modificador (?i), que faz com que o resultado tenha o retorno verdadeiro (true), pois esse modificador tem o objetivo de ignorar letras maiúsculas e minúsculas.

Listagem 2: Modificador ignora letras maiúsculas e minúsculas

public class TestaExpressoes_Modificadores {
	public static void main(String[] args) {
		boolean sobreNome = "Silveira".matches("(?i)silveira");
		System.out.println("Retorno = "+sobreNome);
	}
} 

Abaixo, nas listagem 3 e 4, são mostrados algumas validações de ocorrências através dos metacaracteres.

Listagem 3: Validações de caracteres

public class TestaMetacaractere {

	public static void main(String[] args) {

		boolean email = "@".matches(".");
		System.out.println("Qualquer caractere: "+email);
		
		boolean numero = numero = "a".matches("\\d");
		System.out.println("Possui número: "+numero);
		
numero = "2".matches("\\d");
		System.out.println("Possui número: "+numero);
		
		boolean letrasNumeros = 

Introdução

As classes apresentadas neste artigo demonstram como a programação em Java consegue manipular as datas, horas e internacionalizá-las. No Java o tempo é representado em milissegundos, sendo medido a partir da data 01/01/1970. Essa data pode ser recuperada através do comando System.currentTimeMillis().

Abaixo são mostradas as principais classes utilizadas quando se trata de algum dado que envolva datas.

Figura 1: Trabalhando com datas no Java

Classe Date

A data representa o tempo, um tempo é composto por ano, mês, dia atual, minuto atual, entre outras propriedades que essa classe possui.

Como referência, este link http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Date.html mostra todos os detalhes de métodos e construtores que a classe Date do pacote java.util possui.

Hoje a maioria dos métodos da classe Date estão classificados como deprecated (depreciados), ou seja, são métodos que não são mais utilizados, por isso essa classe foi substituída pela classe Calendar, para haver suporte correto à internacionalização do sistema de datas.

Na listagem 1 é instanciada a classe Date e exibida a data atual em detalhes.

Listagem 1: Testando a classe Date.

import java.util.Date;

public class Testa_Date {
	public static void main(String[] args) {
		Date data = new Date();
		System.out.println("Data Agora: "+data);
	}
}

Classe Calendar

Essa classe pode produzir os valores de todos os campos de calendário necessários para implementar a formatação de data e hora, para uma determinada língua e estilo de calendário. Por exemplo, japonês, americano, italiano, brasileiro entre outros.

A classe Calendar é a mais usada quando se trata de datas, mas como é uma classe abstrata, não pode ser instanciada, portanto para obter um calendário é necessário usar o método estático getInstance(), apresentado no exemplo da listagem 2.

Listagem 2: Recuperação da data com a classe Calendar

import java.util.Calendar;

public class Data_Calendar{

	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		System.out.println("Data e Hora atual: ”+c.getTime());
	}
}

Com a classe Calendar também se consegue manipular a data e hora com os métodos que são fornecidos, abaixo seguem os exemplos.

Listagem 3: Mostra o dia da semana, mês e ano

import java.util.Calendar;

public class Testa_Metodo_Get_Calendar{

	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		
		System.out.println("Data/Hora atual: "+c.getTime());
		System.out.println("Ano: "+c.get(Calendar.YEAR));
		System.out.println("Mês: "+c.get(Calendar.MONTH));
		System.out.println("Dia do Mês: "+c.get(Calendar.DAY_OF_MONTH));
	}
}

Listagem 4: Alterando a data/hora com método set

import java.util.Calendar;

public class Testa_Metodos_Set_Get_Calendar{

	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		c.set(Calendar.YEAR, 1995); 
		c.set(Calendar.MONTH, Calendar.MARCH); 
		c.set(Calendar.DAY_OF_MONTH, 20);
		
		System.out.println("Data/Hora atual: "+c.getTime());
		System.out.println("Ano: "+c.get(Calendar.YEAR));
		System.out.println("Mês: "+c.get(Cale

Antes de tudo, deve ser verificada a perspectiva do Eclipse, se está para desenvolvimento Java EE. De acordo com a perspectiva que estiver aberta, não é possível visualizar certas opções de criação do projeto web.

Para confirmar a perspectiva, acesse o menu Window -> Open Perspective -> Other, como mostrado na figura 1.

Figura 1: Menu de acesso à perspectiva

Figura 2: Abrindo uma perspectiva de ambiente

De acordo com a figura 2, basta apenas selecionar a opção Java EE e confirmar para conseguir criar um projeto web.

** Conheça o curso Curso de Java: Desenvolvimento de aplicações Web no Eclipse

Para criar um projeto web, clique com o botão direito na view Project Explorer, selecione a opção New -> Dynamic Web Project, como mostrado na figura 3.

Figura 3: Selecionando o tipo do projeto

Figura 4: Configurações de um novo projeto web

Acima, na figura 4, foram realizadas algumas marcações com números de referência para as explicações logo abaixo:

1. Project Name – Especificar um nome para o projeto.
2. Target Runtime – Após configurar o servidor Tomcat, essa opção é preenchida automaticamente, mas vale sempre observar se está marcando algum servidor.
3. Configuration – Clique no botão Modify e marque a opção JavaServer Faces e confirme a janela, de acordo com a figura 4.

Figura 5: Lista de componentes para habilitar no projeto

Após isso, clique no botão Next que irá mostrar a figura 6.

Figura 6: Local onde os códigos Java irão ficar, por padrão não é alterado, clique em Next

Figura 7: Configuração do módulo Web

Na figura 7, é importante selecionar a opção destacada para gerar o arquivo web.xml, conhecido como Deployment Descriptor. Clique em Next.

Figura 8: Configurações de bibliotecas

Ao chegar na tela da figura 8, é preciso realizar os seguintes ajustes que estão destacados:

• Type: Deixar selecionada a opção Disable Library Configuration.
• URL Mapping Patterns: Adicionar os seguintes mapeamentos *.jsf e *.xhtml.

Estrutura projeto web

Para entender mais sobre cada compartimento, abaixo são mostrados os principais itens dessa estrutura, que são:

• Deployment Descriptor – É o arquivo web.xml (WEB-INF) que contém as informações para realizar os ajustes dos parâmetros da aplicação, como segurança, mapeamentos, filtros, conversores, entre o ...

O uso das ferramentas mostradas neste artigo é baseado em dois simples critérios básicos: popularidade e experiência. Para chegar nesse processo final com um resultado positivo, será necessário ter o Java e o Eclipse instalado, caso não possua, siga as instruções mostradas nos links abaixo:

• http://www.devmedia.com.br/conhecendo-o-eclipse-uma-apresentacao-detalhada-da-ide/25589
• http://www.devmedia.com.br/preparacao-do-ambiente-para-desenvolvimento-em-java/25188

Apache Tomcat

O Apache Tomcat, conhecido no popular como servidor web Java ou container, é o que gerencia e roda o Servlet. Pode-se dizer que o Tomcat é um servidor de aplicações Java EE (Enterprise Edition), pois consegue suportar a execução das tecnologias de Servlets, Realms, JNDI Resources, JDBC DataSources e JSP, cobrindo a parte da especificação J2EE permitindo que o Java funcione no modo web.

Instalação do Tomcat

A instalação será demonstrada na versão 7 do Tomcat, onde se tem o auxílio do instalador. Acesse link abaixo para download do programa:

http://tomcat.apache.org/download-70.cgi

Ao acessar o link acima será apresentada a imagem da figura 1. Para baixar é necessário escolher a versão do instalador, nesse caso escolher o que está destacado na imagem.

Figura 1: Download da versão do Tomcat

Após baixar o arquivo, execute-o e prossiga com os passos mostrados nas imagens abaixo:

Figura 2: Tela inicial da instalação do Tomcat

Figura 3: Tela de acordo

Figura 4: Tipo de instalação

Na figura 5, não será preciso mudar nenhuma configuração, apenas basta inserir uma credencial nos campos “Username” e “Password”, geralmente o padrão usado é a palavra “admin” para os dois campos. Essa credencial depois será usada quando for acessado o “localhost” do Tomcat para efetuar os deploys das aplicações.

Figura 5: Configurações do Tomcat

Figura 6: Localização do Java

Quando for realizar a escolha da instalação do Tomcat, sempre insira em uma pasta dentro do disco local (C:), pois às vezes o Windows não pode iniciar direito os serviços do servidor por falta de privilégios de acesso na pasta.

Figura 7: Local da instalação do Tomcat

Usando o Manager do Tomcat

O manager do Tomcat é um aplicativo que possibilita gere

Introdução

Nos desenvolvimentos de sistemas, existem alguns fatores importantes como: o entendimento do código, fácil manutenção, reaproveitamento entre outros. Para isso, a Programação Orientada a Objetos também conhecida como POO, tem a intenção de ajudar nesses fatores, dando tempo e agilidade no desenvolvimento de um sistema para o programador.

A Programação Orientada a Objetos foi criada por Alan Kay, autor da linguagem Smalltalk. Antes mesmo da criação Orientada a Objetos, já existiam algumas aplicações, neste caso da linguagem Simula 67, criada por Ole Johan Dahl e Kristen Nygaard em 1967.

Veja na Figura 1 a trajetória que a programação teve para se chegar ao uso da POO.

Figura 1: Linha do tempo das técnicas de programação

Elementos

A Programação Orientada a Objetos é formada por alguns itens, dentre os quais destacamos: Classes, Objetos, Atributos, Métodos, Construtores, que irão ser mostrados nesse artigo.

Classes

As classes de programação são projetos de um objeto, aonde têm características e comportamentos, ou seja, permite armazenar propriedades e métodos dentro dela. Para construir uma classe é preciso utilizar o pilar da abstração. Uma classe geralmente representa um substantivo, por exemplo: uma pessoa, um lugar, algo que seja “abstrato”.

Características das classes

• Toda classe possui um nome;
• Possuem visibilidade, exemplo: public, private, protected;
• Possuem membros como: Características e Ações;
• Para criar uma classe basta declarar a visibilidade + digitar a palavra reservada class + NomeDaClasse + abrir e fechar chaves { }.

Listagem 1: Declaração de uma classe na linguagem Java

public class Teste{
//ATRIBUTOS OU PROPRIEDADES
//MÉTODOS
}

Na Listagem 2, são mostrados os componentes da classe, como métodos e atributos.

Listagem 2: Classe Caes

public class Caes {
	
	public String nome;
	public int peso;
	public String corOlhos;
	public int quantPatas;
	
	public void falar(){
		//MÉTODO FALAR
	}
	
	public void andar(){
		//MÉTODO ANDAR
	} 
	
	public void comer(){
		//MÉTODO COMER
	}
	
	public void dormir(){
		//MÉTODO DORMIR
	}
}

Figura 2: Demonstração da classe Cães

Na Listagem 2 e na Figura 2, mostra que a classe Cães de um modo genérico, tem os mesmos métodos independente de qualquer cachorro, sendo que a classe é sempre um molde/projeto para o objeto cachorro.

Objetos

Os objetos são características definidas pelas classes. Neles é permitido instanciar objetos da classe para inicializar os atributos e invocar os métodos. Veja no exe

O objetivo deste artigo é apresentar alguns componentes fundamentais da Programação Orientada a Objetos: Polimorfismo, Classes Abstratas e Interfaces. Serão apresentados os conceitos e implementações na linguagem Java para facilitar o entendimento.

Polimorfismo

O polimorfismo permite que classes abstratas consigam receber comportamentos através de classes concretas. Por exemplo, um dispositivo USB, podemos considerar que o USB seria uma classe abstrata enquanto os dispositivos (Pen Driver, Ipad, Câmeras, etc) seriam as classes concretas. Ou seja, o USB é uma especificação que pode ter várias implementações com características diferentes.

A figura a seguir ilustra alguns exemplos de tipos de polimorfismo.

Figura 1: Exemplo de Polimorfismo

Sobrescrita de método

A seguir temos um exemplo onde uma classe Soma herda de uma outra OperacaoMatematica, sobrescrevendo seu método calcular para implementar a lógica adequada à sua função. A sobrescrita de métodos é muito utilizada na implementação de polimorfismo para que uma classe filha possa definir seu próprio comportamento, baseada na estrutura da classe mãe.

Listagem 1: Classe OperacaoMatematica

public class OperacaoMatematica {
	
	public double calcular(double x, double y){
		return 0;
	}
}

Listagem 2: Classe Soma herdando de OperacaoMatematica

public class Soma extends OperacaoMatematica {

	public double calcular(double x, double y){
		return x + y;
	}
}

Neste exemplo da Listagem 3 é mostrado porque o polimorfismo é conhecido como “possuir muitas formas”. No método “calculaOperacao” acontece o polimorfismo, pois quando invocado, o argumento do tipo “OperacaoMatematica” é diferente para cada operação.

Listagem 3: Classe Testadora de polimorfismo

public class TestaOperacaoMatematica {

	//EXECUTA A OPERACAO - COM POLIMORFISMO
	public static void calculaOperacao(OperacaoMatematica o, double x, double y){
		System.out.println(o.calcular(x, y));
	}
		
	public static void main(String[] args) {
		calculaOperacao (new Soma(), 2500, 200);
		calculaOperacao (new Multiplicacao(), 10, 10);
	}
}

Classes abstratas

Pode-se dizer que as classes abstratas servem como “modelo” para outras classes que dela herdem, não podendo ser instanciada por si só. Para ter um objeto de uma classe abstrata é necessário criar uma classe mais especializada herdando dela e então instanciar essa

Introdução

A Programação Orientada a Objetos conhecida como POO, é onde o desenvolvedor tem de começar a pensar fora da caixa, a imaginar uma forma aonde será preciso recorrer ao mundo real para o desenvolvimento das aplicações, pois hoje toda a programação em Java é orientada a objetos.

Para obter esse entendimento, é necessário conhecer alguns dos pilares da Orientação a Objetos que são: Abstração, Encapsulamento, Herança e Polimorfismo. Neste artigo o pilar do Polimorfismo não será visto.

1º Pilar - Abstração

É utilizada para a definição de entidades do mundo real. Sendo onde são criadas as classes. Essas entidades são consideradas tudo que é real, tendo como consideração as suas características e ações, veja na Figura 1 como funciona.

Figura 1: Abstrações do mundo real

Uma classe é reconhecida quando tem a palavra reservada “class”. Na Listagem 1 é mostrada a classe “Conta” com seus atributos (características) e métodos (ações). Para saber mais sobre métodos acesse o link: http://www.devmedia.com.br/trabalhando-com-metodos-em-java/25917.

Listagem 1: Exemplo de abstração da classe Conta.

public class Conta {	
	int numero;
	double saldo;
	double limite;	

	void depositar(double valor){
		this.saldo += valor;
	}	

	void sacar(double valor){
		this.saldo -= valor;
	}
	
	void imprimeExtrato(){
		System.out.println("Saldo: "+this.saldo);
	}
}

2º pilar - Encapsulamento

É a técnica utilizada para esconder uma ideia, ou seja, não expôr detalhes internos para o usuário, tornando partes do sistema mais independentes possível. Por exemplo, quando um controle remoto estraga apenas é trocado ou consertado o controle e não a televisão inteira. Nesse exemplo do controle remoto, acontece a forma clássica de encapsulamento, pois quando o usuário muda de canal não se sabe que programação acontece entre a televisão e o controle para efetuar tal ação.

Como um exemplo mais técnico podemos descrever o que acontece em um sistema de vendas, aonde temos cadastros de funcionários, usuários, gerentes, clientes, produtos entre outros. Se por acaso acontecer um problema na parte do usuário é somente nesse setor que será realizada a manutenção não afetando os demais.

Em um processo de encapsulamento os atributos das classes são do tipo private. Para acessar esses tipos de modificadores, é necessário criar métodos setters e getters.

Por entendimento os métodos setters servem para alterar a informação de uma propriedade de um objeto. E os métodos getters para retornar o valor dessa propriedade.

Veja um exemplo de encapsulamento, na Listagem 2 gera-se os atributos privados (private) e é realizado o processo de geração dos métodos setters e getters.

Figura 2: Métodos getters e setters

Listagem 2: Encapsulamento da classe Funcionario.

public class Funcionario {
	private double salario;
	private String nome;

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}
	
	public void setSalario(double salario) {
		this.salario = salario;
	}
	
	public double getSalario() {
		return salario;
	}
}

Na Listagem 3, é instanciado a classe “Funcionario”, onde a variável de referência é usada para invocar os métodos setters, informando algum dado. Ao final, é usado os métodos getters dentro do “System.out.println” para gerar a saída dos resultados que foram passados nos métodos setters.

Listagem 3: Classe Testadora dos métodos getters e setters.

public class TestaFuncionario {

Introdução

A ferramenta JDeveloper é um ambiente de desenvolvimento integrado gratuito da Oracle que oferece funcionalidades para o desenvolvimento em Java, XML, SQL e PL/SQL, HTML, JavaScript, BPEL e PHP. Esse IDE cobre todo o ciclo de desenvolvimento desde a análise até a codificação, a manutenção, a otimização e a implantação.

Antes de começar a ver maiores detalhes é necessário efetuar o download da ferramenta através do link: http://www.oracle.com/technetwork/developer-tools/jdev/overview/index.html.

Figura 1: Site para download do IDE

Com o IDE JDeveloper o desenvolvedor consegue desenvolver qualquer aplicação voltada para a Web. Essas aplicações basicamente podem ser desenvolvidas em Java EE, Java Desktop, Fusion Web entre outras. O foco desse artigo será para aplicações Fusion Web.

Na Figura 2 é mostrada a tela inicial do JDeveloper onde o usuário tem o primeiro contato com a ferramenta.

Figura 2: Tela Inicial do JDeveloper

Antes de começar a construir uma aplicação Fusion Web, é importante conhecer algumas abas de navegações que ajudam no desenvolvimento, acessadas através do menu View. Veja as abas que estão descritas abaixo que podem ser habilitadas a partir desse menu.

Application Navigator

É a janela que gerencia e navega pelas fontes da aplicação, como: Pacotes, Arquivos Java, Definições de Páginas (Page Definition), Views Objects, Entities Objects.

Dentro do Application Navigator existem alguns painéis que gerenciam o conteúdo da aplicação, sendo que os painéis mais usados são o Projects e o Data Controls.

Figura 3: Painéis do Application Navigator

Veja abaixo descrição dos principais painéis.

Projects – É o principal painel onde podemos criar, visualizar e editar códigos fontes da aplicação. Para abrir os arquivos podemos clicar com o botão direito em cima dos objetos e selecionar a opção Open ou clicar duas vezes no arquivo desejado.

Data Controls - Exibe o modelo de dados da aplicação atual. Esse painel é usado quando são construídas aplicações UI (Interface do Usuário). Através dele são mostrados os atributos dos dados e ações expostas pelo Business Service (Serviços de Negócios), através da camada de modelo do ADF.

Existe um facilitador que possibilita arrastar as coleções de dados, atributos ou ações para dentro das páginas desejadas. Quando arrastado o componente para dentro da página, são criados automaticamente uma ligação de itens UI como campos, tabelas, gráficos, botões entre outros componentes, como descrito na Figura 4.

Introdução

A linguagem Java é capaz de processar arquivos que requisitam grandes quantidades de dados persistentes. Esses são os dados que ficam armazenados dentro dos arquivos, sendo que a sua duração vai além da finalização de um programa. Esse processamento de arquivos é uma capacidade que o Java oferece para ler e gravar dados na memória, arquivos e conexões de rede.

Quando existe um dispositivo de entrada de dados ativo, para obter dados deste dispositivo é usada uma ação conhecida como read(). E para enviar um dado para um dispositivo de saída é utilizado o método write().

Para trabalhar com entrada e saída de dados são utilizada as classes que estão dentro do java.io. Essas classes oferecem algumas funcionalidades como:

• Manipulação de entrada e saída de bytes – transferência de dados binários;
• Manipulação de entrada e saída de caracteres – transferência de textos;
• Buffers - melhoram a eficiência da velocidade de leitura e escrita;
• Conversão de formatos – texto e formato interno de dados binários.

As entradas e saídas de dados são manipuladas como sequência de bytes, através das classes InputStream e OutputStream e as classes dependentes.

Classe InputStream

É uma classe abstrata que oferece a funcionalidade básica para a leitura de um byte ou de uma sequência de bytes a partir de alguma fonte.

Lendo um arquivo

Os métodos read() oferecem a leitura de bytes. O valor de retorno desse método é um inteiro, que pode ser o byte lido do próprio método ou número de bytes lidos do método read(byte[] b) sendo que quando o retorno for o valor de -1, é informado que o final do arquivo foi atingindo.

Listagem 1: Ler um byte de um arquivo.

	
		InputStream is = new FileInputStream("arquivo.txt");
		int valor = is.read();
 

Na Listagem 1, a classe abstrata InputStream é declarada inicializando uma classe dependente, a FileInputStream. Essa classe recebe uma String como argumento no construtor. Esse argumento é a definição de onde está localizado o arquivo.

Figura 1: Hierarquia da classe InputStream

Então as principais subclasses de InputStream são:

• ByteArrayInputStream – Valores são originários de um arranjo de bytes;
• FileInputStream – Bytes com originalidade de um arquivo.
• FilterInputStream – Filtra os dados de um InputStream.
• BufferedInputStream – Faz a leitura de grandes volumes de bytes que armazena em um buffer interno.
• DataInputStream – Permite a leitura de representações binárias dos tipos primitivos de Java.
• ObjectInputStream – Oferece o método readObject para a leitura de objetos que foram serializados para um ObjectOutputStream.
• PipedInputStrea ...

Os programas em Java são escritos combinando métodos e classes que são predefinidos na API do Java (Java Application Programming Interface ou bibliotecas de classes Java). Em construções de grandes softwares, são criadas em classes pequenas partes de código, que são identificados como métodos.

Métodos

Os métodos são conhecidos como funções, ações de execuções ou procedimentos, sendo responsáveis por ajudar no design do sistema (separação por blocos), e na reutilização de software, podendo ser aproveitados métodos já existentes para a construção de novos sistemas.

As classes que armazenam esses métodos são conhecidas como projetos de objetos, onde são definidos os atributos que o objeto terá e os métodos projetados para realizar as tarefas da classe.

Por exemplo, quando criado um método com a ação de depositar um valor para uma conta bancária, dentro desse método são incluídas as ações que irão retornar algum valor, trabalhar em uma variável ou até mesmo chamar outro método já criado.

Listagem 1: Classe Conta com os métodos e atributos

public class Conta {
	
	private Double saldo;

	public void setSaldo(Double saldo) {
		this.saldo = saldo;
	}

	public Double getSaldo() {
		return saldo;
	}
	
	public void depositar(Double valor){
		saldo += valor;
	}
	
	public void verificaSaldo(){
		System.out.println("Valor do Saldo: "+getSaldo());
	}
}

Na Listagem 2 usamos uma variável que contém uma referência a um objeto, seguido por um ponto (.) que faz a invocação de todos os métodos e variáveis públicas.

Listagem 2: Invocação dos métodos da classe Conta.

	public static void main(String[] args) {
		
		//INSTANCIA A CLASSE
		Conta conta = new Conta();
		
		//DEFINE UM VALOR DE SALDO
		conta.setSaldo(633.00);
		
		//DEFINE VALOR PARA DEPOSITAR
		conta.depositar(555.0);
		
		//RESGATA VALOR
		conta.verificaSaldo();
		
	}

Métodos static

Os métodos static ou métodos da classe são funções que não dependem de nenhuma variável de instância, quando invocados executam uma função sem a dependência do conteúdo de um objeto ou a execução da instância de uma classe, conseguindo chamar direto qualquer método da classe e também manipulando alguns campos da classe.

Os métodos static tem um relacionamento com uma classe como um todo, enquanto os métodos que não são static são associados a uma instância de classe específica (objeto) e podem manipular as variáveis de instância do objeto, como pode ser visto nos exemplos de declarações de métodos.

Na Listagem 3 é usado o nome de classe e um ponto (.) que faz a invocação de um método static da classe.

Listagem 3: Invocando métodos static

public class Teste_Metodo_Static {

	public static void main(String[] args) {
		double num1 = 8.5;
		double pi = Math.PI;
		
		System.out.println("Valor num1 = "+num1);
		System.out.println("Valor PI = "+pi);

		System.out.println("Soma dos valores = "+(num1+pi));

	}

}

No exemplo da Listagem 4 não é instanciado nenhum objeto, apenas é chamada a classe diretamente, invocando o método resultado que recebe dois argumentos do tipo inteiro.

Listagem 4: Exemplo chamada de método static

class Soma{
	
	public static int resultado(int num1, int num2){
		return (num1 + num2);
	}
}

public class TestaSomaEstatica {

	public static void main(String[] args) {
		
		System.out.println(Soma.resultado(10,50));
	}
}
[/CODE

As aplicações em geral precisam de alguns eventos para o funcionamento completo do programa. Normalmente as GUIs do Java são baseadas em eventos, que são tarefas realizadas quando um usuário faz a interação com algum componente GUI, convertendo as ações do usuário em eventos, como por exemplo:

• Quando ocorre uma ação (ActionEvent);
• Clique do mouse (MouseEvent);
• Apertar em uma tecla (KeyEvent);
• Fechar uma janela (WindowEvent);

As tarefas de respostas realizadas em um evento são conhecidas como handler de evento e o processo total de responder a eventos é conhecido como tratamento de evento. Para cada tipo de evento precisa ser implementada uma interface de escuta.

As informações de evento são armazenadas em um objeto de uma classe que estende AWT.Event. Veja abaixo na Figura 1 a hierarquia de eventos referente ao pacote java.awt.

Figura 1: Classes de evento do pacote java.awt

Existem três elementos para o funcionamento d1o tratamento de evento que são:

• Origem do Evento: é o componente GUI com qual o usuário interage.
• Objeto do Evento: contém os dados do evento invocado, sendo como uma referência à origem do evento e quaisquer informações específicas do evento que podem ser exigidas pelo ouvinte para testar o evento.
• Ouvinte do Evento: é um objeto que é notificado pela origem de evento quando um evento ocorre.

Na Figura 2 são mostradas as interfaces ouvintes de eventos dos pacotes javax.swing.event.

Figura 2: Interfaces listener de eventos

Lembrando que as interfaces providas da classe Listener podem ter um ou mais métodos de tratamento de evento que devem ser declarados na classe que implementa a interface.

Sendo evento ouvinte

Quando existe a intenção de uma ação do usuário sobre algum componente, é necessário o componente saber que há esse interesse, sendo assim é implementado a interface ActionListener e usado o método addActionListener() sendo passado como parâmetro a palavra “this”, é a referência do objeto da classe que implementa a interface ActionListener, neste caso ela mesma. Após isso é preciso saber uma maneira de chamar o componente quando algum evento ocorrer, sendo que o componente irá chamar o método da interface de escuta, ActionListener.

Para fazermos um tratador de eventos precisamos de três ações básicas:

1. Especificar uma classe que implemente uma interface de ActionListener:
   public class CapturaEvento implements ActionListener {
2. Executar um código que registre uma instância desta classes como um listener de um ou mais componentes:
   botao.addActionListener(this);
3. Definir o método de manipulação de eventos interface ActionListener:
   public void actionPerformed(ActionEvent evento) {

Listagem 1: Captura o evento de um botão

import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class CapturaEventoBotao implements ActionListener {
	
	private JButton botao;
	
	public void janela(){
		JFrame frame = new JFrame();
		botao = new JButton();
		
		//REGISTRA O EVENTO
		botao.addActionListener(this);

		frame.getContentPane().add(botao);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(300,100);
		frame.setVisible(true);
	}
	
	@Override
	public void actionPerformed(ActionEvent evento) {
		botao.setText("Botão foi clicado!");
		
		//ALTERA A FONTE 
		botao.setFont(new Font("SansSerif", Font.BOLD, 20));	
	}
	
	public static void main(String[] args) {
		CapturaEventoBotao captura = new CapturaEventoBotao();
		captura.janela();
	}
}

Handler de Evento

Quando um evento acontece, é realizado o despacho (dispatching) para os ouvintes apropriados. Esse despacho é o processo em que o componente GUI chama um método de tr

Servidor Web

A função do servidor web é receber uma solicitação (requisição) e devolver (resposta) algo para o cliente.

O browser permite ao usuário solicitar um recurso e quando o servidor responde a uma solicitação são encontrados recursos como: páginas HTML, figuras e documento PDF que são exibidas depois para o usuário. Geralmente os servidores enviam instruções para o browser escritas em HTML. O HTML diz ao browser como apresentar conteúdo ao usuário web.

Figura 1: Simulação de uma solicitação e resposta

O servidor em si tem alguns recursos, mas por algumas deficiências não consegue processar tudo sozinho como: criações de páginas dinâmicas e o armazenamento de dados em um banco de dados.

Páginas Dinâmicas – Quando a aplicação roda no servidor, este disponibiliza somente páginas estáticas. Porém, para efetuar essa comunicação é necessário o auxílio de uma outra aplicação de ajuda que é passada através de Servlet.

Armazenar dados no servidor – Para efetuar essa ação o servidor precisa de uma aplicação de apoio (Servlet), fazendo com que o servidor envie esses parâmetros para o Servlet.

Solicitação do Usuário Web

A função do usuário web é permitir fazer solicitações ao servidor, exibindo o resultado do pedido. O browser é o software que se comunica com o servidor.

Figura 2: Usuário Web - Solicitação e resposta para uma página web

Protocolo HTTP

É um protocolo que os clientes e os servidores usam para se comunicar. Essa comunicação é baseada em requisições (request) e respostas (responses). Veja abaixo os elementos dessa comunicação:

Conteúdo de uma solicitação

• Método HTTP;
• Página que será acessada;
• Parâmetros do formulário;

Conteúdo de uma resposta

• Código de status (informa se a solicitação foi realizada com sucesso ou não);
• Tipo de Conteúdo (HTML, figuras, textos, etc);
• Conteúdo (HTML real, imagem, etc);

A solicitação HTTP possui outra solicitação conhecida como URL (Localizador Uniforme de Recursos). A solicitação URL é um recurso que se ativa quando o usuário tenta acessar alguns dos métodos HTTP descritos abaixo.

Métodos HTTP

GET - Solicita ao servidor um recurso chamado de solicitação URl. Este é o método padrão, pois é a forma como o browser chama o servidor quando digita-se uma URL para que ele a recupere.

POST - Contém um corpo nos quais seus parâmetros de solicitação já são codificados. O mais frequente uso desse método é na submissão de formulários.

HEAD - Similar ao método GET, o servidor ape

Gerenciadores de Layout

Todos os gerenciadores de layout implementam a interface LayoutManager que faz parte do pacote java.awt. Existe o método setLayout da classe Container que aceita um objeto que implementa a interface LayoutManager como um argumento.

Veja três maneiras básicas de organizar componentes em uma GUI:

• Posicionamento absoluto: fornece o maior nível de controle sobre a aparência de uma GUI, pois configura o layout de um Container como null podendo especificar a posição absoluta de cada componente GUI em relação ao canto superior esquerdo do Container usando os métodos Component setSize e setLocation ou setBounds.
• Gerenciadores de layout: é mais simples e mais rápido para criar uma posição GUI com posicionamento absoluto, mas acaba perdendo controle sobre tamanho e o posicionamento dos componentes GUI.
• Programação visual em uma IDE: facilita o desenvolvimento em GUI, pois toda IDE tem uma ferramenta de design que permite arrastar e soltar (drag and drop) os componentes para uma área de desenho.

Cada contêiner individual pode ter apenas um gerenciador de layout, mas vários contêineres no mesmo aplicativo podem utilizar cada um gerenciador de layout. Os gerenciadores de layout são diversos, mas nesse artigo vamos conhecer o FlowLayout, BorderLayout e GridLayout como apresentado abaixo.

FlowLayout

Ocorre quando os componentes GUI são colocados em um contêiner da esquerda para a direita na ordem em que são adicionados no contêiner. Quando a borda do contêiner é alcançada, os componentes continuarão a ser exibidos na próxima linha. A classe FlowLayout permite aos componentes GUI ser alinhados à esquerda, centralizados (padrão) e alinhados à direita.

Na Listagem 1 a classe está criando e adicionando 3 objetos Jbutton ao aplicativo. Os componentes ficam centralizados por padrão. A ação desse aplicativo será relacionada aos botões. Quando o usuário clicar no botão “Direita” o alinhamento do gerenciador muda para um FlowLayout à direita e assim acontece com os outros botões quando clicado, cada um com seu alinhamento.

Cada botão tem seu próprio handler de evento que é declarado com um uma classe interna anônima que implementa ActionListener.

Listagem 1: Classe com as funções FlowLayout

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class FlowLayoutFrame extends JFrame {

	private JButton botaoEsquerdo;	//BOTÃO PARA CONFIGURAR O ALINHAMENTO À ESQUERDA
	private JButton botaoDireito;	//BOTÃO PARA CONFIGURAR O ALINHAMENTO À DIREITA
	private JButton botaoCentral;	//BOTÃO PARA CONFIGURAR O ALINHAMENTO CENTRALIZADO
	private FlowLayout layout;		//OBJETO LAYOUT
	private Container container;	//CONTÊINER PARA CONFIGURAR LAYOUT
	
	//CONFIGURA GUI E REGISTRA LISTENERS DE BOTÃO
	public FlowLayoutFrame()
	{
		super("Demonstração de um FlowLayout");
		
		layout = new FlowLayout();		//CRIA FLOWLAYOUT
		container = getContentPane();	//OBTÊM CONTEINER PARA LAYOUT
		
		setLayout(layout);	//CONFIGURA O LAYOUT DE FRAME
		
		//CONFIGURA LEFTBUTTON E REGISTRA LISTENER
		botaoEsquerdo = new JButton("Esquerda");	//CRIA O BOTÃO LEFT
		add(botaoEsquerdo);		//ADICIONA O BOTÃO ESQUERDO AO FRAME
		
		botaoEsquerdo.addActionListener(new ActionListener() {
			
				@Override
				//PROCESSA O EVENTO BOTÃO ESQUERDO
				public void actionPerformed(ActionEvent e) {
					layout.setAlignment(FlowLayout.LEFT);
					
					//REALINHA OS COMPONENTES ANEXADOS
					layout.layoutContainer(container);
				}
			}
		);
		
		//CONFIGURA O BOTÃO CENTRAL E REGISTRA O LISTENER
		botaoCentral = new JButton("Centro");	//CRIA P BOTÃO CENTRAL
		add(botaoCentral);	//ADICIONO O BOTÃO AO FRAME
		
		botaoCentral.addActionListener(new ActionListener() {
			
				@Overri

Interface Collection

É a interface absoluta na hierarquia de coleções. Dela descendem as interfaces Set, Queue (filas) e List (listas) que formam a base das coleções genéricas da linguagem Java.

• Set – define uma coleção que não contém valores duplicados.
• Queue – define uma coleção que representa uma fila, ou seja, implementa o modelo FIFO (First-In, First-Out)
• List - define uma coleção ordenada que pode conter elementos duplicados.

As classes e interfaces dessa estrutura de coleções são membros do pacote java.util.

Figura 1: Estrutura das coleções e mapas

Declarando uma coleção

Figura 2: Declaração interface Collection

No exemplo da Listagem 1, estamos declarando uma variável chamada colecao que somente irá armazenar tipos String nesse espaço. Nesse exemplo estamos instanciando a classe que implementa a interface, como descrito no diagrama da Figura 1.

Listagem 1: Declaração de Collections

Collection<String> colecao = new ArrayList();

Apenas lembrando que tanto para declarar List como Collection será necessário importar os seguintes pacotes: java.util.ArrayList e java.util.Collection.

Veja agora alguns métodos da interface List implementados pela classe ArrayList.

Para adicionar o elemento é invocado o método add que aceita um argumento do tipo definido, como mostrado na Listagem 2. Cada vez que invocamos esse método para a mesma coleção é adicionado um valor no fim da lista.

Listagem 2: Adiciona valores

import java.util.Collection; 
import java.util.ArrayList;

public class MetodoAdd {
	public static void main(String[] args) {	
		Collection<String> nomes = new ArrayList();
		nomes.add("João");
		nomes.add("Maria");
		nomes.add("Eduardo");
		nomes.add("Silvana");
		nomes.add("Mário");
		
		System.out.println(“Lista de nomes: ”+nomes);
	}
}

Verifica se os dados dentro de um List estão vazios, tendo como retorno valor booleano, true ou false.

Listagem 3: Verificando a existência de valores

import java.util.Collection; 
import java.util.ArrayList;

public class Metodo_isEmpty {
	public static void main(String[] args) {
		Collection<String> letras = new ArrayList();
		letras.add("A");
		letras.add("B");
		letras.add("C");
		letras.add("D");
		letras.add("E");
		letras.add("F");
				
		if(letras.isEmpt

Sobre VisuAlg

É uma ferramenta na qual pode-se simular pseudocódigos, podemos dizer que é a interpretação de uma linguagem algorítmica, utilizando comandos e instruções em Português para representar as ações dos algoritmos, também conhecida como Portugol ou Português Estruturado.

O Portugol é uma versão portuguesa dos pseudocódigos que são realizados nos exemplos dos livros de introdução à programação ou lógica.

Instalação VisuAlg

Primeiramente devemos baixar o programa no link abaixo e seguir os passos demonstrados neste artigo.

http://www.baixaki.com.br/download/visualg.htm

Após baixar o arquivo execute-o.

Figura 1: Tela de apresentação clique em “Avançar”

Figura 2: Caminho da instalação – clique em Avançar

Figura 3: Instalação de Componentes – clique em Avançar

Figura 4: Nome do grupo, pode editar ou deixar padrão – clique em Avançar

Figura 5: Tarefas Adicionais – clique em Avançar

Figura 6: Confirmação das configurações – clique em Instalar

Figura 7: Conclusão da Instalação – clique em Concluir

A Tela Principal

Figura 8: Tela Principal do VisuAlg

Barra de Tarefas Padrão

Local onde tem os comandos mais utilizados, sendo possível acessá-los pelo menu ou pelos atalhos do teclado.

Figura 9: Barra de Tarefas

Teclas de Atalho

Abrir (Ctrl-A): Abre um arquivo anteriormente gravado, substituindo o texto presente no editor.

Novo (Ctrl-N): Cria um novo "esqueleto", substituindo o texto presente no editor.

Salvar (Ctrl-S): Grava o texto presente no editor, na primeira vez que um novo texto é gravado, é requisitado um nome e a localização para salvar o arquivo.

Imprimir(Ctrl+P): Imprime na impressora padrão o texto presente no editor. Para configurar a impressão, use o comando Imprimir do menu.

Cortar (Ctrl-X): Apaga texto selecionado, armazenando-o em uma área de transferência.

Copiar (Ctrl-C): Copia o texto selecionado para a área de transferência.

Colar (Ctrl-V): Copia o texto da área de transferência para o local em que está o cursor.

Gravar bloco de texto: Permite a gravação em arquivo de um texto selecionado no editor. A extensão sugerida para o nome do arquivo é .inc.

Inserir bloco de texto: Permite a inserção do conteúdo de um arquivo. A extensão sugerida para o nome do arquivo é .inc.

Desfazer (Ctrl-Z): Desfaz último comando efetuado.

Refazer (Shift-Ctrl-Z): Refaz último comando desfeito.

Localizar (Ctrl-L): Localiza no texto presente no editor determinada palavra especificada.

Substituir (Ctrl-U): Localiza no texto presente no editor determinada palavra especificada, substituindo-a por outra.

Corrigir Indentação (Ctrl-G): Corrige automaticamente a identação (formatação) do pseudocódigo, tabulando.

Numerar linhas: Ativa ou desativa a exibição dos números das linhas na área à esquerda do editor. A linha e a coluna do editor em que o cursor está em um determinado momento também são mostradas na barra de status .

Mostrar variáveis modificadas: Ativa ou desativa a exibição da variável que está sendo modificada.

Restaurar tela inicial: Retorna a divisão da tela ao formato inicial, caso você tenha mudado o tamanho da área do editor de texto, quadro de variáveis ou simulador de saída.

Barra de Tarefas para desenvolvimento

Vamos apresentar os tipos Enum que, na linguagem Java, são usados para a criação de estruturas de dados organizados, podendo agrupar valores que tenham o mesmo sentido para dentro dessa estrutura.

Enum

São tipos de campos que consistem em um conjunto fixo de constantes (static final), sendo como uma lista de valores pré-definidos. Na linguagem de programação Java, pode ser definido um tipo de enumeração usando a palavra chave enum.

Todos os tipos enums implicitamente estendem a classe java.lang.Enum, sendo que o Java não suporta herança múltipla, não podendo estender nenhuma outra classe.

Características

Em relação às propriedades é preciso tomar os seguintes cuidados:

• As instâncias dos tipos enum são criadas e nomeadas junto com a declaração da classe, sendo fixas e imutáveis (o valor é fixo).;
• Não é permitido criar novas instâncias com a palavra chave new;
• O construtor é declarado private, embora não precise de modificador private explícito;
• Seguindo a convenção, por serem objetos constantes e imutáveis (static final), os nomes declarados recebem todas as letras em MAIÚSCULAS;
• As instâncias dos tipos enum devem obrigatoriamente ter apenas um nome;
• Opcionalmente, a declaração da classe pode incluir variáveis de instância, construtor, métodos de instância, de classe, etc.

Declaração Enum

Na declaração é definida uma classe chamada de tipo enum. O corpo da classe enum pode incluir métodos e outros campos. O compilador automaticamente adiciona alguns métodos especiais quando se cria um enum.

Listagem 1: Declaração Enum (sempre definir como letras maiúsculas).

public enum Cartas {
       A, J, Q, K;
} 

Inicializando valores

Para iniciar os valores declarados dentro das variáveis Enum, é preciso declarar um construtor para iniciar os seus atributos que são declarados.

Listagem 2: Declarar valor Enum

public enum CartasEnum {
	J(11),Q(12),K(13),A(14);

	public int valorCarta;
	CartasEnum(int valor) {
		valorCarta = valor;
	}
}

Como mostrado na Listagem 2 inicializamos o construtor com apenas um argumento, o que corresponde ao mesmo número de argumentos declarados nos atributos. Pode ser possível declarar com mais argumentos, basta declarar suas variáveis com seus tipos e inicializar dentro do construtor.