Tecnoclasta » Aula CPWJ

Documentos de Padrões Web em Português.

Prof. Luis Eduardo — Tue, 11 May 2010 19:31:18 +0000

Esta é especial para meus alunos: acabou a desculpa para não seguir os padrões web à risca! Está disponível nesta página a lista completa dos principais documentos de padronização do W3C na nossa língua!
Dois dos documentos que acho imprescindíveis estão lá:

Tradução dos Documentos do W3C

Só faltou mesmo a especificação do CSS.

Observe lá no documento que a vários deles foram traduzidos por Maurício Samy Silva, autor e editor do site Maujor.com já indicado por aqui várias vezes.

Fuçando mais acabei encontrando também alguns documentos publicados pelo escritório brasileiro do W3C: http://www.w3c.br/divulgacao /. Neste encontramos um guia de referência CSS e outro HTML.

Espero que ajude os alunos com dificuldades em Inglês.

Fonte: http://revolucao.etc.br/archives/documentos-da-w3c-em-portugues

Artigos Similares:

Encerrando o Curso de Programação para Web em Java.

Prof. Luis Eduardo — Thu, 13 Mar 2008 14:46:53 +0000

Pois é senhores, esta é a última aula do curso de programação para Web em java.

Quem chegou agora, o curso pode ser feito, basta fazer as aulas a partir da primeira aqui.

Foram 5 meses de curso e nada menos que 21 mil acessos. Espero realmente que todos tenham aprendido alguma coisa, e pelo menos encontrado o caminho das pedras para aprender mais a respeito.

Eu pretendia aprofundar mais alguns assuntos, porém não estou com disponibilidade para produzir um material com a qualidade que desejo. Portanto, as aulas que prometi, (por exemplo CRUD), estarão engavetadas no momento.

Para continuarmos mantendo o contato estou preparando uma nova categoria de artigos, com dicas rápidas para programadores em geral. Devido a minha experiência Java e Asp.Net, estes serão assuntos constantes. Estou aceitando sugestões de dicas, ou de assuntos a serem tratados.

Estou preparando também um roteiro com material bibliográfico que utilizei para o desenvolvimento do curso.

Para aqueles que queiram deixar uma palavra final sobre curso, escrevam nos comentários deste artigo.

Quanto ao projeto de um curso nos moldes deste, mas sobre Asp.Net, estou estudando… ainda não é certeza. Existe interesse?

Atualizando

O curso de Asp.net já foi publicado, procure aqui.

Artigos Similares:

Aula 17: Hibernate e Camada Model

Prof. Luis Eduardo — Fri, 07 Mar 2008 21:54:57 +0000

Sejam bem vindos, esta é a décima sétima aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ

Depois que vimos uma aplicação funcionando, vamos agora detalhar cada parte do processo. Nosso estudo de caso será o sistema de busca, porém iremos incrementá-lo significativamente.

Esta aula está sendo postada com atraso, devido a problemas que tive para publicar o código java no WordPress. Depois de várias tentativas, decidi colocar os arquivos *.java e os *.xml em um diretório do servidor para que você possam baixar.

Voltemos à aula

Comecemos estudando a camada Model, ou modelo: O objetivo desta camada é definir as entidades envolvidas e as regras de negócio do programa. Em orientação a objeto, não nos preocupamos inicialmente com a interface do programa, mas sim de um modelo de representação das entidades que fazem parte do projeto. Uma abordagem pedagógica para atacar o problema é escrever de início um lista de requisitos do sistema, discutindo o que ele precisará ter:

Permitir o usuário digitar uma palavra chave e obter uma lista de sites que possuem relação com a palavra digitada usando o motor de busca;
Permitir um usuário cadastrar um ou mais sites definindo uma lista limitada de palavras chaves relacionadas com seu site;
Permitir um administrador do sistema corrigir, adicionar ou eliminar algum site cadastrado no sistema;

Esta será a lista de requisitos que usaremos no nosso exemplo. Para construir o modelo devemos olhar esta lista e identificar as entidades necessárias. Uma abordagem é olhar os substantivos. Estes serão entidades candidatas:

usuário, palavra chave, lista de sites, site, lista de palavras chaves, administrador, sistema de busca, cadastro Esta é uma lista preliminar, já eliminando repetições. O passo seguinte é separar o que é atributo, do que é classe, ficando somente as classes:

Usuário (administrador é um tipo de usuário especial)
Site (Lista de palavras chave é um atributo do site. Lista de Sites é uma coleção de sites)
Motor de busca
Cadastro de Sites

Depois disso iremos definir quais atributos são importantes para estas classes funcionarem de acordo com os requisitos.

Usuário: Id, Nome, Apelido, Senha, Email, Nível
Site: Id, Nome, Descrição, Url, KeyWords, Responsável (pelo cadastro)
Motor de Busca: Resultado da Busca, KeyWords (a serem encontrados)
Cadastro de Sites: Usuário responsável

Implementamos então as classes de modo que sejam manipuláveis pelo Hibernate. Este framework é responsável pela persistência, isso é, pelo armazenamento dos objetos criados na memória, para o banco de dados relacional. As regras para que as classes sejam manipuláveis pelo Hibernate são os seguintes:

A classe deverá ser um Java Bean definindo os atributos como dados privados e com funções públicas Getters e Setters. (veja em wikipedia as regras de uma classe Java Bean);
A classe deverá ter um construtor sem parâmetros para permitir o Hibernate criar objetos;
Deve possuir uma chave primária: isso é um campo id que armazenará um valor único que será gerado pelo Hibernate. A funcão setID() é privada, pois somente o Hibernate deverá modificar o campo chave.
A classe Motor de Busca e cadastro de Site não será persistido. Já que não é necessário a manutenção da busca realizada entre as chamadas.

No nosso exemplo teremos uma nova classe Usuario:

Usuario.class

Observe no código que criei uma propriedade “sites” com um HashSet. Esta propriedade irá auxiliar durante a manutenção dos sites que um usuário possui.

private Set sites = new HashSet();

E criamos o arquivo Usuario.hbm.xml na pasta sbusca. Este arquivo indica ao Hibernate o funcionamento da persistência da classe Usuário criada:

Usuario.hbm.xml

Além disso devemos incluir ao arquivo hibernate.cfg.xml:

Após todas estas codificações teremos duas entidades: Usuário e Sites. Além delas vamos definir uma classe chamada MotorBusca, que fará a lógica mais importante do sistema, isto é, a busca em si. Não é nada complicado e seria possível fazer o código diretamente nos Actions do Struts, mas vamos abusar um pouco de orientação a objeto. Olhando este exemplo simples quem sabe em um trabalho mais complexo você não se intimide. A classe deverá ter: MotorBusca:

Propriedade keyword: String e método executar() com e sem parâmetro;

E o código da classe ficará:

MotorBusca.java

Já definimos nesta aula um modelo quase completo para o nosso sistema. Deixei para depois somente o Cadastro de Sites, pois para implementá-lo será necessário falarmos de um CRUD, também conhecida como tela de Cadastro. Iremos ter uma aula somente sobre isso, quando voltaremos para tornar completo o modelo.

Para que você possa verificar se a busca está funcionando, criei uma classe simples de teste:

TesteBusca.java

Por hoje é só.

Dúvidas? vá para o fórum

Artigos Similares:

Aula 16: Sistema de busca última parte: Jsp e Struts

Prof. Luis Eduardo — Mon, 25 Feb 2008 18:27:07 +0000

Sejam bem vindos, esta é a décima sexta aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ

Na última aula começamos a construir o sistema de busca. Configuramos o Hibernate para uso com o Netbeans. Esta primeira aplicação é para verem tudo funcionando junto. Depois irei destrinchar com detalhes cada parte do processo.

Camada Model

Hoje vamos terminar o sistema começando com a camada Model. A camada Model representa as entidades lógicas que precisamos para construir nossa aplicação. Para o funcionamento correto teremos a classe Sites, representando os sites armazenados no sistema, (isso já está pronto) e teremos também a classe MaquinaDeBusca.

A classe MaquinaDeBusca fará o trabalho pesado permitindo buscar uma lista de Sites de acordo com a palavra chave. Na verdade a classe de teste da última aula tem tudo que precisamos: A função “List buscaSites(String keyword)” realiza a busca dos itens com palavra chave igual ao parâmetro e devolve uma lista com os objetos que atendem a busca.

Camada View

A segunda camada que iremos trabalhar é a camada View. Vamos começar criando uma página JSP que apresenta um formulário para o preenchimento do usuário. Escolha “File/New File” no menu do Netbeans. Na janela “New File” selecione categoria “Web” tipo de arquivo “JSP” e clique em “Next”. Chame a página de “busca” e clique em “Finish”.

Para o formulário faremos algo bem simples:

<%@page contentType="text/html" pageEncoding="UTF-8"%>



  
  Sistema de Busca

Veja que o formulário chama a ação “buscar.do”. O que será esta ação definiremos pelo framework Struts. Já vamos chegar lá. Vamos também criar um página chamada resultado.jsp que permitirá ver a lista de Sites encontrados. Para funcionar vamos supor que temos uma variável de requisição com o resultado da busca:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@taglib uri="http://struts.apache.org/tags-html" prefix="html"%>
<%@taglib uri="http://struts.apache.org/tags-logic" prefix="logic"%>
<%@taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>



  
  Sistema de Busca


  
    
    
  
  
    Nenhum Ítem Encontrado
  
  
    
        
      
      Nome
      Descrição
      Url
      Palavras Chave
      
      
        ${site.nome}
        ${site.descricao}
        ${site.url}
        ${site.keyword}

Nome	Descrição	Url	Palavras Chave
${site.nome}	${site.descricao}	${site.url}	${site.keyword}

Os tags logic:empty e logic:iterate são bastante auto explicativos. São parte da biblioteca de componentes do Struts. Veja as linhas após o @page.

Camada Control

Agora só falta juntar todas as peças. Quem faz isso é a camada Control. E esta camada é implementada pelo framework Struts. Nós temos apenas que definir o que acontecerá em cada ação possível do usuário.

A única ação deste sistema que o usuário poderá executar é clicar em buscar no formulário de busca. Então vamos gerar um Ação Struts para tratar este evento.

Escolha novamente “File/New File” no menu do Netbeans e na janela “New File” escolha categoria “Struts”, tipo de arquivo “Struts Actions”. Clique em “Next” e digite o nome do Action como “buscarAction”, o package como “sbusca” e o action Path para “/buscar”. Clique em “Next” e desligue a opção “Use ActionForm Bean”. Clique em Finish.

Modifique a função “Execute” para determinar o que acontecerá ao clicar o botão Buscar:

public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
  MaquinaDeBusca mdb=new MaquinaDeBusca(); //Prepara um objeto do modelo
  String busca= request.getParameter("buscar"); //recupera o que o usuario digitou na caixa de texto
  List sites=(ArrayList) mdb.buscaSites(busca); //Usa o modelo para obter os sites que batem com a palavra chave digitada pelo usuário
  request.setAttribute("sites", sites); //armazena os sites encontrados para que a camada view (resposta.jsp) mostre a lista de sites encontrados
  return mapping.findForward(SUCCESS); //passa a ação para o struts
}

(incluir “import java.util.*;” junto aos outros imports)

Falta muito pouco. Abra o arquivo struts-config.xml em WEB-INF na aba Project. Este arquivo está a configuração da amarração das ações com a views.

Modifique a linha para:

Isso fará com que ao final da Action “BuscarAction” a página de resposta que irá para o usuário será a “resultado.jsp”.

Aproveite e defina a página padrão modificando a linha para:

Pronto, basta executar a aplicação e terá o sistema funcionando! (tecla F6 ou menu Run/Run Main Project)

Sei que vão pintar milhares de dúvidas, porém estou aqui para esclarecer. (no fórum).

Na próxima aula vamos detalhar cada parte do processo, começando com um longo artigo sobre a camada Model.

Artigos Similares:

Aula 15: Oracle e Hibernate, fazendo uma busca

Prof. Luis Eduardo — Tue, 19 Feb 2008 11:55:21 +0000

Sejam bem vindos, esta é a décima quinta aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ

Vamos construir uma aplicação de verdade usando Java e Web e o modelo MVC. Já sabemos lidar com java, xhtml e css e um pouco de teoria sobre o MVC. Vamos colocar tudo pra funcionar?

Definindo o que será nosso primeiro programa: um sistema de busca. Vamos começar com um formulário simples com uma caixa de texto e um botão buscar, que quando clicado leva a outra página com a lista de sites com a palavra chave procurada.

Eu prometi que o conteúdo seria apresentado com o banco de dados mysql, porém tive uma seqüência de problemas com o hibernate mais mysql. Não quiz perder tempo com os detalhes. Eu não trabalho com o mysql, mas com o Oracle. Acredito que vocês possam encontrar material sobre o uso do mysql e hibernate, porém eu estou com pressa para publicar logo este material e como tenho experiência com Oracle é com ele mesmo que vou continuar. A forma de trabalho é a mesma, mudando apenas o xml de conexão com o banco.

Para uso do Oracle faça o download do Oracle 10g Express Edition em http://www.oracle.com/technology/software/products/database/index.html. É uma versão limitada mas de uso gratuíto. (Debian, Mandriva, Novell, Red Hat, Ubuntu e Windows compatíveis conforme o site Oracle).

Após o processo de instalação crie um usuário “sbusca” com senha “suasenha”.

É só o que você precisa na parte do banco de dados, o restante ficará por conta do Hibernate.

Para a configuração do ambiente do Netbeans 6.0, você precisa das seguintes arquivos de biblioteca:

para conectar no banco:
- classes12.jar
para o Hibernate:
- ant-antlr-1.6.5.jar
- asm-attrs.jar
- asm.jar
- cglib-2.1.3.jar
- commons-collections-2.1.1.jar
- commons-logging-1.0.4.jar
- dom4j-1.6.1.jar
- ehcache-1.2.3.jar
- hibernate3.jar
- jta.jar

O classes12.jar você encontra aqui mesmo:jdbc Oracle. As bibliotecas do Hibernate você encontra no site do Hibernate em http://www.hibernate.org/6.html. A opção de download do Core é suficiente. (hibernate3.jar está na raiz do zip e os outros no diretório lib)

Reserve os arquivos indicados acima, somente eles, em um diretório qualquer de sua máquina.

Abra agora o Netbeans e vamos começar a fazer a mágica. Após o processo de carga escolha o opção File/New Project…

Escolha a Categoria Web e o tipo de projeto Web Application conforme a figura abaixo:

Clique em Next e digite o nome do projeto e se quiser escolha outra localização para a pasta do projeto. O restante pode deixar como indicado na tela:

Clique em Next e ative a biblioteca do Struts conforme a figura:

Clicando em Finish o projeto estará criado.

Vamos instalar as bibliotecas hibernate e do oracle para uso no nosso projeto. Na aba Projects use o botão direito sobre o nome do projeto (sbusca) e clique em properties. Na janela “Project Properties – sbusca” clique em libraries nas Categorias e no botão “Add JAR/Folder”. Selecione todos os arquivos do diretório que você colocou os arquivos jar e confirme clicando em “OK”.

Criado o projeto e definido as bibliotecas que vamos utilizar, o próximo passo é o Hibernate. Esta biblioteca auxilia no acesso ao Banco de Dados. Implementa a persistência aos objetos, fazendo a ponte objeto/relacional.

Vamos configurar o Hibernate para conexão com o Oracle. Para isso vamos escrever um arquivo de configuração XML. Clique com o botão direito do mouse sobre “Source Package” na aba do projeto e escolha a opção “New/ XML Document”. Digite o nome do arquivo como “hibernate.cfg.xml” (xml é automaticamente preenchido digite somente hibernate.cfg). Clique em “Next” e “Finish”.

Digite ou copie o código de configuração da conexão com o Oracle: (sempre cuidado com as aspas em códigos fonte, o WordPress detona lembra-se?)






oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@10.89.9.6:1521:orabkl
SBUSCA
suasenha

1


org.hibernate.dialect.Oracle9Dialect

thread

org.hibernate.cache.NoCacheProvider

true


create

Para facilitar a codificação com o Hibernate vamos criar uma classe para a conexão e desconexão do banco de dados. Clique com o botão direito do mouse sobre “Source Package” na aba do projeto e escolha a opção “New\java class”. Chame a classe de “HibernateUtil” e defina o package como “util”:

Clique em finish e copie o código da classe:

package util;
import org.hibernate.*;
import org.hibernate.cfg.*;
public class HibernateUtil {
  private static final SessionFactory sessionFactory;
  static {
    try {
      // Create the SessionFactory from hibernate.cfg.xml
      sessionFactory = new Configuration().configure().buildSessionFactory();
    } catch (Throwable ex) {
      // Make sure you log the exception, as it might be swallowed
      System.err.println("Initial SessionFactory creation failed." + ex);
      throw new ExceptionInInitializerError(ex);
    }
  }
  public static SessionFactory getSessionFactory() {
    return sessionFactory;
  }
}

Com a biblioteca carregada e as configurações do hibernate certas, vamos codificar uma classe Sites para representar um dado persistente. Clique em File/New File e escolha Categoria “java” e “File Types” igual a “Java Class”:

Clique em “Next” e defina o nome da classe como Sites e o package como sbusca:

Clicando em “Finish” o Netbeans irá abrir a página com o código da Classe. Complete o código da classe criando os campos necessários:

package sbusca;
public class Sites {
  private Long id;
  private String nome;
  private String url;
  private String descricao;
  private String keyword;
  public Sites() {}
  public Long getId() {
    return id;
  }
  private void setId(Long id) {
    this.id = id;
  }
  public String getNome() {
    return nome;
  }
  public void setNome(String nome) {
    this.nome = nome;
  }
  public String getUrl() {
    return url;
  }
  public void setUrl(String url) {
    this.url = url;
  }
  public String getDescricao() {
    return descricao;
  }
  public void setDescricao(String descricao) {
    this.descricao = descricao;
  }
  public String getKeyword() {
    return keyword;
  }
  public void setKeyword(String keyword) {
    this.keyword = keyword;
  }
}

Para o funcionamento perfeito do Hibernate são necessários alguns detalhes:

Um campo Id para ser usado como campo chave automático;
Funções Get e Set públicos para manipulação dos dados privados;

Após a criação da classe é necessário definir um arquivo de mapeamento Hibernate. Com o botão direito do mouse sobre “sbusca” em destaque na figura, escolha a opção “new” e “others”.

Na janela “New File” escolha a categoria “XML” e “File Type” “Xml Document”. Clique em “Next” e defina o nome do arquivo como “Sites.hbm.xml” (a extensão xml é automaticamente inserida). Clique em “Next” e por fim em “Finish”. Copie o código abaixo para realizar a amarração:

Para verificar se tudo funcionou até aqui, vamos criar uma classe para ver se o hibernate está conseguindo criar os registros: (espero que já saiba como criar a classe depois de eu repetir mais de uma vez a seqüencia de teclas!)

package sbusca;
import org.hibernate.Session;
import util.HibernateUtil;
public class MaquinaDeBusca {
  public static void main(String[] args) {
    MaquinaDeBusca mgr = new MaquinaDeBusca();
    mgr.createAndStoreEvent("Tecnoclasta","http://www.tecnoclasta.com","Detonanto Tecnologia","java, tecnologia, astronáutica, astronomia");
    mgr.createAndStoreEvent("Uol Universo On-line","http://www.uol.com.br/","Universo On-line - O maior portal em língua portuguesa","portal, uol, sites, notícias");
    mgr.createAndStoreEvent("Portal Terra","http://www.terra.com.br/","Qual a sua Terra","portal, terra, notícias, sites");
    mgr.createAndStoreEvent("Folha de São Paulo","http://www.folha.uol.com.br/","O Jornal com Credibilidade","jornal, folha, notícias");
    HibernateUtil.getSessionFactory().close();
  }
  private void createAndStoreEvent(String nome, String url, String descricao, String keyword) {
    Session session = HibernateUtil.getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Sites umSite = new Sites();
    umSite.setNome(nome);
    umSite.setDescricao(descricao);
    umSite.setUrl(url);
    umSite.setKeyword(keyword);
    session.save(umSite);
    session.getTransaction().commit();
  }
}

Executando esta classe o NetBeans vai trabalhar um bocado, e no fim do processo tudo deverá funcionar. Veja você mesmo se foi criada a tabela e se os registros foram criados corretamente.

Observe que o hibernate elimina toda a necessidade de codificação em SQL. Isso facilita muito a manutenção e mesmo portar o sistema para um banco de dados diferente.

Um segundo teste do hibernate consiste em executar uma consulta. Mude a função main para esta, inclua uma nova função “buscaSites()” e execute a classe novamente:

public static void main(String[] args) {
  MaquinaDeBusca mgr = new MaquinaDeBusca();
  //String teste="store";
  String teste = "list";
  if (teste.equals("store")) {
    mgr.createAndStoreEvent("Tecnoclasta", "http://www.tecnoclasta.com", "Detonanto Tecnologia", "java, tecnologia, astronáutica, astronomia");
    mgr.createAndStoreEvent("Uol Universo On-line", "http://www.uol.com.br", "Universo On-line - O maior portal em língua portuguesa", "portal, uol, sites, notícias");
    mgr.createAndStoreEvent("Portal Terra", "http://www.terra.com.br", "Qual a sua Terra", "portal, terra, notícias, sites");
    mgr.createAndStoreEvent("Folha de São Paulo", "http://www.folha.uol.com.br", "O Jornal com Credibilidade", "jornal, folha, notícias");
  } else if (teste.equals("list")) {
    List sites = mgr.buscaSites("notícias");
    for (int i = 0; i < sites.size(); i++) {
      Sites umSite = (Sites) sites.get(i);
      System.out.println("Site: " + umSite.getNome() +": " + umSite.getDescricao()+ ", Url:"+umSite.getUrl());
    }
  }
  HibernateUtil.getSessionFactory().close();
} //fim da função main
public List buscaSites(String keyword) {
  Session session = HibernateUtil.getSessionFactory().getCurrentSession();
  session.beginTransaction();
  List result = session.createQuery("from Sites where keyword like '"+ keyword+"'").list();
  session.getTransaction().commit();
  return result;
}

Dando certo será listado os sites da Uol, Terra e Folha.

Pensei em fazer isso em uma aula só, porém está ficando muito, muito longo. Então fica aqui a primeira parte do sistema de busca. Na próxima aula terminamos.

Dúvidas? vá para o fórum.

Artigos Similares:

Aula 14: O modelo MVC

Prof. Luis Eduardo — Thu, 14 Feb 2008 10:54:40 +0000

Sejam bem vindos, esta é a décima quarta aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Até a última aula de HTML e CSS descobrimos como preparar uma página para publicação na Internet. Porém estas página preparadas assim tem um problema: são estáticas. Uma vez escritas e copiadas para o servidor, permanecerão exatamente iguais em todos os detalhes.

Com o conteúdo de Java aprendemos como construir programas. Vamos juntar as duas coisas agora.

JSP é uma sigla para Java Server Pages, e é uma tecnologia desenvolvida pela Sun para permitir o uso do Java para produzir páginas dinâmicas na Web. É utilizada em conjunto com classes Java com regras específicas para atendimento a requisições dos usuários. Estas classes são os Servlets.

Revisando como funciona a Web

O cliente faz uma requisição através do navegador quando:

Digita um endereço na barra de endereço e envia;
Clica em um botão de envio de um formulário;
Modifica um dado em um formulário com código javascript relacionado;

Na ação do usuário esta requisição é enviada pela Internet (ou Intranet) até o servidor de Web e este faz uma série de ações:

Interpreta a requisição
Procura na pasta root o arquivo HTML pedido
Envia o arquivo de volta ao navegador do cliente

Por fim o navegador do cliente interpreta o código Html, css e “desenha” o resultado.

Páginas dinâmicas

Com as páginas dinâmicas a diferença está nas ações do servidor de WEB:

Interpreta a requisição e detectando um pedido para página dinâmica:
Aciona uma classe Servlet
A classe Servlet interpreta qual ação foi requisitada e aciona as classes adequadas
Após a execução das ações, é chamada a página JSP para preparar a resposta visuais à requisição. As páginas JSP possuem código para produção de uma página HTML ad-roc, isto é sob demanda.
O Servidor envia para o navegador cliente a página de resposta gerada

Observe que temos duas camadas de código para produção de uma página dinâmica: os Servlets e o JSP. Um modelo mais completo utiliza três camadas e é chamada MVC Model-View-Control. Vamos ver cada uma destas camadas:

Model

A camada Model (modelo) possui a representação das informações do programa. No nosso exemplo, esta camada irá implementar classes para representar as entidades envolvidas no programa. Por exemplo em um programa de frente de caixa, haveria classes para representar produtos, compras, notas fiscais, itens de notas fiscais, métodos de pagamento. Estas classes iriam também armazenar todas as ações que eventualmente o usuários necessitasse realizar sobre estas entidades. Normalmente as classes utilizam um sistema de banco de dados para fazer o armazenamento persistente. Utilizaremos a biblioteca Hibernate para facilitar a persistência dos dados. Iremos utilizar o banco de dados Mysql para os exemplos

View

A camada View (visão) é responsável por construir uma interface para interação do usuário. Ela prepara a apresentação da informação para que o usuário possa reagir as respostas e continuar utilizando o programa. Em Java utilizaremos páginas JSP com Jstl para produzir as páginas de resposta. Observe que a camada View não acessa diretamente o banco de dados, ela recebe normalmente objetos Collection geradas pelas classes da camada Model e produz código HMTL a partir deles. Percebeu porque tivemos uma longa aula sobre coleções? (revise)

Control

A camada Control (controle) é a camada que controla o processo. Cada requisição do usuário é primeiro interpretado pela camada de controle que determina qual ação deve ser executada no modelo e encaminha depois a resposta do modelo para a camada de visão. No nosso exemplo quem irá fazer toda a camada de controle será o Struts.

Preparem-se, na próxima aula um sistema de busca completo será nosso primeiro programa!

Arrumem suas máquinas:

Instalar Netbeans 6
Instalar o Mysql
Baixar o Driver jdbc do MySql
Baixar o Hibernate

Dúvidas? vá para o fórum.

Artigos Similares:

Atraso na Aula do Curso Java e novidades

Prof. Luis Eduardo — Thu, 14 Feb 2008 09:30:34 +0000

Os alunos do curso de programação web em Java não precisam se preocupar, apesar do atraso desde terça-feira, pretendo publicar a primeira aula de JSP entre hoje e amanhã. O motivo do atraso é uma boa notícia para alguns: estou preparando um material também de Asp.NET.

Uma mudança na grade curricular do curso que leciono na faculdade me fez rever os conteúdos ministrados e estou sendo obrigado a acertar o material para os alunos presenciais. As aulas começaram nesta segunda-feira e está sendo uma correria.

Se houver interesse, após as aulas de Java, eu até poderia passar alguma coisa de Asp.NET. Se manifestem se houver interesse.

Artigos Similares:

Aula 13: Exceções e tratamento de erros

Prof. Luis Eduardo — Wed, 30 Jan 2008 01:20:04 +0000

Sejam bem vindos, esta é a décima terceira aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Hoje a aula é bem curta e semana que vem é carnaval e teremos folga. Aproveite para adiantar nas aulas e conseguir acompanhar o ritmo. Vamos falar de Exceções ou tratamento de erros em Java.

O sistema de exceções do Java é uma ferramenta para ajudar os programadores a reportar e manipular erros.

Sempre que uma função chamada em um programa puder gerar uma exceção o programador é obrigado a tomar uma ação. Esta ação pode ser a captura e tratamento do erro, ou simplesmente o lançamento do erro para outra função tratar. Vamos ver primeiro como tratar o erro:

Exemplo de tratamento/captura de erro típico: (Exception Catch)

public float dividir(int a, int b) {
  Float resultado;
  float r=0;
  try {  // Bloco try delimita a porção de código que pode apresentar erro
    resultado = new Float(a / b);
    r=resultado.floatValue(); //divisão executada armazena resultado
  } catch (ArithmeticException e) { //bloco catch trata o tipo de exceção indicado
    return 0; //divisão por zero
  } catch (Exception x) { //são permitidos vários blocos catch, um para cada tipo de exceção.
    //Exception é usada para qualquer tipo de exceção não específica encontrada
    //tratar aqui outros erros
  } finally { // é executada após o tratamento das exceções ou quando nenhuma exceção
    //é gerada normalmente quando é liberado os recursos usados na função
    resultado = null;
    System.out.println(r);
  }
  // após a execução das exceções ou de todo o bloco try, o fluxo prossegue deste ponto
  return r;
}

Lançamento de Exceções (Exception throwing)

Neste caso a função lança exceções para a função chamadora, isso é, quem deverá capturar o erro e tratá-lo é uma função que usa esta função para funcionar. Em outras palavras, a função escrita não trata o erro, simplesmente avisa que o erro aconteceu e interrompe seu processamento.

Exemplo de lançamento de erro:

public class File {
  public File(String nomeArquivo) throws FileNotFoundException {
    ...
    if (arquivo não encontrado ) {
      throw new FileNotFoundException();
    }
  }
}

“throws FileNotFoundException” na linha de declaração da função, indica que nesta função este tipo de exceção poderá ocorrer. Isso obriga o programador que usar esta função a tratar esta exceção (ou lançar para outro nível novamente).

“throws new FileNotFoundException();” indica que uma exceção foi detectada e avisa a máquina Java a respeito.

E por hoje é só.

Na Seqüência

dia 5 de Fevereiro: Carnaval. (não esqueçam a camisinha moçada!)
dia 12 de Fevereiro: Introdução a Jsp.

Dúvidas? vá para o fórum.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.

Artigos Similares:

Aula 12: Coleções, Hashing e Comparadores

Prof. Luis Eduardo — Tue, 22 Jan 2008 21:25:42 +0000

Sejam bem vindos, esta é a décima segunda aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Estamos retornando hoje das férias e continuando a todo vapor com o curso. A partir de hoje fique atento, que as aulas voltarão todas as terças-feiras. O conteúdo de Java está no final, logo iremos começar nossa primeira aplicação Web com JSP.

Hoje iremos aprender alguns conceitos e técnicas para trabalhar com coleções.

Hashing

Hashing é uma maneira de identificar objetos com um número inteiro. Coisas iguais tem (ou deveriam ter) o mesmo número hash. Isso é extremamente útil para realização de comparações mais rápidas.

Em classes escritas por você mesmo, para isso funcionar corretamente, você deve sobrescrever a função .hashCode() e gerar seu próprio número hash.

A função .HashCode()

Esta função deve retornar um número inteiro. É definida na classe java.lang.Object e retorna altomaticamente um valor único para cada instância (para cada objeto).

Se sua classe tem comportamento diferente deste, você deve sobrescrever esta função.

As três premissas da função .HashCode() são:

O hashCode de um objeto não deve mudar se o valor de um objeto não mudar.
Dois objetos iguais DEVEM ter o mesmo hashCode
É desejável que dois objetos diferentes tenham hashCode distintos (sempre que isso for possível)

Exemplos de hashCode:

String scott = "Scotty";
String scott2 = "Scotty";
String corey = "Corey";
System.out.println(scott.hashCode());
System.out.println(scott2.hashCode());
System.out.println(corey.hashCode());  // => -1823897190, -1823897190, 65295514
Integer int1 = 123456789;
Integer int2 = 123456789;
System.out.println(int1.hashCode());
System.out.println(int2.hashCode()); // => 123456789, 123456789

Classe NomeCompleto

Para prosseguir iremos definir uma classe chamada NomeCompleto, que será utilizada nos exemplos do restante da aula:

public class NomeCompleto {
  public String nome;
  public String sobrenome;
  public NomeCompleto(String nome, String sobrenome) {
    this.nome = nome;
    this.sobrenome = sobrenome;
  }
  public String toString() {
    return nome + " " + sobrenome;
  }
  public boolean equals(Object o) {
    return (o instanceof NomeCompleto &&((NomeCompleto) o).nome.equals(this.nome) &&((NomeCompleto) o).sobrenome.equals(this.sobrenome));
  }
}

Vamos verificar se esta classe NomeCompleto está funcionando corretamente:

NomeCompleto maria = new NomeCompleto("Maria", "Lúcia");
NomeCompleto jose = new NomeCompleto("José", "Silva");
NomeCompleto jose2 = new NomeCompleto("José", "Silva");
System.out.println(maria.equals(jose));
System.out.println(jose.equals(jose2));
System.out.println(maria.hashCode());
System.out.println(jose.hashCode());
System.out.println(jose2.hashCode()); // ⇒ false, true, 6718604, 7122755, 14718739

Objetos são iguais, mas o hashCode não é. Precisamos arrumar esta classe.

Você não pretende usar a classe hashCode, portanto não precisa se preocupar com isso não é? ERRADO! Você precisa resolver isso porque irá ter problemas com listas e coleções. As classes que implementam as listas pressupõem que a função hashCode() funciona corretamente.

Aliás, estamos vendo hashCode no início desta aula, justamente para podermos usar listas na continuação, e lembrá-lo que antes de usar listas deve sobrescrever esta função.

O que deve fazer a função hashCode mesmo? Gerar um número inteiro único para objetos com conteúdo iguais, e diferentes para objetos de conteúdo diferente.

Possível implementação para o nosso exemplo:

public class NomeCompleto {
  ...
  public int hashCode() {
    return nome.hashCode() *23 + sobrenome.hashCode();
  }
}

Veja que as classes String já implementam hashCode corretamente. Usamos “*23″ para que José Maria seja diferente de Maria José. Faça testes e verifique que sem a multiplicação o hashCode gerado é o mesmo.

Tenha certeza que entendeu este tópico antes de prosseguir. Funções hashCode não implementadas ou com código errado irão provocar problemas estranhos no uso de coleções. Estes problemas poderão te deixar realmente confuso. Se tiver dúvidas nesta parte pergunte no fórum, ou nos comentários antes de continuar.

Coleções

Coleções são implementações da biblioteca java para executar:

Coleções de objetos
Ordenação de objetos
Estocagem de objetos
Recuperação e busca de objetos estocados

Para usar Coleções deve-se incluir a importação de java.util.* no topo de cada arquivo *.java:

package lab2;
import java.util.*;
public class UsandoColecoes {
  List lista = new ArrayList();
  ... //resto da classe
}

Sintaxe básica de uma coleção de NomeCompleto:

Adiciona um nome a lista: boolean add(NomeCompleto o);
Verifica se um objeto está na lista: boolean contains(Object o);
Remove um elemento da lista: boolean remove(NomeCompleto o);
Verifica quantos elementos tem na lista: int size();

Exemplo de uso:

List iapjava = new ArrayList();
iapjava.add(new NomeCompleto("Luis", "Lima");
iapjava.add(new NomeCompleto("José", "Silva");
System.out.println(iapjava.size()); // => 2
iapjava.remove(new NomeCompleto("José", "Silva");
System.out.println(iapjava.size());  // => 1
List iapruby = new ArrayList();
Iapruby.add(new NomeCompleto("Marcos", "Fontes"));
iapjava.addAll(iapruby);
System.out.println(iapjava.size()); // => 2

Coleções Genéricas

É permitido definir uma coleção que só armazene objetos de um determinado tipo como no exemplo acima. Porém também é permitido definirmos coleções genéricas que armazenam objetos de qualquer tipo.
Exemplo de coleções genéricas:

List untyped = new ArrayList();
List typed = new ArrayList();
Object obj = untyped.get(0);
String sillyString = (String) obj;
String smartString = typed.get(0);

As coleções não genéricas ou tipadas são mais práticas de manipular.

Recuperando todos os dados de uma lista:

Dado uma coleção de NomeCompleto chamada “colecaox” podemos usar duas ferramentas para recuperar cada item da coleção: Iterator e For each.

Iterator

Iterator it = colecaox.iterator();
while (it.hasNext) {
        NomeCompleto obj = it.next();
        // Fazer alguma coisa com cada objeto
}

for (NomeCompleto obj : colecaox) {
        // Fazer alguma coisa com cada objeto
}

Excluir objetos da lista enquanto se está recuperando os mesmo:

Não é permitido remover objetos de uma coleção enquanto a mesma está em um laço for-each. Para remover uma lista enquanto se está recuperando é necessário usar o Iterator:

Iterator it = colecaox.iterator();
while (it.hasNext) {
   NomeCompleto obj = it.next();
   it.remove(obj); // Veja que só se remove pelo Iterator não pela coleção: colecaox.remove(Obj);
}

Tipos de Coleção disponíveis:

Listas:
- ArrayList;
Conjunto: (set)
- HashSet
- TreeSet
Mapeamento (map)
- HashMap

Listas

ArrayList é uma lista de objetos ordenados, similar a um Array, porém sem tamanho pré-definido. A lista é ordenada de acordo com a ordem de inserção.

Definindo e inserindo itens na lista:

List strings = new ArrayList();
strings.add("one");
strings.add("two");
strings.add("three");
// strings = [ "one", "two", "three"]

Inserindo objetos em uma determinada posição

List strings = new ArrayList();
strings.add("one");
strings.add("three");
strings.add(1, "two");
// strings = [ "one", "two", "three"]

Recuperando objetos de uma determinada posição:

s.o.print(strings.get(0))   // => "one"
s.o.print(strings.indexOf("one")) // => 0

Conjuntos (set)

Coleção sem tamanho e sem ordem definida. Não é permitido duplicidade de objetos no conjunto.

Exemplo:

Set nomes = new HashSet();
nomes.add(new NomeCompleto("José", "Silva"));
nomes.add(new NomeCompleto("José", "Silva"));
System.out.println(names.size()); => 1

Regra de ouro para Conjuntos (set):
Um elemento do conjunto não pode mudar se isso poderá afetá-la a ponto de torná-lo igual a um outro objeto do conjunto. (ou a outro objeto a ser inserido no conjunto mesmo após a mudança)

Se não respeitar esta regra, pode se preparar para coisas realmente estranhas. De preferência sempre use objetos imutáveis com conjuntos.

Mapas (map)

Mapas são conjuntos de pares Chave/Valor. Para cada chave o mapa armazena um valor correspondente. Com o valor da chave a coleção map pode recuperar o valor previamente armazenado. Uma chave deve ser única, porém valores podem repetir.

É um serviço muito útil para armazenamento e posterior recuperação de dados com valor chave. Utilíssimo para uso com banco de dados relacionais. Iremos usar isso muito, então não deixe dúvidas a respeito

Mapas não implementam as funções add e contais, em seu lugar temos as seguintes funções:

boolean put(Foo chave, Bar valor);
boolean contaisKey(Foo chave);
boolean contaisvalue(Bar value);

(neste exemplos Foo e Bar são duas classes de qualquer tipo)

Exemplo de uso:

Map dns = new HashMap();
dns.put("scotty.mit.edu", "18.227.0.87");
System.out.println(dns.get("scotty.mit.edu"));
System.out.println(dns.containsKey("scotty.mit.edu"));
System.out.println(dns.containsValue("18.227.0.87"));
dns.remove("scotty.mit.edu");
System.out.println(dns.containsValue("18.227.0.87"));
// => "18.227.0.87", true, true, false

Outros métodos úteis em mapas (map):

keySet() – retorna um Set de todos as chaves
values() – retorna uma Collection de todos os valores (use ArrayList ou Set para armazená-lo)
entrySet() – returna um Set de pares “chave,valor”. Cada par é um objeto Map.Entry. Map.Entry suporta getKey, getValue, setValue ;

Comparação e Ordenação

Para uso das coleções ordenadas é preciso também definirmos a função compareTo nas classes que definirmos. Esta função é usada para decidir, entre dois objetos, qual é o maior ou se são iguais.

(a.compareTo(b)) deverá resultar em um número menor que zero se a < b, em zero se a = b e, finalmente, em um número maior que zero se a > b .

Exemplos de comparação:

Integer um = 1;
System.out.println(um.compareTo(3));
System.out.println(um.compareTo(-50));
String jose= "José";
System.out.println(jose.compareTo("Ana"));
System.out.println(jose.compareTo("Zé"));
// => -1 , 1, 4, -2

Veja que as classes String e Integer já implementam uma função compareTo corretamente. Nas classes definidas pelo programador esta função deverá ser definida corretamente. Mais a frente iremos definí-la para nosso exemplo NomeCompleto. Por enquanto vamos ver como usar compareTo com listas para ordenar alfabeticamente uma lista:

List nomes = new ArrayList();
nomes.add("Sailor");
nomes.add("Lula");
nomes.add("Bobby");
nomes.add("Santos");
nomes.add("Dell");
Collections.sort(nomes);
// nomes => [ "Bobby", "Dell", "Lula", "Sailor",  "Santos" ]

Interface Comparable

Podemos usar Colletions.sort com a lista acima porque Strings implementam Comparable. Isto é, Strings tem uma ordem natural. Para que uma classe NomeCompleto seja “Comparable”, você deve implementar:

int compareTo(NomeCompleto obj);

Exemplo:

public class NomeCompleto implements Comparable {
  ...
  public int compareTo(NomeCompleto o) {
    int compare = this.sobrenome.compareTo(o.sobrenome)
    if (compare != 0)
      return compare;
      else return this.nome.compareTo(o.nome);
  }
}

Usando a nova classe Comparable NomeCompleto:

List nomes = new ArrayList();
nomes.add(new NomeCompleto("Nicolas", "Cage"));
nomes.add(new NomeCompleto("Laura", "Dern"));
nomes.add(new NomeCompleto("Harry", "Stanton"));
nomes.add(new NomeCompleto("Diane", "Ladd"));
nomes.add(new NomeCompleto("William", "Morgan"));
nomes.add(new NomeCompleto("Dirty", "Glover"));
nomes.add(new NomeCompleto("Johnny", "Cage"));
nomes.add(new NomeCompleto("Metal", "Cage"));
System.out.println(nomes);
Collections.sort(nomes);
System.out.println(nomes);
// => [Johnny Cage, Metal Cage, Nicolas Cage, Laura Dern, Crispin Glover,
// Diane Ladd, William Morgan, Harry Stanton]

Objetos Comparadores (Comparator)

Para criar mais de um método de ordenação você deve definir classes Comparadoras. A classe comparadora simplesmente é uma classe com a implementação da função compateTo entre dois objetos:

int compare(Foo o1, Foo o2);

Exemplo de Comparador, ordenando primeiro nome primeiro:

public class PrimeiroNomePrimeiro implements
    Comparator {
    public int compare(Nome n1, Nome n2) {
      int ret = n1.nome.compareTo(n2.nome);
      if (ret != 0)
        return ret;
        else return n1.sobrenome.compareTo(n2.sobrenome);
    }
}

Isso deverá ser feito em arquivo separado do NomeCompleto.java: PrimeiroNomePrimeiro.java

Para usar o Comparador:

List nomes = new ArrayList();
...
Comparator primeiroNome = new PrimeiroNomePrimeiro();
Collections.sort(nomes, primeiroNome);
System.out.println(nomes);
// => [Crispin Glover, Diane Ladd, Harry Stanton, Johnny
// Cage, Laura Dern, Metal Cage, Nicolas Cage, William
// Morgan]

Outra maneira de ordenar é usando TreeSet. Isso faz a ordenação de maneira automática, sem precisar chamar a função sort. Para funcionar os objetos da TreeSet devem ser “Comparable” ou você deve definir uma classe Comparator.

SortedSet nomes = new TreeSet(new PrimeiroNomePrimeiro());
nomes.add(new NomeCompleto("Laura", "Dern"));
nomes.add(new NomeCompleto("Harry", "Stanton"));
nomes.add(new NomeCompleto("Diane", "Ladd"));
System.out.println(nomes);
// => [Diane Ladd, Harry Stanton, Laura Dern]

Aprofundando

Procurar e estudar na documentação do java as classes apresentadas nesta aula: (veja java.util.*) em http://java.sun.com/j2se/1.5.0/docs/api

Durante os próximos estudos de java é essencial manter este endereço aberto em uma janela do navegador, de modo a tirar dúvidas a respeito do funcionamento de alguma classe java.

Na Seqüência

dia 29 de janeiro: Exceções e outros truques

Dúvidas? vá para o fórum.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.

Artigos Similares:

Como aprender sozinho

Prof. Luis Eduardo — Tue, 18 Dec 2007 13:24:34 +0000

Verifiquei pelas estatísticas que muitos dos alunos do Curso de programação para Web em Java tem desistido de continuar o curso. Para estimular aqueles que tem dificuldades para levar um estudo auto ditada resolvei escrever algumas dicas a respeito. Porem encontrei na net um artigo bem interessante sobre isso. Aproveitem:

Autodidatismo direto do Sarcófago.

Artigos Similares:

Aula 11: Classes, Interfaces e Polimorfismo

Prof. Luis Eduardo — Tue, 18 Dec 2007 11:58:27 +0000

Sejam bem vindos, esta é a décima aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Hoje iremos aprofundar alguns conceitos de orientação a objeto .

Classes e Interfaces, Conceitos

Vamos começar com uma revisão de alguns conceitos já passados na última aula:

Classe: um modelo para um Objeto
Interface: uma especificação
Instância: um objeto de uma Classe ou Interface fisicamente representado na memória
Membros de uma Classe:
- Método: um conjunto sequencial de instruções
- Campo: variável associada com um objeto particular
- Campo estático: variável compartilada entre todos os objetos de uma classe.

Tipos de Dados

Existem dois tipos de dados em Java, os tipos primitivos e os tipos objetos.

Objetos

Usar a palavra chave “new” para criar um objeto. Este comando irá reservar espaço para um novo objeto na memória, chamar o construtor do objeto e retornar o endereço para o novo objeto.

Modelo de definição de uma Classe:

[acesso] [abstract/final] class NomeDaClasse
                        [extends NomeClassePai]
                        [implements NomeDaInterface...] {
                  //construtores
                  //métodos membros
                  //campos membros
}

Exemplo de Sintaxe

public class ContaBancaria {
	...
}

Membros das Classes

Ao escrever uma classe nós podemos definir os seguintes membros:

Construtores
Métodos e campos
Métodos e campos estáticos
Classes alinhadas

Vamos detalhar cada um dos membros, começando pelos Construtores.

Construtores

São os métodos chamados automaticamente na criação dos objetos. Deve ter o mesmo nome da classe que a possue. Tem o objetivo de realizar a inicialização de um objeto da classe.

Modelo de Construtor

[acesso] NomedaClasse ([argumentos...]) {
   //corpo do construtor
}

Exemplo de Sintaxe Construtor

public class ContaBancaria {
  public ContaBancaria(){ // veja que o nome do construtor é o mesmo da classe
		saldo=0;
  }
}

Exemplo de Sintaxe de Múltiplos Construtores

public class ContaBancaria {
	public ContaBancaria(){
		saldo=0;
	}
	public ContaBancaria(int saldoInicial){
		saldo=saldoInicial;
	}
}

Métodos

Métodos são usados para realizar funções modificando o estado dos objetos. Podem ter vários parâmetros, e retornar um único valor. Nos casos que não retornam valor deve ser utilizado a parlavra chave void.

Modelo de Método

[acesso] tipoRetorno nomeDoMétodo ([argumentos...]) {
    //corpo do método
}

Exemplo de Método

public class ContaBancaria {
	public int getSaldo(){
		return saldo;
	}
}

Sobrecarga de métodos

Uma classe pode possuir dois métodos com mesmo nome, desde que os seus argumentos sejam diferentes.

Por exemplo:

	int getSaldo() {...}
	int getSaldo(String tipo) {...}

Java reconhece qual método deverá executar verificando quantos e que tipos de parâmetros são apresentados na chamada.

Exemplo:

int x=minhaClasse.getSaldo(“total”); //chamará o segundo método.

Campos

Um campo é como uma variável e armazena um estado do objeto. É sempre relacionado a um tipo de dado que determina o que ele pode armazenar.

Modelo de Campo

[acesso] tipoDeDado nomeCampo [= valor];

Exemplos de Campos

public class ContaBancaria {
	public int saldo; // << campo
	public Date ultimaTransacao; // << campo
	public List transacoes; // << campo
}

Juntando tudo

public class ContaBancaria {
  private int saldo; // campo
  public ContaBancaria() {  //construtor
        saldo= 0;

  }
  public void retirada(int valor) {  //método
        saldo = saldo – valor;
  }
  public void deposito (int valor) {  //método
        	saldo = saldo + valor;
  }
}

Controle de Acesso

Para controlar o acesso aos dados membros temos 4 tipos de acesso direrentes que determinam que classes tem acesso:

public – qualquer outra classe
protected – somente subclasses
(default) – somente classes no mesmo pacote (package)
private – somente acessível por métodos da mesma classe

Estes níveis de acesso são usados para garantir a abstração e encapsulamento dos objetos.

Herança

É o mecanismo que permite uma classe herdar funcionalidades de outra classe, permitindo abstração de dados e procedimentos e diminuindo a complexidade de grandes sistemas de dados.

Usamos herança quando duas idéias tem diferentes comportamentos mas com funcionalidades sobrepostas:

ContaBancaria => ContaCorrente
ContaBancaria => ContaPoupanca

Interfaces

Uma interface é uma especificação de uma classe. Declara-se métodos, mas não os define. Não tem contrutores. O objetivo é expecificar um padrão de uso (interface) de um conjunto de classes diferentes.

Modelo de Interfaces

[acesso] interface NomeDaInterface
    [extends ListaDeNomeDeInterface...] {
      //declaração de métodos
}

Exemplo de Interface

public interface ContaBancaria {
  public void retirada (int valor);  //nenhum método é definido na interface, somende declarado

  public void deposito (int valor);
  public int getSaldo ();
}

Como utilizar uma Interface?

Uma vez definido uma interface, podemos escrever classes, ou mesmo outras interfaces que implementam (implement) ou extendam (extends) esta interface.

Quando uma classe implementa uma interface, esta classe deve possuir em seu corpo cada um dos métodos declarados desta interface. Se uma classe implementa mais de uma interface, ela deve possuir cada uma dos métodos de cada uma das interfaces que implementa.

Exemplo usando a Interface

public class ContaPoupanca implements ContaBancaria {
    private int saldo;
    public ContaPoupanca (int saldoinicial) {
         saldo= saldoinicial;
    }
    public void somaJuros(int juros){    //função particular de ContaPoupanca
	saldo=saldo+(saldo*(juros)/100);
    }
    //implementando métodos da interface ContaBancaria:
    public void retirada (int valor) {
         saldo= saldo – valor;
    }
    public void deposito (int valor) {
         saldo = saldo + valor;
    }
    public int getSaldo () {
         return saldo;
    }
}

Classes Abstratas

São uma mistura de interfaces e classes, podendo definir métodos e possuir campos. Porém podem apresentar métodos somente declarados, e não definidos.

A idéia é capturar o estado de uma idéia e também sua funcionalidade.

Exemplo de Classe Abstrata

public abstract class ContaBancaria {
   private int saldo; // campo
   public void retirada(int valor); //função não definida pela classe abstrata, porque difere de tipo de conta bancária para outra.
   public void deposito (int valor) {
        	saldo = saldo + valor;
   }
}

Exemplo extendendo uma Classe Abstrata

public class ContaCorrente extends ContaBancaria {
	public ContaCorrente(){
		saldo=0;
	}
	public void retirada(int valor){
		if((saldo-valor)<0) {
			throw new RuntimeException (“Insuficiencia de fundos”);
		} else {
			saldo=saldo-valor;
		}
	}
}

Exemplo de outro tipo de Conta Bancaria:

public class ContaCorrenteEspecial extends ContaBancaria {
	private limiteChequeEspecial;
	public ContaCorrenteEspecial(){
		saldo=0;
		limiteChequeEspecial=1000;
	}
	public void retirada(int valor){
		if((saldo-valor)
Polimorfismo
Consiste na capacidade de objetos de tipos diferentes responder a métodos de mesmo nome e tipo. Isso acontece quando usamos herança. A máquina virtual java automaticamente determina qual das funções devem ser executadas.
A classe Object
Quando uma classe não extende nenhuma outra classe, implicitamente ela extende a classe java.lang.Object. Esta é uma classe da biblioteca java que contém um conjunto de métodos que assim ficam disponíveis para qualquer classe que você definir. os principais métodos da classe Object são: clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString e wait.
Sobreposição de métodos (overriding)
Se uma classe A extende uma classe B, então B é a classe pai (superclass) de A. E, a classe A é uma classe filha (subclass) de B. Quando a classe pai possui um método definido, a classe filha pode ter um método com mesmo nome e tipo para modificar o comportamento do método da classe pai. Isso chama-se sobreposição (overriding).
Modificando um método da Superclass
A classe Object possui um método chamado equals que verifica se dois objetos são o mesmo, isto é, se duas variáveis estão apontando para o mesmo objeto. (revisem a última aula se não entenderam)
Porém em alguns tipos de objetos a noção de igualdade dá-se de maneira totalmente distinta. No nosso exemplo de conta bancária, igualdade poderia dizer que duas contas possuem o mesmo saldo. Graças ao polimorfismo e sobreposição é possível mudar o método equals para realizar exatamente esta verificação.
Usando o método equals padrão
ContaCorrente c1 = new ContaCorrente(100);
ContaCorrente c2 = new ContaCorrente(100);
c1.equals(c1); // verdadeiro
c2.equals(c2); // verdadeiro
c1.equals(c2); // falso, como são dois objetos a função equals retorna falso.
Modificando nossa função “equals”, usando overriding:
public class ContaCorrente extends ContaBancaria {
	...
	public boolean equals (Object aux){
		if(aux instanceof ContaCorrente){ //verifica se tipo de dado do parâmetro está correto
			ContaCorrente aux2 = (ContaBancaria) aux;
			return saldo == aux2.saldo; //retorna true se saldo igual
		} else {
			return false; //se tipo incorreto não é igual
		}
	}
	...
}
Usando nova função “equals”
ContaCorrente c1 = new ContaCorrente(100);
ContaCorrente c2 = new ContaCorrente(100);
c1.equals(c1); // verdadeiro
c2.equals(c2); // verdadeiro
c1.equals(c2); // verdadeiro, pois agora o que se compara é o saldo, não a posição do objeto
Usando variáveis do tipo Superclass
Variáveis de um tipo podem armazenar dados de tipos subclasses
Object o1 = new ContaCorrente(100); //Object é superclass de qualquer classe
Object o2 = new ContaCorrente(100);
Object é o tipo em tempo de Compilação (compile-time) e ContaCorrente é o tipo em tempo de execução (runtime).
Chamada de métodos em tempo de execução
Quando chamamos um método por uma variável do tipo superclass mas com um objeto subclass armazenado, o método executado será o do subclass. No nosso exemplo, chamar o método o1.equals(o2), iria chamar a função “equals” definida em ContaCorrente.
Isso acontece porque Java escolhe o método a ser chamado em tempo de execução e não em tempo de compilação.
Exemplo usando ContaCorrente e ContaCorrenteEspecial
ContaBancaria c1 = new ContaCorrente(10);
ContaBancaria c2 = new ContaCorrenteEspecial(10);
c1.retirada(12); //chamará ContaCorrente.retirada(int)  e causará uma exceção por insuficiência de saldo
c2.retirada(12); //chamará ContaCorrenteEspecial.retirada(int) e não apresentará problemas.
As vantagem de uso de tipos abstratos como demonstrado aqui é que os detalhes de implementação são mais simples de modificar sem mudanças nas classes que usam estes tipos abstratos.
Nas próxima aula iremos lidar com coleções e listas para fixar exatamente estes conceitos. Porém isso vai ser somente em 22 de janeiro, pois estou entrando em férias, e me reservei no direito de aproveitar os 20 primeiros dias do ano sem nenhuma preocupação. Estarei me casando no dia 12 de janeiro, e só vou voltar a este site quando voltar a trabalhar também na faculdade e na Sabesp.
Para quem acompanha os artigos astronômicos, só irei postar se for algo realmente extraordinário. Um abraço e boas férias.
Na Seqüência

dia 25 de dezembro: folga é Natal. Entraremos em recesso com o curso, estaremos de volta dia 22 de janeiro, ao final de minhas merecidas férias.
dia 22 de janeiro: Coleções, Hashing e Comparadores.

Dúvidas? vá para o fórum.
Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.
Artigos Similares:

Aula 11: Classes, Interfaces e Polimorfismo
Aula 10: Java Essencial
Aula 12: Coleções, Hashing e Comparadores
Aula 17: Hibernate e Camada Model
Aula 15: Oracle e Hibernate, fazendo uma busca

Aula 10: Java Essencial

Prof. Luis Eduardo — Wed, 12 Dec 2007 11:59:16 +0000

Sejam bem vindos, esta é a décima aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Na última aula fizemos uma introdução ao ambiente Java, incluindo a instalação do ambiente de desenvolvimento NetBeans. Hoje, vamos fazer uma viagem sobre a linguagem vendo o que ela tem de essencial.

Em minha opinião esta é a mais importante aula do curso até agora.

Java é uma linguagem Orientada a Objeto

A programação em java consiste em manipulação e criação de objetos.

Objeto

Em programação, objetos são representações computacionais de entidades reais, ou abstratas. Eles representas pessoas, entidades. Ou mesmo coisas mais ou menos abstratas, como uma música, ou uma conta bancária.

Todos objetos tem estados: uma pessoa tem nome, idade, Rg, etc. Uma música tem título, interprete, etc. Uma conta bancária tem seu saldo, seu número de identificação, titular da conta, etc.

Programadores podem chamar métodos ou ações no objeto para realizar computações que podem potencialmente modificar o estado do objeto:

Programador: Quantos anos você tem ? <
Objeto: Eu tenho 10. <
Programador: Hoje é seu aniversário! <
Objeto: Eu tenho que somar 1 à minha idade. <

Programador: Qual seu saldo?
Objeto Conta Bancária: Saldo igual a R$ 2940,00
Programador: Sacar 100 reais
Objeto: Eu tenho que atualizar o saldo para R$ 2840,00

Um programa em Java:

package ola;
import java.util.System;
class OlaMundo {
  String minhaString;
  void vaiLa() {
    minhaString = new String("Olá, Mundo!“);
    System.out.println(minhaString);
  }
  public static void main(String[] args) {
    AloMundo meuAloMundo = new AloMundo();
    meuAloMundo.vaiLa();
  }
}

Classes

Classes por sua vez são modelos para fazer Objetos. Programar em Java consiste em escrever classes. Todo o código de Java está dentro de classes.

class HelloWorld { //nome da classe
  ...  ...
}

Campos

Campos também chamados variáveis, são usadas para armazenar o estado do Objeto.

class Pessoa {
  int idade; // <<= variável ou campo
}
 ;

Construindo Objetos

Pessoa luis = new Pessoa();

Para a construção de um objeto usa-se o código “new” conforme o exemplo acima. Objetos são criados a partir de uma classe, são instâncias das classes. O código “new Pessoa()” cria um objeto na memória do computador, especificamente no Heap do Java.

No código acima luis é um ponteiro para o objeto. Isto é, o Objeto que foi criado é armazenado em uma área de memória do computador, a variável luis armazena o endereço desta posição de memória.

O código acima “luis = ” atribui o endereço do objeto na memória para a variável luis.

= new ();

Usando objetos

Depois de criado, um objeto pode ser usado assim:

Pessoa luis = new Pessoa();
luis.idade=33; //use "." para acessar os campos
Pessoa elaine = new Pessoa();
elaine.idade=32;
System.out.println(luis.idade); // imprime 33 na tela
System.out.println(elaine.idade); //imprime 32 na tela

Tipos Primitivos

Em Java nem tudo são objetos. Algumas coisas são tão simples, que não compensa usar objetos para representá-los: boolean, byte, short, int, long, double, float, char. São respectivamente tipo lógico, número, inteiro curto, inteiro, inteiro longo, número ponto flutuante duplo, ponto flutuante simples, caracter.

boolean: Um valor verdadeiro ou falso.
byte: Valor numérico inteiro com sinal de 8 bits
short: Valor numérico inteiro com sinal de 16 bits
char: Caracter unicode de 16 bits
int: Valor numérico inteiro com sinal de 32 bits
long: Valor numérico inteiro com sinal de 64 bits
float: Valor numérico de ponto flutuante padrão IEEE754 de 32 bits
double: Valor numérico de ponto flutuante padrão IEEE754 de 64 bits

Para armazenar texto, não usamos um tipo primitivo, temos uma classe String:
String nome=new String(“José das Couves”);

Métodos

São ações que podemos realizar sobre os objetos, que podem mudar seu estado.

() {

}

No exemplo AloMundo no inicio da aula temos dois métodos definidos: vaiLa e main:

meuAloMundo.vaiLa();
// use ‘.’ para acessar o método

Construtores

Construtores são tipos especiais de métodos que não retornam valores, usados para iniciar campos, aceitam parâmetros e tem corpo de método normal. Tem o mesmo nome da classe, inclusive iniciando com letra maiúscula:

class Pessoa{
  int idade;

  Pessoa(){ //início do contrutor
    idade=18; // ao criar um objeto do tipo Pessoa a idade será iniciada
                   // com 18 anos em todos os objetos;
    } //fim do construtor
}

Corpo do Método

String primeiroNome(String nomeCompleto) {
  int espaco = nomeCompleto.indexOf(“ ”); //posição onde está o espaço
  String palavra = nomeCompleto.substring(0, espaco);
  return palavra;
}

Pode-se definir qualquer número de parâmetros, separando por vírgula (no exemplo nomeCompleto). Pode-se declarar variáveis locais(espaco, palavra). Deve sempre retornar alguma coisa (String palavra). No caso de um método não necessitar retorno usa-se void no tipo de retorno (void=nada).

void seuAniversario(){ >>exemplo de método void para a classe Pessoa
  idade++;
}

Controle de Fluxo

O comando “if” permite controle sobre ações que devem ser realizadas de acordo com as situações do programa:

if(luis.idade<18){
  System.out.println("Proibido para menores");
} else if(luis.temCartaoCredito(){
  System.out.println("Seja bem vindo!");
} else {
  System.out.println("Sai fora, tá pensando que é de graça?");
}

if(condição 1){
…
} else if (condição2) {
…
} else if (condiçãoN) {
…
}else { … }

Condições

As condições do “if” são expressões que são booleanas, valem Verdadeiro ou Falso. Para construir usar os operadores:

< menor
> maior
== igual
<= menor ou igual
>= maior ou igual
! negação

Exemplos:

caixa.isVazia();
caixa.numeroLivros()==0
!(caixa.numeroLivros()>1) negação: número de livros na caixa NÃO é maior que 1)
caixa.numeroLivros!=MAX_NUMBER_BOOKS
caixa.numeroLivros%2==0 //verifica se o resto da divisão por 2 é zero (isso é, se o número de livros é par)

Repetição For (loops)

Repete um trecho de código, controlando por uma variável:

for (int i = 0; i < 3; i++) {
  System.out.println(i); // imprime 0 1 2
}

for ( ; ; ) {
…. // trecho de código que repete
}

Inicialização é executado uma única vez antes do trecho repetido. A condição é verificada após a inicialização e antes de repetir o trecho. Incremento é realizado todas as vezes após o trecho repetido.

Para de repetir quando a condição passa a ser falsa.

Repetição While

Repetição de um trecho de código enquanto (while) uma condição for verdadeira.

int i = 0;
while(i<3) {
  System.out.println(i); //imprime 0 1 2
  i++;
}

while () {
…
}

Combinando Condições

Quando temos mais de uma condição para testar usamos “&&”: E lógico ou “||”: OU lógico.

luis.idade>=18 && luis.temCartaoCredito()
alguem.nome.equals(“Luis”)||alguem.nome.equals(“Lima”)
(!true || false)&& true (resposta=false)

Matrizes ou arrays

Lista de objetos identificados com um único nome, mais números de ordem.

String[] animais = new String[2]; // dois objetos String
animais[0] = new String("Rex");
animais[1] = "Lulu"; // forma simples de criar String
String[] animais= new String[] {"Rex","Lulu"};
System.out.println(animais.length); // 2 ítens na matriz

Objetos wrapper dos tipos Primitivos

Os tipos primitivos em algumas situações são interessantes serem manipulados como objetos. A biblioteca Java possui classes que representam cada tipo de variável primitiva: Integer para int, Float para float, Double para double, Boolean para boolean, etc.

Usando os wrappers

Integer a= new Integer(3); // cria objeto Integer e inicia com valor 3;
Integer sum = a.add(5); // cria objeto Integer com o valor de a+5;

Wrappers em Arrays

Integer notas= new Integer[50]; // 50 objetos Integer

Cuidado ao usar Objetos

Não tentar acessar array fora de faixa
animais[5] >> excessão ArrayOutOfBoundsException;
Acessar variável sem criar objeto correspondente
String[] str;
str.length >> NullPointerException
Erros de interpretação de uso
Integer a = new Integer(3); //a=>3
a.add(5); //calcular a+5, não muda valor de a=>3
a=a.add(5); //agora sim: a=>8

Resumo

Variáveis
- Variáveis apontam para objetos;
- Variáveis apontam objetos de uma classe em particular;
- Integer x; Declara uma variável;
Objetos
- Classes definem objetos
- Objetos são instâncias de uma classe em particular;
- new Integer(3); Constrói um objeto;

Representação Objeto vs Variáveis

Um exemplo visual de objetos e variáveis durante a execução de um programa java:

Temos dois objetos da classe Integer com o valor 3 armazenado. E temos 4 variáveis: num, x, y e z. As variáveis num e x apontam para o mesmo objeto. A variável z não aponta para nenhum objeto.

Null

Variáveis sem objetos relacionados apontam para null. null não é um objeto, é apenas uma indicação para a não existência de objeto relacionado com uma variável.

Utilizar uma variável com valor Null para verificar um campo de um objeto irá causar um erro (NullPointerException):

Pessoa joao;
joao.idade=10; // NullPointerException, não existe objeto relacionado à variável joao, portanto não existe o campo idade.

Mudando um objeto através das variáveis

Para atribuir um objeto à uma variável, utilize o operador “=”. Com isso é possível fazer mais de uma variável apontar para o mesmo objeto. Este recurso pode provocar um efeito chamado mutação de objetos compartilhados:

public class MutationExample {
  public static void main(String[] args) {
    List a = new ArrayList();
    List b;
    b= a; // b e a compartilham a lista
    a.add(“Alo, Mundo!”);
    System.out.println(b); // imprime "Alô, Mundo!"
  }
}

No exemplo, a e b são variáveis apontando para a mesma lista. Usando “a.add(…” modificamos o objeto lista. Quando imprimimos “b”, a variável aponta para o mesmo objeto modificado, e portanto mostra o valor “Alô, Mundo!”.

Campos e Métodos Estáticos e Não estáticos

Campos e métodos também são chamados membros de uma classe. Por padrão são não estáticos.

Membros estáticos são aqueles que são compartilhados entre cada Instância/Objeto da classe.

Um campo estático, compartilha seu valor entre cada objeto da classe.

Campos não Estáticos

public class Livro {
  public int livroCounter = 0;
  public Livro() {
    livroCounter++;
  }
  public static void main(String[] args) {
    new Livro(); new Livro();
    Livro biblia = new Livro();
    System.out.println(biblia.livroCounter); // Imprime 1
  }
}

Campos Estáticos

public class Livro {
  public static int livroCounter = 0; // <<== campo estático
  public Livro() {
    livroCounter++;
  }
  public static void main(String[] args) {
    new Livro(); new Livro(); new Livro();
    System.out.println(Livro.livroCounter); // Imprime “3”: observe Livro se refere à classe
  }
}

Campos Estáticos devem ser chamados a partir do nome da Classe. São únicos para todos os objetos da classe.

Métodos Não Estáticos

public class livro {
  private boolean lido = false;
  public void leiaLivro() {
    lido = true;
  }
  public static void main(String[] args) {
    Livro livro = new Livro();
    livro.leiaLivro(); // Invocado através do objeto
  }
}

Métodos Estáticos

public class Livro {
  private boolean lido = false;
  public static void leiaLivro(Livro livro) {     // <<== metodo estático
    livro.lido = true;
  }
  public static void main(String[] args) {
    Livro livro = new Livro();
    Livro.leiaLivro(livro); // método invocado através da classe
    // “livro.leiaLivro(livro);” válido mas desaconselhado!
  }
}

Métodos estáticos são chamados através da classe, e só tem acesso a dados estáticos.

Objetos passados por referência

Parâmetros de métodos podem ser por referência ou valor. Objetos por padrão são passados por referência. Isso é, mudanças no objeto dentro da função se propagam para fora da mesma.

public static  void removePrimeiro(List lista) {
  lista.remove(0);
}
public static void main(String[] args) {
  List minhaLista = new ArrayList();
  minhaLista.add(“Gato”);
  minhaLista.add(“Cachorro”);
  removePrimeiro(minhaLista);
  System.out.println(minhaLista); // imprime [Cachorro]
}

Tanto a variável “minhaLista” no método “main” e a variável “lista” no método “removePrimeiro” se referem ao mesmo objeto na memória (veja a e b em “Mudando um objeto através das variáveis” acima)

Escopo

Escopo de variáveis está relacionado à que partes do programa podem acessar uma variável. Dependendo de onde a variável está definida seu escopo muda.

As Chaves {…} definem uma área de escopo. Quando uma variável é definida dentro de uma área de escopo, é somente visível dentro desta área. Ao final da execução de uma área de escopo, as variáveis internas são automaticamente destruídas.

O escopo dos campos das classes são todos os métodos da classe. Isso é, um campo de um objeto da classe é acessível por todos os métodos daquele objeto.

Os parâmetros de um método, funcionam exatamente como uma variável do método. Existe até o fim da execução do método.

Exemplos de Escopo

Alguns toques:

Atribução: variáveis apontam objetos. Cuidado com ponteiros nulos;
Static: não invocar métodos estáticos pelos objetos
Passagem por referência: faça uma cópia se quizer se prevenir de uma mudança acidental;
Escopo: minimize o escopo das variáveis o mais possível. Não faça tudo global

Como você pode ver, esta é a aula mais pesada do curso. Não deixe as dúvidas acumularem. Faça os exercícios. Tire suas dúvidas no Fórum, é para isso que está disponível. Não se acanhe. O curso só melhora com a participação de vocês.

Aprofundando

Procure no Java Tutorial da Sun, os tópicos abordados nesta aula.
Faça um estudo de operadores Java.
Faça um estudo da classe java.lang.Math.
Faça um estudo da classe java.lang.String.
Qualquer dúvida vá ao fórum.

Exercícios

Faça um programa para mostrar os números pares de 1 a até 100;
Faça um método que verifique se um número é primo; (chamado isPrimo)
Faça um programa para mostrar os números primos de 1 a 50;
Transforme o método isPrimo em um método estático;
Refaça o programa para usar o método estático;
Faça uma função que verifique os números primos de uma lista e exclua todos os números não primos da mesma.

Na Seqüência

dia 18 de dezembro: Classes, Interfaces e Polimorfismo.
dia 25 de dezembro: folga é Natal. Entraremos em recesso com o curso, estaremos de volta dia 22 de janeiro, ao final de minhas férias.
dia 22 de janeiro: Coleções, Hashing e Comparadores.

Dúvidas? vá para o fórum.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.

Artigos Similares:

Problemas de Logística: décima aula na quarta-feira

Prof. Luis Eduardo — Tue, 11 Dec 2007 20:06:14 +0000

Desde o lançamento do curso de programação para Web, esta será a primeira vez que não poderemos publicar a aula de hoje nesta terça-feira, como de costume.

A aula já está pronta para publicação, porém devido a problemas de logística, só iremos publicá-la amanhã ainda pela manhã.

Peço desculpas para os alunos que estão esperando, mas peço também compreenção. Afinal, se até os engenheiros da Nasa podem adiar algo planejado, por que não posso eu?

Brincadeiras a parte, amanhã nos veremos. Prepare uma boa dose de café, a aula está bem pesada e longa.

Artigos Similares:

Aula 9: Introdução a Java

Prof. Luis Eduardo — Tue, 04 Dec 2007 17:34:20 +0000

Sejam bem vindos, esta é a nona aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Acabou a parte mais fácil do curso, vamos agora começar a programar. Mas antes disso uma introdução teórica de Java é interessante. Vamos a ela:

Java foi iniciado pela Sun no ano de 1990. James Gosling coordenou a equipe que a desenvolveu inicialmente. No início dos trabalhos o objetivo era desenvolver software para uso em eletrônicos de consumo.
Antes do lançamento os projetistas descobriram que Java era ótimo para a Internet. Tiveram a idéia de utilizar um recurso chamado Applet Java, que permitia que programas funcionassem inseridos (Embed) em páginas Web. Lançada em 1995, rapidamente a linguagem ganhou força como a linguagem para uso com a Internet.

Embora o uso de Applets parecesse interessante, a banda larga não era tão difundida como é hoje, e os links lentos impediam a carga dos programas com uma velocidade aceitável. Hoje em dia, estes Applets são usados para validação de senhas em alguns bancos. Veja que a segurança é um dos pontos extremamente fortes do ambiente Java.

Java acabou se transformando na linguagem mais badalada com a introdução do Jsp-Java Server Page, e dos frameworks como Struts, Hibernate e outros. e do J2ee. Isso permitiu que Java fosse realmente utilizado pelas grandes corporações desenvolver softwares de peso nesta linguagem que inicialmente era despretensiosa.

O principal diferencial de Java para as outras linguagens é sua independência de plataforma, embora seja compilada. Utilizando uma máquina virtual diferente em cada plataforma onde funciona, os programas em si depois de compilados podem ser transportados de um ambiente para outro sem modificações. E para ambientes diferentes eu quero dizer:

Processadores diferentes: x86, Sparcs, PowerPC, etc
Sistemas Operacionais diferentes: Windows, Linux, MacOs, Solaris, etc

Assim podemos desenvolver um programa para Windows que funciona em Linux, MacOs, etc.

Mas outras características importantes ainda estão presentes:

Orientação a Objeto
Alto nível
Tipos de dados Estáticos
Multithreaded
Extensível
Bem estruturada
Acesso a banco de dados

Em Java escrevemos o código em um editor de texto sem formatação, como o bloco de notas do Windows e salvamos o arquivo com a extenção *.java. Usamos o compilador javac para obter o programa executável *.class. Os arquivos .class não possuem código executável (bytecode) para o processador do ambiente de desenvolvimento, como acontece com os arquivos executáveis de outras linguagens. Os códigos são bytecodes para uma Máquina Virtual Java (JVM). Para executá-lo usamos o lançador de programas java que aciona a Máquina Virtual para executar o programa.
O JVM por sua vez traduz os bytecodes java para o processador específico onde está sendo executado o programa.

A plataforma Java inclui além da Linguagem de Programação e da Java Virtual Machine JVM, a API – Biblioteca de Classes.
Esta biblioteca possui um grande conjunto de Classes que implementam várias ferramentas necessárias para os programadores. A maior parte das implementação do Java estão na biblioteca.
O aprendizado da linguagem Java é extremamente rápida, mas devido à amplitude da biblioteca, é necessário muita pesquisa para não tentar reinventar a roda a cada programa desenvolvido.

Na próxima aula iremos começar realmente a programar em Java, escrevendo muito código.

Antes de terminar esta aula no entanto instale o seu ambiente de desenvolvimento Netbeans que eu recomendo para as aulas seguintes. É necessário uma máquina razoável (>1Ghz) e 512Mb de memória para ficar confortável. Porém já vi funcionando com menos.

E vamos fazer um teste para ver se está funcionando:

Abrir o Netbeans e acionar o menu Arquivo/Novo Projeto;
Uma janela chamada “Novo Projeto” abrirá. No canto esquerdo tem a identificação do passo em que estamos;
No passo 1: Selecionar Geral / Aplicação Java , clicar no botão Próximo ;
Passo 2: Definir o nome da aplicação. Use “AppAloMundo”. (maiúscula e minúscula é importante em Java, nunca se esqueça disso). Defina a pasta onde vai salvar a aplicação e o nome da classe principal: “appalomundo.AloMundo” e clique em finalizar; Faça exatamente como eu estou pedindo a primeira vez, depois se quiser repetir é por sua conta;
Automaticamente o Netbeans irá criar os diretórios necessários e arquivos para sua aplicação;

Com o projeto pronto para uso, modificar o código de AloMundo.java para:

public class AloMundo {
         public static void main(String[] argv){
               AloMundo objeto=new AloMundo();
         }

         /** Creates a new instance of AloMundo */
         public AloMundo() {
               System.out.println("Alô mundo!");
         }
}

Salve o arquivo e execute a classe com a tecla ou com o menu Executar/Executar Projeto Principal.

O resultado, se tudo der certo, será uma aba conforme a imagem abaixo:

Veja após a saída “run:” o resultado da execução do seu programa. Simplesmente Alô Mundo!

Não deixe para depois, antes da próxima aula consiga com todas as suas energias chegar a este ponto de funcionamento do Netbeans (ou de sua ferramenta escolhida). A próxima aula iremos fazer muitos testes e será altamente recomendado que esteja tudo de acordo.

Na Seqüência

dia 11 de dezembro: todos os fundamentos, rápido e direto!
dia 18 de dezembro: orientação ao objeto.

Dúvidas? vá para o fórum.

Como o curso terminou a primeira fase, gostaria de saber quem ainda esta acompanhando a aulas. Em uma espécie de chamada deixem um recado no comentário desta mensagem. Agradeço de antemão.

Procure os mais baratos Livros sobre a Web, Livros sobre Java, Livros HTML ou Livros CSS nas melhores lojas do Brasil.

Artigos Similares:

Oitava Aula: Diagramação Css

Prof. Luis Eduardo — Tue, 27 Nov 2007 20:40:29 +0000

Sejam bem vindos, esta é a oitava aula de Programação Web em Java, para saber mais sobre o curso, começe em Curso de Programação Web em Java – CPWJ.

Na última aula estudamos como lidar com blocos e trechos xHtml e com bordas, margens e preenchimento. Hoje iremos ver o uso de background, ou pano de fundo e como usar tudo isso para diagramação de sua página.

Background

Os parâmetros background permitem definir como será o comportamento do fundo de um bloco. O fundo inclui a área de conteúdo e o preenchimento (padding). É possível definir uma cor para o fundo, ou preencher o fundo com uma figura. Esta figura pode ser repetida por toda a área ou de outras maneiras. Vamos definir um bloco para realizar os testes:

este é o bloco de teste

E em style definir algumas características:

Pronto assim teremos uma caixa para aplicar os padrões de fundo. Vamos testar primeiro a cor de fundo:

p{
  background-color: #ccc;  /* cor de fundo cinza */
}

Nada mais simples. Agora vamos usar uma figura de fundo. Arrume uma imagem *.gif ou *.jpg e copie para o mesmo diretório do arquivo Css. É possível aplicar um padrão repetido por todo o bloco usando:

p{
background-image: url(“nome do arquivo.jpg”);
}

Se quizer controlar como será a repetição:

background-repeat: no-repeat;  /* a imagem somente uma vez */
background-repeat: repeat-y;  /* a imagem repete na vertical */
background-repeat: repeat-x;  /* a imagem repete na horizontal */
background-repeat: repeat;  /* a imagem repete na vertical e horizontal (padrão) */

Um efeito interessante é manter o fundo fixo quando rolamos a página:

background-attachment: fixed;
background-attachment: scroll; /* rola de forma padrão */

Quando não repetimos a imagem por todo o fundo, podemos posicionar o local onde a imagem irá se apresentar:

background-position: x-pos y-pos ; x-% y-% ; top left ; top center ; top right ; center left ;
center center ; center right ; bottom left ; bottom center ; bottom right ;

Exemplos

Para mostrar uma imagem de fundo exatamente no meio do bloco de modo:

 p{
  background-image: url(“nomearquivo.gif”);
  background-repeat: no-repeat;
  background-position: center center;
}

Como os outros parâmetros podemos escrever um grupo de opções de uma vêz só:

 p{
  background: url(“nomearquivo.gif”) no-repeat center center fixed;
}

As opções podem vir em qualquer ordem e pode-se omitir qualquer uma delas.

Parâmetro Float

Os blocos ‘div’ se comportam exatamente como os parágrafos ‘p’. Quando colocamos um parágrafo na página e definimos uma largura menor que a largura da página é evidente que sobrará espaço a direita do bloco. Veja a figura abaixo:

Digamos que o bloco em azul claro é o fundo do navegador, e os blocos amarelo e verde são dois parágrafos. Usamos Css para definir o parágrafo amarelo e o bloco verde com largura 100px:

#paragrafoamarelo, #paragrafoverde { width:100px; }

Mesmo existindo espaço para os dois parágrafos ficarem lado a lado, como são blocos eles terminam com quebra de linha e o bloco verde continua abaixo.
O parâmetro float permite que um parágrafo simplesmente não quebre a linha no final. O comportamento é de flutuação. O bloco pode ser colocado a esquerda e o restante vai contornar conforme a figura:

Aqui o bloco amarelo possui os seguintes parâmetros:

#paragrafoamarelo{
   width: 100px;
   float: left; /* flutuando a esquerda */
}
/* e o verde: */
#paragrafoverde{
width:100%; /* parágrafo verde ocupando toda a largura da página */
}

Para colocar os dois parágrafos um ao lado do outro:

#paragrafoamarelo{
  width: 100px;
  float: left; /* flutuando a esquerda */
}
/* e o verde: */
#paragrafoverde{
   width:100px;
   float:left; /* flutuando a esquerda */
}

Diagramação com Css

Vamos falar um pouco sobre diagramação com Css. Como exemplo vamos tomar o código xHtml proposto na última aula com algumas modificações:

…




Título da Página
Descrição da página parte do título
Autor: Luís Eduardo. Também parte do título
  

 
Menu de opções:

Opção 1
Opção 2
Opção 3
Opção 4
Opção 5

  


Conteúdo principal da página
…
 

 
Feito por Luís Eduardo
…

E vamos planejar um modelo de diagramação desejado:

Como já expliquei várias vezes, o conteúdo do curso é uma apresentação sobre os assuntos. Material detalhado está na web, e já indiquei vários lugares. Vamos fazer esta diagramação acima explicando cada detalhe e depois é por conta de vocês.

Vamos considerar algumas escolhas:

A largura total da página será fixa e com 758px. (exato para não aparecer a barra de rolagem inferior em tela com resolução 800×600)
A altura dependerá do conteúdo.
A barra lateral em amarelo terá 250px
O título com altura de 200px;
O rodapé terá altura 40px;

Vamos lá Css com as medidas:

#tudo {
  width : 758px;
  background-color: #ffcccc;
}
#titulopagina {
  height : 200px;
  background-color: #00ff00;
}
#menu {
  width : 250px;
  margin: 2px;
  background-color:yellow;
}
#conteudo {
  width : 498px; /* 758px- 250px -10px (margens dos blocos) */
  margin: 2px;
  background-color: orange;
}
#rodape {
  height : 40px;
  background-color: red;
}

Isso fará com que todos os blocos estejam na medida correta, porém um abaixo do outro. Para acertar os blocos no lugar iremos acrescentar o float no conteúdo e no menu:

#menu { ...
  float:left;
  ...
} /* e  */
#conteudo {...
  float:right;
  ...
}

Isso colocará os blocos menu e conteúdo lado a lado. Porém o comportamento do rodapé ainda será errado. Teste no Firefox e no Iexplorer e veja por si mesmo. Para corrigir isso utilize o parâmetro Clear, que proíbe qualquer conteúdo ao lado de um bloco:

#rodape {...
  clear: both; /*proíbe conteúdo a direita e a esquerda do rodapé, fazendo ele ir para baixo */
  ...
}

Ainda temos alguns probleminhas como ajustes de padding dos blocos e as cores de fundo que não se espandem para baixo no menu e conteúdo, eliminar os pontinhos no menu, centralizar o layout, etc.

body {
  margin : 0px 0px;
  text-align:center;
}
#tudo {
  text-align : left;
  ...
}
#menu *, #conteudo * {
  padding: 0 6px;
}
#menu ul li {
  list-style-type:none;
}

Acabou a primeira parte do curso gente, cansei de falar de html, css. Agora fiquem com os especialistas desta área: o Diego Eis do http://www.tableless.com.br e Maurício Samy do http://www.maujor.com. E claro, os cursos web mais completos (infelizmente em inglês) em http://w3schools.com/.

Na próxima aula iremos falar de Java. Uma aula bem teórica, mas é importante saber com o que estaremos lidando.

Aprofundando

Estude alguns outros modelos de layout em:

Na Seqüência

dia 4 de dezembro: Vamos falar de Java, aula introdutória.
dia 11 de dezembro: todos os fundamentos, rápido e direto!
dia 18 de dezembro: orientação ao objeto.

Dúvidas? vá para o fórum.