Java, java e um monte de outras coisas

Queima de Livros de Computação

2011-11-26T06:03:00.000-08:00

Fala galera! Irei me mudar ano que vem, e recebi um ultimato da minha esposa para me 'livrar' de algumas coisas que eu tenho, ela disse que na casa nova só quer coisa nova :(
Assim, estou vendendo os Livros abaixo (depois irei anunciar outras coisas), se alguém se interessar favor entrar em contato comigo pelo meu email ou deixa um comentário aí no post! Valeu!

Rails 3 Programming (R$ 45,00) Ruby Programming (R$ 50,00)

Core J2ME (R$ 20,00) ~~Hibernate em Ação (20,00)~~

~~Projetos Práticos com Jboss Seam (R$ 30,00)~~ Hackers Expostos 4ed (R$ 50,00)

Sistema de Banco de Dados (R$ 60,00) Criando Páginas com css (R$ 35,00)

Effective Java - autografado pelo autor do livro (R$ 80,00)

Se alguém se interessar pelo bolo todo, fala aí que eu posso ver um desconto. Quanto à entrega, eu moro em Fortaleza, então é bom que você more por aqui também, pois não tenho ideia de quanto seria o frete pra outro lugar :) Abraço a todos!

Novidades da JDBC 4

2011-08-03T07:43:00.000-07:00

Quem nunca precisou fazer uma conexão JDBC em Java que atire a primeira pedra! Apesar de hoje em dia não ser comum utilizar JDBC puro em grandes projetos, embora haja quem o faça, a API continua evoluindo junto com a especificação do JSE.

A nova API, JDBC 4, foi incorporada ao JDK 6 e traz algumas mudanças como: melhor gerenciamento de objetos e suporte a novos tipos de dados, além das já existentes flexibilidade e facilidade de uso.

Uma mudança que a nova versão trouxe é na hora de obtermos uma conexão com o banco. Antes era necessário carregar a classe do driver JDBC antes de chamar o getConnection de DriverManager, por exemplo:

Class.forName("com.mysql.jdbc.Driver");

//Chamada ao DriverManager aqui

Esta chamada não é mais necessária, pois o próprio DriverManager se encarregará de localizar e carregar a classe do Driver JDBC, para isto, basta que nós adicionemos o .jar no classpath da aplicação.

Outra novidade é o suporte a tipos de dados em XML, que estão definidos na SQL2003. O objeto é o java.sql.SQLXML, podemos fazer por exemplo:

SQLXML xml = Connection.createSQLXML( );

ou ainda:

SQLXML xml = resultSet.getSQLXML( );

InputStream is = xml.getBinaryStream( );

Seu uso é similar aos dos tipos CLOB e BLOB, que são suportados desde à versão 2.0, a nova versão traz também a classe RowId, que permite fazer o acesso a um registro de forma mais rápida.

Agora é possível executar funções escalares como:

CHAR_LENTH, CHARACTER_LENGTH
CURRENT_TIME, CURRENT_DATE

Com o advento dos frameworks de ORM, como Hibernate, JPA, ficou cada vez mais raro usar JDBC, talvez você leitor nem mesmo soubesse que a API estava na versão 4.0, to mentindo? :) Mas eu acredito que é bom estudar as bases, pois se soubermos utilizar bem JDBC será mais fácil aprender a usar ORM, assim como o estudo de Servlets/JSP é importante para o aprendizado de frameworks web como JSF, Struts, Vraptor etc. Especialmente quando precisamos desenvolver alguns projetos de pequeno porte, onde não é necessário utilizarmos esses frameworks de grande porte. Espero que tenham gostado do post! Até o próximo post então!

Servlet Listeners - Listeners de Sessão - Parte 1

2011-08-02T16:22:00.000-07:00

Olá Javeiros! Continuando a nossa sequência de posts sobre listeners (aqui tá o primeiro e aqui o segundo) hoje vamos começar a falar sobres os listeners de eventos de sessão. Vamos dividir o assunto em duas partes pois nós temos 4 interfaces para os listeners de sessão.

Antes de mais nada é importante que você saiba o que é uma sessão. Como o foco do post não é esse, não espere nenhum compêndio sobre o assunto aqui, quero apenas lembrar o conceito para aqueles que já viram algo sobre isso. Você nunca estudou o que é uma sessão http? Então é melhor você clicar aqui e dar uma estudada primeiro.

O protocolo HTTP é considerado um protocolo stateless, isso significa que cada requisição que é feita ao servidor é sempre uma novidade. Lembra do filme "Como se fosse a primeira vez"? Pois é, depois que o servidor recebe a requisição e envia a resposta ele jamais lembrará o que tinha nessa requisição. Bom, mas isso é porcaria não? É, realmente seria se não fosse o conceito de sessão http. Uma sessão http nada mais é do que a identificação das requisições de um usuário, como o protocolo http não armazena o estado das requisições, os clientes enviam algo nela para que servidor saiba que aquela requisição foi feita pelo usuário A e não pelo B. Essa informação é o session ID.

Existem basicamente duas maneiras de implementar o controle de Sessão em uma aplicação Web Java: através de Cookies ou da reescrita de URLs. A API de Servlets suporta as duas formas e o melhor é que o processo de controle é totalmente automático para o desenvolvedor. Cookies podem ser desabilitados pelo cliente, sendo assim, quando não for possível utilizar esta técnica, os Servlets poderão reescrever as URLs adicionando a elas o nosso Session ID.

A criação de uma Sessão pode ser feita a partir da chamada ao método getSession. Este método retornará a sessão que está associada à requisição atual, caso não exista, uma Sessão nova é criada. Você pode passar um booleano como parâmetro caso deseje decidir criar ou não uma nova sessão.

HttpSession session = request.getSession( );

Depois que um sessão é criada, toda requisição feita entre cliente e servidor carregará o session ID. A partir daí precisamos definir o tempo de duração de uma sessão e quando destruí-la, já que não há como saber se o cliente não está mais 'ativo'.

Encerrando uma Sessão

Existem duas formas de encerrar uma sessão, através da definição de um tempo máximo de inatividade setMaxInactiveInterval ou através da chamada ao método invalidate, os dois métodos estão presentes na interface HttpSession. É possível também configurar o tempo máximo através de um parâmetro no arquivo web.xml da aplicação, conforme pode ser visto abaixo:

<session-config>
<session-timeout>30</session-timeout>
</session-config>

Vale apenas ressaltar que o tempo definido através do método setMaxInactiveInterval é em segundos, enquanto no web.xml é em minutos.

HttpSessionListener

A API de Servlets permite que interceptemos o momento em que uma sessão é criada ou destruída. Para isso precisamos criar um Listener de Sessão através da implementação da interface javax.servlet.http.HttpSessionListener. Essa interface possui 2 métodos que serão chamados sempre que uma sessão for criada, sessionCreated, ou destruída, sessionDestroyed. Por último a classe precisa ser configurada no web.xml para que o container possa chamá-la. A API 3.0 de Servlets permite a utilização de annotations na classe Listener, eliminando a necessidade do mapeamento no web.xml.
A seguir temos um exemplo de uma classe que implementa HttpSessionListener utilizando anotações.

Caso você não esteja usando a nova versão de Servlets, você deve mapear o listener no arquivo web.xml da aplicação:

<listener-class>30</listener-class>

</listener>

No próximo artigo iremos falar sobre sobre os outros Listeners de Sessão (Activation, Binding e Attribute).
Até o próximo post!

Notebook CCE: Primeiras Impressões

2010-12-23T10:36:00.000-08:00

Fala galera, recentemente adquiri uma nova máquina pois o meu bom e velho core 2 duo já não estava mais dando conta do recado. Gostaria de falar da minha primeira impressão sobre os novos Notebooks da CCE. Ah, só pra registrar, o meu note anterior também era um CCE.

Bom, comprar um Notebook hoje em dia é um grande desafio, isso porque você tem um zilhão de opções pra escolher e normalmente os preços não variam muito. Os mais conservadores não irão pensar muito, vão correr pras marcas consagradas do mercado como: Dell, Hp, Sony, etc. Eles estão errados? De modo nenhum! Isso se chama: NÃO ARRISCAR! Bem, mas diz o velho ditado: Quem não arrisca não petisca. E por causa disso eu prefiro arriscar sim! Vou contar-lhes o motivo porque comprei novamente um notebook CCE (só lembrando: eu não estou ganhando porcaria nenhuma pra falar da CCE, apenas estou relatando a minha experiência como cliente desta empresa tupiniquim).

Quando eu resolvi comprar meu primeiro note em meados de 2008 e disse que ia comprar um CCE, quase fui massacrado pelos meus coleguinhas....Foram várias piadinhas do tipo: Ha, CCE é? Começou comprando errado... e outras coisas que o valham... mas como valente e destemido que sou, não dei ouvidos à concorrência..rs. O meu core 2 duo era o que precisava em termos de configuração na época e posso garantir que economizei uma grana boa!

Críticas à primeira versão CCE

O primeiro notebook CCE que comprei tinha suas vantagens (core 2 duo, 2GB de RAM, 120 GB HD). Minhas única crítica era com relação à placa de vídeo, uma vagabunda SiS que não rodava nem campo minado! Bom, mas eu não me importava com isso naquela época, então posso dizer que ele me serviu bastante. O acabamento era bom, com exceção do Pad do mouse, e especifamente comigo tinha um rangido quando fechava a tela, que com o tempo parou. Foram dois anos de uso intenso e ZERO de problemas, nada dele parou de funcionar! Ponto pra CCE!

Novas versões com processadores core i

Agora resolvi comprar outro notebook. Escolhi o T546P+ da CCE. Muita coisa melhorou nessa versão. O problema da versão anterior, a placa de vídeo, foi resolvido. A CCE colocou uma Intel HD, que é a mesma placa que vem nos notebooks da Dell, não é uma monstruosidade, mas com relação à versão anterior parece até piada comentar. O acabamento foi melhorado, agora vem todo em black piano e com um teclado teclado mais moderno e muito melhor de digitar, com teclas mais espaçadas e mais sensíveis ao toque. Ponto pra CCE. A tela também foi melhorada, agora é de LED, pra aproveitar ainda mais a qualidade HD da placa de vídeo, com câmera e vem com saída HDMI. Ponto também! Não foram miseráveis com memória (4 GB) e nem com HD (640 GB o.O), outro diferencial foi a versão do Windows que veio junto: Windows 7 Home Premium (a maioria traz no máximo a Basic) e o Norton Security por 1 ano. A bateria está de parabéns! Fiz um teste e ela durou 2:30 horas de uso intenso! Ah, ainda vem com uma mochila Targus! CCE Wins!

O que eu não gostei?

O Pad do mouse continua uma porcaria, o acabamento black piano é show, mas não precisava colocar ele no Pad do mouse né? Fail aqui. As conexões estão todas na lateral, se você conectar coisas na USB fica um trabolho só, mas não é tão crítico. O cooler é barulhento e roda o tempo todo, vamos dar uma colher de chá aqui, afinal de contas é um core i5 e deve esquentar pra caramba.

Conclusão

Se você estiver pensando em comprar um Notebook com uma boa configuração, mas que o propósito não seja jogar eu recomendo fortemente comprar um CCE, você vai economizar bastante e vai ter uma boa máquina com uma boa durabilidade e de uma empresa nacional!

Notebook CCE, ótimo preço, ótima configuração.

Rest with Jersey: Creating a Restful zip download funcionality.

2010-12-14T06:41:00.001-08:00

It's very simple create RESTFul Web Services with Jersey. I'll demonstrate how to create a simple one that provide a dowload of a compressed file.

First, let's see how to compress a file in Java. If you wanna learn more about, then click here. I use ZipOutputStream because I wanna send the zip file through OutputStream provided by Servlet Response object, but you can send an existent zip file if you prefer. So let's go to the code:

This method is quite simple, It just writes the File parameter inside the ZipOutputStream, that encapsulates our OutputStream, I didn't close the Stream because I wanna compress several files.

Right now let's see how to create our Rest class:

The main points are the annotation @Produces and the header Content-Disposition. The first one is used to specify the MIME media types of representations a resource can produce and send back to the client, in our example we will send a zip file back to the client. The header Content-Disposition allow us to set the file name for the client, if you don't wanna use it the file name will be the same of the rest method name.

After add all desired files we need flush and close the stream and return an 'ok' response, if something goes wrong we send an INTERNAL_SERVER_ERROR status response. When the user requests the resource (like this: http://localhost:8084/jersey-sample/resources/downloader/downloadall/ he will receive a zip file to download and the suggested name will be the same configured in the header Content-Disposition.

It's just for now. Until the next post.

Tomcat 7 foi lançado! Vejas as novidades.

2010-06-30T16:10:00.000-07:00

A apache lançou oficialmente a versão 7 do tomcat, que recentemente completou 10 anos de criação, o que faz dele um projeto bastante maduro, apesar de apenas 7 versões. No mundo open source é comum não termos milhares de versões, afinal de contas esse negócio de mil versões tem um apelo meramente comercial.

Vale a pena conferir a nova versão, que já oferece suporte à especificação de servlets 3.0 e jsp 2.2. Veja aqui tudo que mudou nessa versão e se quiser degustar a versão é só fazer o download aqui.

Custom Tags: Exemplo Rápido

2010-05-22T11:02:00.000-07:00

Fala javeiros! Neste post iremos ver um dos assuntos mais ~~chatos~~ complexos da prova de SCWCD: Custom Tags. E não tô falando de usar JSTL não... a gente vai aprender como construir nossa própria JSTL (guardadas as devidas proporções claro).

Neste primeiro post não vamos falar muito. Queremos que você, leitor, veja todo o processo de construção de uma custom tag. Não fiquei preocupado por não entender quase nada das tags, atente apenas a sequência da construção. Espero que gostem do post! Hands on!

A construção de custom tags envolve basicamente 3 passos:

Criar uma classe que implemente a interface Tag ou estender uma de suas implementações da API.
Criar um arquivo .tld que definirá a sua tag.
Mapear a tag no descritor da aplicação (web.xml).

Para o nosso exemplo iremos construir uma tag que mostra a data atual no formato dd/mm/yyyy hh:mm:ss. É um exemplo bem simples, porém perfeitamente extensível e didático.

Para o primeiro passo nós iremos utilizar a classe javax.servlet.jsp.tagext.BodyTagSupport. Esta classe é fornecida pela própria API e facilita bastante o trabalho de construção de tags, bom mas isso não nos interessa no momento, o importante é saber que temos que estedê-la.

Na figura abaixo podemos ver a implementação da nossa classe principal.

Para o segundo passo iremos definir a nossa tag no arquivo mytags.tld.

Veja como fazer isso na figura abaixo:

Por último, temos que mapear a nossa tag no arquivo web.xml de nossa aplicação.

Pronto! Nossa primeira tag foi construída. Simples, não? Apesar de ser chamada de Simple Tags, construir tags não tem nada de simples, são muitas classes e interfaces possíveis de estender, o retorno dos métodos é feito através de constantes (chato de memorizar) e sem contar que temos que criar um arquivo xml e alterar o descritor e cada um com várias possíveis tags para memorizar. Mas temos que estudar né, fazer o que.

Em posts seguintes veremos mais detalhes sobre a construção de tags, agora pra terminar de vez este post, vejamos como fica a nossa tag em uma página JSP e qual o seu resultado após a execução da página.

Ao executar esta JSP devemos obter um resultado parecido com o abaixo:

Hoje são 22/05/2010 14:58:30

Até o próximo post!

Servlet API: Utilizando parâmetros de incialização

2010-05-15T13:11:00.000-07:00

Olá Javeiros! Dando continuidade ao nosso estudo para a certificação SCWCD veremos neste post rápido como fazer para utilizar parâmetros de inicialização em nossa aplicação e também em um Servlet específico.

É possível adicionar parâmetros que são acessíveis por toda a aplicação. Muitos frameworks web fazem uso desse recurso. Digamos que a aplicação necessite enviar um email para o administrador reportando erros, se colocarmos o email do administrador no código da aplicação e este email sofra alguma mudança, será necessário gerar um novo arquivo de deploy da aplicação. Este problema pode ser resolvido adicionando um parâmetro de inicialização no arquivo descritor (web.xml), e dessa forma ele estará disponível para toda a aplicação.

Digite o trecho a seguir entre as tags web-app do seu arquivo descritor.

A API de Servlet disponibiliza, através da interface ServletContext, métodos para acessar os parâmetros de inicialização. Existem dois métodos para tal:

Enumeration getInitParameterNames: Este método retorna uma enumeration contendo todos os nomes de parâmetros disponíveis no web.xml. Ele é muito útil quando não se sabe o nome do parâmetro.
String getInitParameter(String name): Este método retorna o valor (param-value) do parâmetro de inicialização. Vale lembrar que sempre é retornado uma String e nunca outro tipo como Integer, Long, etc.

No trecho de código abaixo podemos ver o uso desses métodos a partir de um servlet.

Quando o servlet for acessado ele irá exibir todos os parâmetros de inicialização disponíveis.

É possível também criar parâmetros de inicialização para Servlets, a diferença é que estes serão visíveis somente para os servlets onde foram declarados. O conceito é basicamente igual ao anterior, porém devemos atentar para as tags que criam cada um deles. No exemplo anterior nós colocamos a tag context-param na raiz do nosso descritor, já para os parâmetros de servlets iremos utilizar a tag init-param e esta deve ser declarada sobre a tag servlet (tag de declaração de um servlet).

O trecho abaixo mostra a criação de um parâmetro para um Servlet.

Veja que a única diferença para o exemplo anterior é a tag init-param. Outra mudança também é na forma como o parâmetro é acessado. Na verdade a mudança é no objeto em que ela é acessado, não mais o ServletContext e sim o próprio Servlet.

Vejamos abaixo o código que acessa os parâmetros do servlet:

Observe que o método getInitiParameterNames é chamado diretamente de Servlet e não mais do contexto como no exemplo anterior.

Então é isso pessoal. Espero que tenham gostado do post! Até o próximo então.

Servlet Listeners - ServletContextAttributeListener

2010-05-09T06:48:00.000-07:00

Olá Javeiros! No post anterior começamos a falar sobre servlet listeners. Vamos continuar a série e agora falaremos sobre o listener de atributos de contexto ou ServletContextAttributeListener. Este listener é notificado quando algum atributo é adicionado, removido ou alterado no contexto da aplicação.

A criação deste listener é semelhante ao criamos anteriormente. Teremos que implementar a interface java.servlet.ServletContextAttributeListener e seus três métodos:

void attributeAdded(ServletContextAttributeEvent): este método é chamado automaticamente sempre que um atributo for adicionado no ServletContext e através do objeto ServletContextAttributeEvent podemos obter informações como: o nome do atributo adicionado, o seu valor, o objeto em que o evento inicialmente ocorreu e ainda o próprio ServletContext.
void attributeRemoved(ServletContextAttributeEvent): este método é chamado sempre que um atributo for removido do contexto.
attributeReplaced(ServletContextAttributeEvent): é chamado sempre que um atributo tiver o seu valor alterado.

Vejamos um exemplo prático onde exibimos o nome de atributo e o seu valor para cada evento.

A configuração do listener é feita da mesma forma que anterior. Vale lembrar que não é possível declarar várias classes listener dentro da tag , é preciso criar um conjunto pra cada listener, como vemos abaixo:

Aprendemos mais um listener hoje! Boa sorte nos estudos e até o próximo post!

Servlet Listeners - ServletContextListener

2010-05-08T08:18:00.000-07:00

Olá Javeiros de plantão! Continuando nossa sequência de posts sobre o exame para SCWCD vamos falar hoje sobre Servlet Listeners. O exame requer que o candidato saiba criar e configurar listeners para os escopos do ciclo de vida de uma aplicação, listeners de atributos e também serem capazes de escolher um filtro apropriado para um determinado cenário. Iremos ver como funcionam os listeners cobrados no exame. Neste artigo falaremos especificamente do listener de contexto (criação ou destruição).

Suponhamos que uma aplicação web necessite de alguns recursos para que esta possa funcionar corretamente. É importante que estes recursos esteja disponíveis assim que a aplicação esteja no "ar", mas como saber se aplicação já foi carregada pelo container? E como garantir que os recursos serão liberados após a aplicação ser desativada? Para resolver o problema descrito neste cenário a API de Servlet disponibiliza um listener de contexto. Através dele e possível sabermos o momento em que a aplicação está sendo carregada ou destruída.

O processo de criação de um listener resume-se basicamente em implementar a interface do listener desejado e fazer a configuração do mesmo no descritor da aplicação (web.xml). Para esse primeiro post iremos utilizar a interface javax.servlet.ServletContextListener. Esta interface deve ser utilizada para a criação de listeners de contexto e ela possui dois métodos que devem ser sobrescritos pela classe implementadora. Os dois métodos são:

void contextInitialized (ServletContextEvent): Este método é executado no momento em que a aplicação é carregada pelo container, através do parâmetro ServletContextEvent, que é injetado automaticamente pelo container, é possível obter o objeto ServletContext, onde poderemos adicionar, remover ou capturar atributos ou fazer a leitura de parâmetros de inicialização. ATENÇÃO: este método só é chamado UMA ÚNICA vez durante o toda a vida da aplicação.
void contextDestroyed (ServletContextEvent): Este método é executado no momento em que aplicação está sendo destruída (parada) pelo container. Assim como o método de inicialização este método também só é executado uma vez.

Abaixo temos um exemplo simples de como criar um listener de contexto. No nosso exemplo apenas adicionamos um atributo contendo o momento em que aplicação subiu e podemos usar este atributo para saber quanto tempo a aplicação ficou ativa. O exemplo não é dos melhores, mas você aprenderá com ele que é capaz adicionar atributos que serão visíveis por toda a aplicação no momento seguinte à subida da mesma. Quando a aplicação for destruída o sistema irá exibir uma mensagem contendo o tempo total em segundos que a aplicação ficou no ar.

Primeiramente vamos criar a classe que irá implementar a interface ServletContextListener e vamos também implementar seus dois métodos:

Agora precisamos configurar o nosso listener no arquivo descritor da aplicação, que é o arquivo web.xml da aplicação. Vejamos abaixo como configurar o nosso listener.

A configuração de um listener é bastante simples e resume-se em declarar a classe que implementa a interface de listener. A aplicação irá carregar os listeners na ordem em que eles aparecerem no arquivo web.xml.

Espero que este post seja útil de alguma forma pra você! Até o próximo post!

Criando funções JSP com EL

2010-05-02T11:03:00.000-07:00

Galera, pra quem vai tirar (ou não) a certificação SCWCD 5.0, um dos objetivos do exame é saber se o candidato sabe criar funções com EL (Expression Language) para serem usadas em suas páginas JSP. A criação de funções EL serve para que você pense duas vezes antes de usar os malditos scriptlets em suas páginas JSP (sério, não faça isso por favor).

O processo envolve basicamente quatro passos:

Criação de uma classe Java que conterá os métodos que você irá utilizar nas suas páginas JSPs.
Criação do arquivo tld (Tag library descriptor) que conterá o mapeamento entre o método Java e sua versão XML.
Mapeamento da sua tld no web.xml (isso é opcional... mas é legal utilizar)
Declaração da taglib na sua página JSP.

Vamos criar um exemplo simples para explorar os passos acima. Criaremos uma função que calcula a raiz quadrada de um número. Mãos à obra.

Passo 1: Vamos criar uma classe chamada functions.MyMath e nela vamos criar um método square que será responsável pelo cálculo da raiz quadrada. Precisamos de alguns cuidados neste momento. A especificação diz que esta classe deve ser pública e os métodos que serão acessados pelas páginas JSPs devem ser públicos e estáticos. Dito isto, vejamos como ficou a nossa classe:

Passo 2: Vamo criar o arquivo tld. Este arquivo permitirá o mapeamento entre o nosso método java uma função XML que a EL possa executar (EL não permite a invocação de métodos Java). Uma observação importante é que caso o arquivo tld esteja sobre o diretório WEB-INF da sua aplicação ele é automaticamente reconhecido por ela, caso esteja em outro lugar você terá que fazer o passo seguinte.

Eu odeio quando as coisas não seguem um padrão nesses malditos arquivos xml... deixando a ira de lado, notem que o atributo que mapeia o nome da função não é function-name (o que faria muito mais sentido) e sim name, ele será usado para chamar de fato o nosso método java, você não precisa colocar o mesmo nome do método, mas fica melhor dessa forma. Outras dicas importantes são que em function-class deve ser colocado o nome completo da classe (com o pacote, conhecido como full qualified name) e em function-signature os tipos do retorno e da entrada devem ser também completos. Você pode usar todos os tipos básicos de Java e incluindo os wrappers sem necessidade de importação nas páginas JSP, caso não seja um desses tipos você terá que fazer a importação.

Passo 3: Este passo é opcional caso o seu arquivo tld esteja sobre o diretório /WEB-INF da aplicação, mas eu recomendo fortemente que você o faça. Por quê? Bem, digamos que um belo dia você resolve mover ou mudar o nome do arquivo... imagine só ter que sair alterando todas as páginas JSPs que fazem uso do arquivo... chato né? Então largue a preguiça de lado e coloque o conteúdo abaixo no arquivo web.xml:

Passo 4: Por fim precisamos declarar nossa função na página na qual desejamos chamá-la. O processo é bastante simples, principalmente se você já tiver utilizado JSTL. Vejamos como fica a nossa página JSP:

Se você fez tudo direitinho, ao executar a página acima será exibida a mensagem "A raiz quadrada de 25 é 5.0". Uma última coisa a dizer é sobre o argumento uri, apesar de ele está no formato absoluto (com protocolo etc) isto não significa que a JSP irá tentar acessar este endereço, apenas ela irá procurar no descritor (web.xml) se alguma taglib declarada ali combina com esta uri informada).

Bom galera, isso é tudo! Espero que tenham gostado da dica e até o próximo post!

Dica 4: Empacotando uma aplicação em um Jar

2009-11-28T04:56:00.000-08:00

Uma das dificuldades que os programadores de linguagem RAD tem quando vem para o Java é com relação ao tal do 'executável'. Quando você cria um programa em Java não é gerado um arquivo .exe como na maioria das linguagens. Em java dizemos que uma classe é executável se ela tiver um método main ou ainda se ela for um applet o método init. O processo de criação de executável se chama: empacotamento da aplicação. Que é exatamente colocar a aplicação dentro de um arquivo de extensão .jar. Nesta dicas vamos ver como fazer para empacotar uma aplicação Java.

Vamos supor que nossas classes estão em uma pasta chamada HelloWorld e nela temos uma classe chamada HelloWorld.java e seu bytecode compilado HelloWorld.class. Esta classe simplesmente exibe uma mensagem de boas vindas pro usuário.

Outra coisa importante para um arquivo .jar é o arquivo de manifesto. Esse arquivo vai fornecer informações importantes para a execução do programa como classpath e também a main class do seu programa. A partir do Java 6 temos um comando novo onde podemos informar diretamente no prompt qual é a main class da aplicação, basta então digitarmos isso:

jar cvfe HelloWorld.jar HelloWorld .*class

Se você viu algo como:

added manifest

adding: HelloWorld.class(in = 395) (out= 292)(deflated 26%)

Significa que deu tudo certo. Para executar o arquivo bastar dar um clique duplo nele (caso o Java esteja configurando corretamente no seu classpath do SO) ou pode ainda usar o comando abaixo que tem o mesmo resultado:

java -jar HelloWorld.jar

Você pode ver mais informações sobre arquivos .jar neste link. Um abraço e até a próxima dica.

Dica 3: Descompactando Arquivos Zip

2009-11-08T05:19:00.000-08:00

Essa dica é baseada nos exemplos do deste artigo da sun. Lá você pode conferir outros exemplos em inglês. Não é algo comum, mas certamente muitas pessoas já precisaram descompactar um arquivo zipado em uma aplicação. Essa tarefa tornou-se mais fácil depois que o Java disponibilizou as classes do pacote java.util.zip.*. A leitura do arquivo zip é simples. Utilizamos a API de I/O do Java. Precisamos de um Buffer para leitura e um para escrita e também das classes ZipFile, que encapsula o arquivo Zip e a classe ZipEntry que encapsula um arquivo dentro do zip. A classe ZipFile fornece um método que retorna os arquivos que estão contidos dentro do zip, basta percorremos o enum e ler cada um dos arquivos. É possível ainda saber se o 'arquivo' que estamos lendo é um diretório através do método isDirectory, caso contrário deve ser utilizada uma outra abordagem (não mostramos aqui), com o Stream podemos então escrever os arquivos fora do zip.

Na imagem abaixo temos o código fonte de exemplo.

Até a próxima dica!

Dica 2: Escrevendo em um arquivo com Java

2009-11-02T13:36:00.000-08:00

Na dica 1 vimos como fazer pra ler um arquivo utilizando Java. Nesta dica veremos como escrever conteúdo em um arquivo.

O processo de escrita em arquivos é muito semelhante ao de leitura, basicamente as classes/interfaces que antes terminavam com Reader agora terminam com Writer. O uso buffer é opcional para o caso de escrita, pois a classe FileWriter fornece método para escrita de strings diretamente no arquivo (a classe FileReader só permite leitura em bytes).

O código abaixo mostra como escrever em um arquivo em Java.

É isso aí pessoal! Até a próxima dica.

Dica 1: Lendo Arquivo com Java

2009-11-01T13:12:00.001-08:00

Salve javeiros de plantão! Depois de um tempão fora do ar por causa dos estudos, vamos voltando aos poucos a postar no javeiro.

Irei começar uma série de dicas rápidas em Java, ideal para aqueles que não querem perder tempo lendo um monte de coisa :D.

A primeira dica é como ler um arquivo em Java. A API de I/O do Java é bastante rica e também um pouco chatinha de trabalhar, são muitas classes que se combinam para executar tarefas. A cada versão nova do Java temos vista diversas melhorias nessas APIs.

O código abaixo mostra como fazer a leitura de um arquivo em Java.

Essa é uma das formas de ler um arquivo em Java. Espero ter ajudado. Até a próxima dica!

Usando os atalhos do Eclipse no Netbeans

2009-02-10T14:51:00.000-08:00

Essa dica é muito boa para aqueles que desejam começar a usar o Netbeans mas estão acostumados com as teclas de atalho do eclipse, e que venhamos e convenhamos são uma verdadeira maravilha do eclipse ide. Você poderá usar a maioria dos atalhos do eclipse no Netbeans. É infelizmente não estão todos mapeados, mas para usuários iniciantes será como se eles estivem usando o eclipse, só que na verdade estarão usando uma ide melhor com os atalhos da anterior (vão me estrangular por esse comentário :D ).
Então vamos lá. Para isso acesse o menu Tools --> Options. Aí você verá a tela abaixo:

Em profile escolha: Eclipse. (tem várias outras opções se você quiser se divertir).
Prontinho. Agora é só usufruir dos benefícios da única IDE que você precisa com os atalhos da sua IDE anterior.
Até o próximo post!

Netbeans 7 disponível para download

2009-01-30T14:01:00.000-08:00

Já está disponível o download da versão 7.0 do Netbeans. Ainda é um beta, mas pode ter certeza que vale a pena testar. As últimas versões da IDE que carregar o slogan: A única IDE que você precisa, vêm cada vez mais fazendo jus ao seu slogan. O Netbeans tem ganhado espaço entre os desenvolvedores Java, especialmente por sua grande gama de funcionalidades disponíveis, estabilidade e integração com diversos frameworks como: Jsf, Hibernate, Spring e etc. Em breve traremos mais novidades sobre a nova versão da IDE.
Enquanto isso você pode clicar aqui e começar a testar a nova versão, que está quentinha ainda!!!
Até o nosso próximo post!

Firebird + JPA e o Problema com o Generator

2009-01-29T07:55:00.000-08:00

Resolvi fazer este post depois de muito sofrer para integrar o JPA com o Firebird. O grande problema que eu encontrei foi com o esquema de geração de ids do firebird. Firebird usa um esquema chamado de Generator, é muito parecido com esquema de sequences de bancos como oracle. Então vamos à solução do problema. Abaixo temos a nossa entidade Aluno, com as anotações do JPA. (omitimos os imports e os get/set, pois o foco é no generator.

@Entity
@Table(name="TB_BAIRRO")
@SequenceGenerator(name="GEN_TB_BAIRRO",sequenceName="GEN_TB_BAIRRO_ID")
public class Bairro extends BaseEntity {

@Id
@Column(name="BAIRRO_SEQ")
@GeneratedValue(strategy=GenerationType.AUTO,generator="GEN_TB_BAIRRO")
private Integer id;

@Column(name="BAIRRO_DSC")
private String descricao;

Definimos na classe qual é a sequence (no firebird Generator) que vai ser usada pra gerar a primary da key da tabela. O atributo name é importante pois ele vai ser usado, como pode ser visto acima, na anotação GeneratedValue, cuja strategy deve ser do tipo AUTO, e no parâmetro generator, informamos o nome que demos à nossa SequenceGenerator da tabela.
Até o nosso próximo post!

Operadores e Atribuições - Tabela de Precedência

2008-11-29T11:56:00.000-08:00

Olá javeiros! Após um período longe do blog (estou estudando pra dois concursos e pra prova SCWCD) vamos tentar aos poucos voltar a escrever algum post no nosso blog. Assim que essa fase passar prometo que vou postar mais coisas aqui. Então vamos voltar ao Java!
Neste post vamos começar a estudar os operadores e atribuições em Java. Operadores são essenciais em uma linguagem de programação, e normalmente eles são semelhantes em todas as linguagens. Antes de vermos cada um deles, precisamos saber a precedência dos operadores. A precedência é importante quando temos uma expressão para ser executada. O resultado da expressão vai depender da precedência dos operadores. Veja na tabela abaixo a precedência dos operadores na linguagem Java:

Operadores	Precedência
postfix	`expr++ expr--`
unário	`++expr --expr +expr -expr ~ !`
multiplicativo	`* / %`
aditivo	`+ -`
deslocamento	`<< >> >>>`
relacional	`< > <= >= instanceof`
igualdade	`== !=`
bitwise AND	`&`
bitwise exclusive OR	`^`
bitwise inclusive OR	`\|`
lógico AND	`&&`
lógico OR	`\|\|`
ternário	`? :`
atribuição	`= += -= *= /= %= &= ^= \|= <<= >>= >>>=`

Essa tabela embora pareça muito grande, na verdade é muito intuitiva. A maioria de nós já aprendeu pelo menos a precedência dos operadores matemáticos, que são maioria na tabela. No próximo post vamos estudar a maioria desses operadores. Não vamos estudar todos por que alguns foram retirados do exame 5.0 (ainda bem). Até o próximo post então!

Agora eu sou SCJP!!

2008-09-27T05:51:00.000-07:00

Quero pedir desculpas pela minha ociosidade repentina mas é que eu estava na minha semana decisiva. Fiz a prova da certificação ontem e obtive 83% \o/. Acertei 60 das 72 questões, um resultado além do meu esperado. A prova estava bem tranquila mas é lógico que eu estudei pra caramba pra fazer. Então em breve estaremos postando novos artigos sobre a SCJP, agora que estou mais experiente vai ficar ainda melhor. um abraço e até o próximo post.

Novidades do Java 5.0: Enums

2008-09-03T16:17:00.000-07:00

Hoje iremos aprender mais um assunto novo para a prova de certificação java 5.0: os enums. Podemos entender enums como tipos de constantes. Por exemplo: SEGUNDA, TERCA, QUARTA...etc, podem ser iplementados como constantes ou membros de um enum chamado DiasDaSemana. Enums ajudam bastante os programadores a tornar seus códigos mais claros e com menos possibilidades de bugs.

Para definir um enum usamos a palavra chave enum, por exemplo, o nosso enum descrito acima ficaria assim:

public enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

Um enum pode ser declarado em uma classe própria ou ainda dentro de uma classe. Vejamos como é isso:

enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

class Calendario {

enum Meses {

JANEIRO, FEVEREIRO, MARCO

//OUTROS MESES AQUI

}

DiasDaSemana dia;

Meses mes;

}

public class UsandoCalendario {

public static void main(String... args){

Calendario c = new Calendario();

c.dia = DiasDaSemana.SEGUNDA;

c.mes = Calendario.Meses.JANEIRO;

}

Apesar de enum ser um classe (é isso mesmo) um enum não é instanciado diretamente como as outras classes em java (usando new por exemplo), basta chamar uma de suas 'constantes'. A ordem dos elementos de um enum é importante e uma coisa importante também é que nada pode ser declarado antes delas. Bom, você pode declarar variáveis em um enum, mas elas precisam vir após a declaração dos elementos. Por exemplo:

enum DiasDaSemana {

private boolean diaUtil; // erro!

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO

}

O correto seria:

enum DiasDaSemana {

DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA,

SEXTA, SABADO; // o ; é obrigatório caso declare algo depois

private boolean diaUtil;

}

Enums também pode ter construtores. Porém eles não são acessíveis fora da definição do enum. Podemos usar os construtores para inicializar algum tipo de variável ou valor default para um enum. Por exemplo:

enum DiasDaSemana {

DOMINGO(false), SEGUNDA(true), TERCA(true), QUARTA(true), QUINTA(true), SEXTA(true), SABADO(false);

// o ; é obrigatório caso declare algo depois

private boolean diaUtil;

DiasDaSemana(boolean util){

this.diaUtil = util;

}

public boolean isDiaUtil(){

return this.diaUtil;

}

Enums também pode ser utilizados com a estrutura de switch. Como no exemplo abaixo:


public enum Luas {
          CHEIA, CRESCENTE, MINGUANTE, NOVA
}

.... definição da classe
Luas l = Luas.NOVA;
switch(l) {
             case CHEIA: //codigo aqui
             case CRESCENTE: //codigo aqui
             case MINGUANTE: //codigo aqui
             case NOVA: //codigo aqui
             default: //codigo aqui
}

Até o próximo post.

Novidades do Java 5.0: Varargs

2008-09-02T18:26:00.000-07:00

Suponhamos que você deseja criar um método que faz a soma dos inteiros passados como parâmetros nele. Como você faria isso antes do java 5? Bem, teríamos que fazer algo do tipo:


public int somar(int a) {
 return a;
}

public int somar(int a, int b) {
 return a + b;
}

public int somar(int a, int b, int c){
 return somar(a,b) + c;
}
...

O problema é que para conseguir suportar mais argumentos você teria que criar mais métodos sobrecarregados, tornando a sua classe gigante e difícil de manter. A partir do java 5 ficou muito mais fácil criar essa funcionalidade. Através da sintaxe de argumentos variáveis ou varargs. Então os métodos que nós escrevemos antes ficariam todos resumidos em um método assim:

public int somar(int... args) {
int total = 0;
for (int i = 0; i < args.lenght; i++)
total += args[i];
return total;
}

chamadas válidas ao método
System.out.println(somar()); imprime 0
System.out.println(somar(1)); imprime 1
System.out.println(somar(1,2)); imprime 3
System.out.println(somar(1,2,3)); imprime 6

Acho que você notou que o argumento variável nada mais é que um array de objetos ou de primitivos do tipo informado no parâmetro né? Só que o recurso é mais interessante porque me dá a flexibilidade de passar quantos parâmetros eu quiser sem precisar declará-los em um array. Agora vejamos as regras do varargs:

Todo vararg tem um tipo definido. Como no nosso exemplo o tipo foi int.
Para definir que o parâmetro é vararg use ... (três pontinhos) depois do tipo. Cuidado para não confundir com a sintaxe de arrays, ainda não vimos arrays mas vamos adiantar a sintaxe aqui: um array pode ser definido: int[] a ou int a[]. Um vararg só pode ser int... a e NUNCA int a...
Eu posso ter vários parâmetros junto com o vararg, porém só posso ter um ÚNICO vararg como parâmetro e este precisa ser OBRIGATORIAMENTE o último deles. Assim é válido ter: public void somar(String msg, int... a); mas é inválido: public void somar(int... a , String msg);

Por último devemos saber que acessamos vararg como se tivéssemos acessando um array do tipo informado. Assim você pode usar qualquer estrutura de laço ou índice, como for por exemplo.
Até o próximo post.

Declarando Variáveis de Classe

2008-09-02T14:29:00.000-07:00

No post anterior vimos como declarar variáveis locais. Vimos que normalmente o escopo de uma variável local é o método ou a estrutura onde ela foi declarada (por ex. um for) e vimos ainda que elas só aceitam o modificador final.
Agora iremos aprender o que são e como usar variáveis de classe. Uma variável de classe nada mais é do que uma variável que tem o seu escopo na classe na qual ela foi criada. Isso quer dizer que ela vive enquanto a classe estiver viva (ou na memória né...). Você define uma variável como sendo de classe utilizando o modificador static. Uma variável estática pode ser acessada diretamente através da classe, ou seja, eu não preciso ter um objeto (ou uma instância de um) para acessar a variável, só preciso utilizar ClassName.variableName. Vamos dar um exemplo:


public class Carro {
   public static String cor = "Azul";
}

public class TesteCarro {
   public static void main(String args[]){
         Carro c = new Carro();
         System.out.println(Carro.cor); //classe
         System.out.println(c.cor);     //objeto
   }
}

Note que não criamos um objeto Carro, simplesmente chamamos a variável cor através da classe Carro (claro que isso foi possível também porque cor é uma variável pública). Você pode também acessar uma variável de classe através de uma instância da classe, pois todas as instâncias compartilharão a mesma variável, já que ela pertence à classe. Então eu sugiro que você sempre acesse via classe mesmo e não via objeto, até para deixar seu código mais claro.
Até o próximo post.

Declarando Variáveis Locais

2008-09-01T18:46:00.000-07:00

Um dos tópicos da seção 1 diz que o programador deve desenvolver código que declare, inicialize e use variáveis locais. Neste post iremos falar um pouco sobre elas. Já vimos vários modificadores de acesso. Vimos que eles são aplicados em membros de uma classe (que podem ser métodos ou variáveis). Toda variável possui um escopo. Escopo a gente aprendeu na 1ª série que nada mais é do que o limite até onde essa variável pode ser acessada (cuidado pra não confundir com encapsulamento). No java variáveis podem ser de 3 tipos:

Locais ou de métodos
De classe
De instância

Uma variável local ou de método tem o seu escopo limitado ao método ou bloco (por exemplo um for) em que ela foi definida. A sua vida se resume ao local delimitado pelas chaves em que ela foi criada. Por exemplo:


public void mostrarNome(String nome) {
      int a = 10;
      System.out.println(nome);
}

As variáveis 'a' e 'nome' são variáveis locais. O escopo delas está limitado as chaves que abrem e fecham o método mostrarNome. Isso significa que após a última chave, elas simplesmente não existirão. Podemos ter também algo do tipo:


public void contarAte(int contador) {
    for (int i =0; i <= contador)          System.out.println(i);            }            System.out.println(i); }

Quantas variáveis locais temos aí? Quem disse 2 acertou na mosca. São elas: 'contador' e 'i'. A variável 'i' é uma variável local também, só que o seu escopo está limitado ao laço for no qual ela foi criada. Então isso significa que esse código não compilaria pois estamos tentando acessar a variável 'i' fora o seu escopo, pois o compilador não enxerga mais a varíavel após a última chave do for. Já a variável contador seria perfeitamente acessível daí, já que o seu escopo é o método todo.
Mas eu falei de modificadores de acesso no começo deste post, o que tem a ver com as variáveis locais? Tem tudo a ver. Ou por que não dizer "não tem nada a ver". Isso porque as variáveis locais só aceitam um único modificador de acesso: final. O modificador final quando aplicado a uma varíavel local diz que o valor da variável não pode ser modificado após a sua inicialização. Então se fizéssemos algo do tipo:


public void contarAte(final int contador) {
    contador = 100; //erro
    ...
}

Esse código não compila, pois a varíavel contador não pode ter o seu valor alterado pois ela é uma variável final. O modificador final pode ser usado em java para definir constantes, apesar de uma das palavras chaves da linguagem ser a palavra const, ela não é utilizada. Assim você diz que uma variável é uma constante aplicando a ela o modificador final.
Para finalizar você precisa saber que uma variável local precisa ser OBRIGATORIAMENTE inicializada antes de ser utilizada. E você precisa garantir que ela o será, caso contrário o seu código não irá compilar.


public void exibeResultado(boolean exibe) {
      String resultado;
      if (exibe)
               resultado = "Fui iniciada?";
      System.out.println(resultado);
}

Você pode achar que o compilador vai ser legal com você e aceitar que se o parâmetro exibe for true a variável resultado será inicializada e poderá ser utilizada. Mas ele não vai aceitar isso. Ele vai reclamar para você que a variável resultado pode não ser inicializada. Lembra que eu falei que você tinha que garantir que ela o seja? Para corrigir o trecho acima basta fazermos:

public void exibeResultado(boolean exibe) {
      String resultado;
      if (exibe)
               resultado = "Fui iniciada?";
      else
               resultado = "Com certeza";
      System.out.println(resultado);
}

Agora sim, o compilador se dará por satisfeito e compilará o seu código. Resumindo o que vimos:

Variáveis locais só podem ser marcadas como final.
Variáveis locais TEM que ser inicializadas antes do seu uso.

Até o próximo post.

Windows Explorer com abas e muito mais

2008-09-01T16:44:00.000-07:00

Se você assim como acha que o Windows Explorer do XP é uma porcaria, então esse programa foi feito pra você também! O ExplorerXP permite você navegar nos arquivos e pastas do seu windows e oferece uma série de recursos extras. Você pode clicar aqui e ver as vantagens de usar o software e também pode fazer o download. O programa é bem pequeno (apenas 410KB) e consome pouca memória ao ser ativado. O melhor de tudo é que ele não afeta o seu Windows Explorer. Você pode usar os dois independentemente.

Abaixo você pode ver um screeshot do programa.

O que aprendemos até aqui

2008-08-30T09:37:00.000-07:00

Vamos dar uma paradinha rápida no estudos para vermos o que aprendemos até aqui. Como já havia falado antes, estamos seguindo o conteúdo completo (não sei se vamos conseguir mostrar tudo, mas tentaremos) do programa de certificação para programador. Até aqui só vimos o objetivos da seção 1 (quero ver essas seções):
Section 1: Declarations, Initialization and Scoping
1.1 - Aprendemos a declarar classes concretas e abstratas. Ainda falta vermos enum.
1.2 - Aprendemos a declarar interfaces e implemtá-las, vimos que seus métodos são todos públicos e abstratos, e que todos as variáveis são constantes (public static final).
1.3 - Só vimos os identificadores válidos lembra (começa com $,_, ou letra, depois qualquer outro caractere unicode)
1.4 - nada visto ainda.
1.5 - nada visto ainda.
1.6 - nada visto ainda.

Já deu pra ver que falta muita coisa ainda né? Bom, alguns assuntos a gente vai ter que pular, mas só aquilo que a gente vir que dá pra você pegar de letra. Mas fique calmo, não vamos querer desistir por causa disso né? Uma dica para aqueles que não conseguem estudar (como eu :) ): marque a prova que você vai ser obrigado a estudar...rs é meio masoquismo, mas comigo funcionou.
Aguardem que vem mais post em breve. Até lá.

Declarando membros de classes - Parte 3

2008-08-28T17:07:00.000-07:00

Vamos continuar o nosso estudo sobre os níveis de acesso aplicados aos membros de uma classe. Já falamos sobre três níveis: public, protected e default. Neste post vamos falar sobre o último nível de acesso: private. O nível de acesso privado é o mais restritivo dos níveis. Ele faz com que o membro que seja marcado como tal fiquei fechado dentro da classe que o criou, ou seja, SOMENTE é possível acessar um membro privado dentro da classe que o declarou. Sendo assim, os membros private NUNCA são herdados. Bom, já que não teremos muita coisa pra falar por aqui, então vamos para os exemplos:


Dog.java
public class Dog {
   private String raça = "viralata";
  
   private void latir(){
         System.out.println("au au");
   }
}

Dobberman.java
public class Dobbermar extends Dog {
   
    private void destruir(){
         System.out.println("rrrrr asdfhasdasd");
    }
}

Canil.java
public class Canil {
    private void exibirMe(){
         System.out.println("Eu posso ser acessado aqui");
    }
    public static void main(String args[]){
          Dog dog = new Dog();
          dog.latir(); // xiii
          Dobberman d = new Dobberman();
          d.raça = "Dobberman"; // piorou né?
          d.destruir(); // agora é que destruiu tudo
          exibirMe(); // blz. aqui tudo bem.
    }

Vamos fazer apenas mais uns poucos comentários para encerrar essa seção. Dog definiu dois membros privados, um método e uma variável de instância. Esses membros só podem ser acessados por algum código que esteja dentro do escopo (entre as chaves) da classe Dog, e por ninguém mais. Então eu nem preciso falar que a classe Dobberman não herdará os membros né? Vamos pular então pra classe Canil, ela instância um objeto Dog e um Dobberman, e em seguida tenta acessar seus membros privados, o que obviamente ocasionará em um erro de compilação, pois estes não são acessíveis a partir de outra classe. Se porém, contudo, todavia a classe Canil pudesse ser compilada, o método exibirMe poderia ser chamado sem problemas, pois apesar de ele ser privado, o acesso está sendo feito dentro da classe na qual ele foi declarado.

Então é isso. Sobre membros privados não há mais o que dizer, pelo menos não por enquanto (calma, depois falaremos sobre inner classe e você verá que é possível acessar membros privados a partir de outra classe... mas esqueça isso por enquanto).
Então se liga aí que é hora da revisão:

public -> acessível a partir de qualquer classe em qualquer pacote.
protected -> acessível a partir de qualquer classe no mesmo pacote e por outras classes em outros pacotes através de herança.
default -> acessível a partir de qualquer classe no mesmo pacote.
private -> acessível somente a partir da classe que o declarou.

Até o próximo post.

Declarando membros de classes - Parte 2

2008-08-27T17:24:00.000-07:00

No post anterior nós estudamos sobre membros públicos. Vimos que eles são acessíveis a partir de qualquer classe. Neste post iremos estudar sobre os níveis protected e default. Isso porque eles são muito parecidos. E você vai notar rapidamente a diferença entre eles.

O nível default pode ser entendido como um nível de acesso de pacotes. Isso quer dizer que se você declarar um membro como default (na verdade você não vai colocar o modificador, lembra?) somente as classes que estiverem dentro do mesmo pacote que a sua terão acesso ao membro. Vamos pegar o exemplo anterior e retirar o modificador das variáveis de instância:


Animal.java
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) default
 //somente classes do mesmo pacote
 //poderão acessar o membro.
 String nome;
}

Gato.java

public class Gato extends Animal {
String raça;

public void mostrarNome(){
     System.out.println(nome); //pode?
}

}

package javeiro;
Exercicio1.java
public class Exercicio1 {

public static void main(String arg[]){
    Gato g = new Gato();
    g.nome = "Garfield"; //e aqui?
    g.raça = "preguiçoso"; //aqui também né?
}
}

O método mostrarNome numa primeira olhada parece fazer uma operação ilegal tentando exibir a variável nome, que é de Animal e está marcada como default. Porém não há problemas, pois as classes Animal e Gato estão no mesmo pacotes, isso significa que além de herdar os membros públicos, gato também herda os membros default, nós veremos mais adiante que é possível fazer uma classe herdar os membros default de uma classe que está em outro pacote. Já a classe Exercicio1 não será compilada com sucesso. O compilador irá dizer que não conhece a propriedade nome e muito menos raça do objeto gato. Por que isso acontence? Exatamente isso que você pensou, Exercicio1 está em um pacote diferente da classe Gato, e isso faz com ela possa acessar somente os membros públicos dela.

Membros protegidos (protected)

O nível protected é muito parecido com o nível default. A diferença básica é que os membros protegidos podem ser acessados por classes de pacotes diferentes, desde que estas sejam subclasses da sua classe. As outras regras são iguais, ou seja, os membros protegidos só podem ser acessados por classes que estão dentro do mesmo pacote (com a exceção que falamos antes). O exemplo que faremos irá elucidar as dúvidas que possam ter resistidos:


Animal.java
package javeiro.pacote1;
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) protected
 //somente classes do mesmo pacote
 //e subclasses poderão acessar o membro.
 protected String nome;
}

Gato.java
package javeiro.pacote2;
import javeiro.pacote1.Animal;

public class Gato extends Animal {
protected String raça;

public void mostrarNome(){
     System.out.println(nome); //herdou nome
}

}

package javeiro;
Exercicio1.java
public class Exercicio1 {

public static void main(String arg[]){
    Gato g = new Gato();
    g.nome = "Garfield"; //não pode
    g.raça = "preguiçoso"; //não pode
}
}

Temos aqui algo muito parecido com a versão anterior onde tínhamos os membros default. A diferença pode ser nota na classe Gato, que faz um acesso ao membro nome mesmo este sendo protected (deveria ser acessado por classes do mesmo pacote), porém membros protected são acessíveis por classes de outros pacotes através de herança. Já a classe Exercicio1 não compilará, pois está tentando fazer acesso a duas variáveis protegidas de classes de outros pacotes (Animal e Gato).
Então não esqueça:

DEFAULT -> Permite acesso aos seus membros SOMENTE às classes do mesmo pacote.
PROTECTED -> Permite acesso aos seus membros às classes do mesmo pacote e às classes de outros pacotes através de HERANÇA.

Até o nosso próxim post!

Declarando membros de classes - Parte 1

2008-08-26T17:47:00.000-07:00

Olá javeiros de plantão! Vamos continuar o nosso estudo sobre a certificação SCJP da sun. Continuaremos estudando o objetivo 1 (Declaração, inicialização e escopo), ah por falar nisso, você pode clicar aqui para ver os objetivos da prova de SCJP 5.0. Agora iremos estudar os objetivos 1.3 e 1.4 que está relacionado com a criação de membros de classes. Vamos fazer uma rápida revisão de POO. Sabemos que uma classe é composta por um nome, atributos (propriedades) e métodos. As propriedades e métodos forma o que nós chamamos de membros de uma classe, é sobre como declarar esses membros que nós vamos aprender neste e em mais alguns posts daqui pra frente. Pronto, a revisão acabou por aqui! Eu falei pra você que era rápida né!?

Você lembra quando nós falamos sobre os modificadores de acesso a classes e sobre os níveis de acesso? (Eu não lembro) Membros também possuem níveis de acesso assim as classes. Porém, eles possuem os quatro níveis, diferente das classes que só usam dois. Os níveis são mostrados abaixo na ordem do mais restritivo para o menos restritivo:

private -> default -> protected -> public

Antes de explicarmos cada um deles, você precisa saber que a visibilidade desses membros vai depender inicialmente da visibilidade das classes (do nível de acesso das classes). Ou seja, se uma classe não consegue enxergar a outra, não importa que nível de acesso tenha seus membros, a classe não consiguirá acessar nenhum deles (ainda que sejam públicos). Isso pode dar um boa pegadinha na prova, então fique bem atento. Vamos estudar os membros o contrário do que está apresentado acima, ou seja, do public para o private. Vamos nessa então.

Membros Públicos (public)

Quando você define uma classe como public, qualquer outra classe do mundo vai enxergá-la. Quando você define um membro como public, qualquer classe que consiga acessar a sua classe vai enxergar o seu membro (pegou mal essa frase :) . Só tenho que te dizer mais uma coisa com relação aos membros públicos, é que eles sempre são herdados pelas classes que estenderem a sua. Já podemos então partir para um exemplo:


Animal.java
//Classe public diz que todos vão enxergá-la
public class Animal {
 //Membro (variável) public,
 //quem tiver uma instância de Animal
 //ou estendê-la, poderá acessá-lo
 public String nome;
}

Gato.java
// Esta classe ganhou por herança todos
// os membros public de Animal
public class Gato extends Animal {
   public String raça;
}

package javeiro;
Exercicio1.java
public class Exercicio1 {

   public static void main(String arg[]){
         Gato g = new Gato();
         //posso acessar o membro public herdado
         g.nome = "Garfield";
         //posso acessar o membro public de Gato
         g.raça = "preguiçoso";
   }
}

Muito fácil não é mesmo? A classe Exercicio1 está em um pacote de diferente de Animal e Gato, porém por estas serem públicas permite o acesso de qualquer lugar. Vimos também que temos livre acesso à variável nome, que foi herdada de Animal, e também à raça, que é um membro público de Gato. A gente vai ver depois que isso não é muito legal de fazer na vida real, mas para aprendizado serviu como uma luva.
Por enquanto é isso, no próximo post falaremos sobre membros protegidos (protected).
Até o próximo post então.

Declarando Interfaces

2008-08-25T17:01:00.001-07:00

Saudações java a todos! Vamos continuar o nosso estudo para a certificação de programador java, agora com um assunto mais interessante: interfaces. Você já deve ter ouvido falar muito em interfaces né verdade? Provavelmente o termo: interface com o usuário. Bom, mas a interface que falaremos aqui é um pouco diferente, esta outra está relacionada normalmente com uma tela gráfica ou página web, a nossa tem a ver com herança e polimorfirsmo (vamos manter a sanidade).

Uma interface nada mais é que um contrato. Isso mesmo, não dá pra complicar, é simples mesmo. Um contrato possui clásulas que devem ser cumpridas por aqueles o assinaram. A diferença é que diferente dos contratos da vida real, os contratos das interfaces jamais poderão ser quebrados. Usando POO, uma interface define um comportamento que você deseja que determinadas classes tenham, por exemplo: Você possui um sistema de biblioteca, e você possui Objetos dos tipos Livro, Revistas, Cds, Dvds etc, mas estes objetos devem compartilhar uma característica como: poderem ser alugados. Como fazer isso usando o que há de melhor na POO? A resposta é: criando uma interface comum a todos esses objetos. Poderíamos ter uma interface nomeada como Alugavel, que deveria ser implementada por qualquer objeto da biblioteca que puder ser alugado. Aguente as pontas que em breve traremos um exemplo mais claro nesta seção.

As interfaces são simples porém poderosas. Quando bem utilizadas tornam o seu sistema muito mais claro e fácil de ser expandido. As interfaces, juntamente com as classes abstratas, permitem o uso do Polimorfismo, deixando o seu código claro e flexível.
Vimos que uma classe abstrata não pode ser instanciada e que todos os seus métodos abstratos deveriam ser implementados pela primeira classe concreta que a estendesse. Pois bem, uma interface é muito parecida com uma classe abstrata, com a diferença que a interface é totalmente abstrata, isso significa que você não poderá definir métodos concretos lá como numa classe abstrata. E não é só isso! Os contratos das interfaces são bem rígidos, vejamos algumas cláusulas deste contrato:

TODOS os métodos de uma interface SÃO públicos e abstratos. Eles já nascem assim. E não há nada que você possa fazer para mudar isso. Mesmo que você não coloque os modificadores public e abstract, para o compilador java é como se eles estivessem lá. Então os dois métodos abaixo são perfeitamente válidos em uma interface e fazem o mesmo efeito:
- public abstract void executar();
- void executar();
TODAS as variáveis de uma interface DEVEM ser públicas, estáticas e finais. Isso significa que uma interface só pode declarar constantes (e elas são bastante utilizadas para este fim).
Você NÃO pode declarar método final em uma interface, pois eles são abstratos por padrão (ponto 1). Um método de interface também NÃO pode ser: static, native, strictfp e nem syncchronized.
Interfaces PODEM fazer herança múltipla. Yes, man they can. Uma interface pode herdar de quantas outras interfaces ela quiser.
Uma interface NÃO pode implementar outra interface e nem pode estender de nada que não seja interface.
Você pode ou não utilizar o modificador abstract na declaração da interface. Já a palavra interface é obrigatória.

Esses cinco pontos são o que você precisa saber sobre interfaces. A seguir traremos alguns exemplos de uso das mesmas para fixarmos o conteúdo.

// abstract é opcional aqui
public abstract interface Alugavel {
//aqui é implicitamente public static final
int TEMPO_MAXIMO_ALUGUEL = 7; //É comum definirmos como constantes

 //aqui é implicitamente public abstract
 void alugar(); // não tem '{'
}

//utiliza a palavra implements para implementar a interface
public class Livro implements Alugavel {
 //precisa ser implementado e publico
 public void alugar() {
      //regras de negócio aqui
 }
}

Em uma outra oportunidade falaremos um pouco sobre o Polimorfismo. Por enquanto isso é tudo o que você precisa saber sobre interface para se dar bem na prova.

Até o próximo post.

Identificadores e Palavras Reservadas

2008-08-25T15:01:00.000-07:00

Este tópico é bastante simples porém é fruto de muitas pegadinhas na hora da prova. E pode apostar que a prova vai estar cheia delas. Então para evitarmos perder questões bobas vamos aprender neste post como declarar identificadores, que nada mais são que os nomes de nossas variáveis, métodos e classes.
As regras de nomenclatura dos identificadores em java são muito parecidas com as de outras linguagens como delphi, c, c++ etc. Antes de listarmos as regras é preciso saber que o java utiliza a codificação Unicode para os arquivos de código fonte. As regras são as seguintes:

Os identificadores DEVEM começar com uma letra, um cifrão ($) ou com um underscore (_).
Após o primeiro caractere pode ser usado qualquer outro caractere do conjunto Unicode.
NÃO se pode usar uma palavra reservada (vamos já saber o que é isso) como identificador.
Em java, os identificadores são case sensitive. Então você pode definir gato e Gato como duas coisas diferentes;

Para fixar os conceitos, abaixo está uma lista contendo identificadores válidos:

int _var;
double ist0_é_válido; //não recomendo, mas é válido
float R$100; //legal né? :)
int ________________Legal;

Palavras reservadas da linguagem Java:

`abstract`	`continue`	`for`	`new`	`switch`
`assert`^***	`default`	`goto`^*	`package`	`synchronized`
`boolean`	`do`	`if`	`private`	`this`
`break`	`double`	`implements`	`protected`	`throw`
`byte`	`else`	`import`	`public`	`throws`
`case`	`enum`^****	`instanceof`	`return`	`transient`
`catch`	`extends`	`int`	`short`	`try`
`char`	`final`	`interface`	`static`	`void`
`class`	`finally`	`long`	`strictfp`^**	`volatile`
`const`^*	`float`	`native`	`super`	`while`

^*		Não utilizada
^**		Adicionada em 1.2
^***		Adicionada 1.4
^****		Adicionada 5.0

Ao todo são 50 palavras reservadas. A má notícia é que você terá que saber todas elas, então utilize a sua técnica de memorização preferida e boa sorte... Mas você verá que não é tão difícil assim quanto parece. Especialmente se você já trabalha com java ou está sendo obrigado a fazer isso (faculdade por exemplo). Para ajudar você a memorizar vamos fazer uma pequena divisão:
De quebra já devemos saber os tipos primitivos, são 8:

boolean, byte, char, double, float, int, long, short.

Utilizadas em definição de classes e métodos, são 15:

abstract, class, enum, final, interface, native, private, protected, public, static, strictfp, synchronized, transient, void, volatile.

Utilizadas em laços e retornos de métodos, são 9:

break, case, continue, default, do, for, return, switch, while.

Utilizadas em tratamentos de exceção, são 5:

catch, finally, throw, throws, try.

Estruturas condicionais e verificações, são 3:

if, else, instanceof.

Usadas em herança, são 2:

extends, super.

Importação e definição de pacote, são 2:

import, package.

NÃO SÃO UTILIZADAS, são 2:

goto, const.

Adicionadas recentemente, são 2:

assert, enum;

Criação de objetos e acesso à classe executando, são 2:

new, this.

Não fiquei muito preocupado pois você verá essas palavras tantas vezes que talvez nunca mais consiga esquecê-las.
Até o nosso próximo post.

Declarar Classes - Parte 3

2008-08-25T14:29:00.000-07:00

No post anterior vimos que uma classe pode ter dois níveis de acesso: publico e padrão. Para dar à classe acesso publico, utilizamos o modificador public, para o padrão basta não colocar nada. Além dos modificadores de acesso à classe, o java possui outros modificadores que também podem ser aplicados a classes, mas que não estão relacionados ao acesso a estas. Os modificadores são:

strictfp
final
abstract

O modificador strictfp pode ser utilizado tanto em classes quanto em métodos. Você não precisa saber muita coisa sobre ele, mas se quiser saber um pouquinho mais é só clicar aqui. Na realidade o que você precisa saber mesmo é que ele pode ser usado na declaração de um método ou de uma classe, seja ela final ou abstract.

Bem, já que tocamos no assunto, o modificador final pode ser utilizado para declara um método, propriedade (variável) ou uma classe. O modificador final quando usado em uma classe faz com esta não possa mais ser extendida, ou seja, a sua hierarquia chegou ao final (essa foi podre). Mas será que alguém pode querer que uma classe não possa ser extendida? Claro que sim. Inclusive a Sun pensa assim. A classe String é uma classe final, ou seja, você não pode herdar jamais de String. Isso pode ser escolhido também por uma questão de segurança ou qualquer coisa que o valha.

Para finalizar temos o modificador abstract. Ele pode ser utilizado em classes e em métodos. Vale lembrar que se uma classe tiver pelo menos um misero método abstrato esta classe deverá ser abstrata, porém uma classe pode ser abstrata e não ter nenhum método abstrato... Agora embolou tudo né?. Bem, primeiro precisamos saber o que é uma classe abstrata. Uma classe abstrata (abstract) é uma classe que não pode ser instanciada, ou seja, se você quiser usar uma algum dia desses, a única forma de fazê-lo será estendendo-a.

Quando você herdar de uma classe abstrata você terá a obrigação de implementar todos os métodos abstratos da mesma, a menos, é claro, que a sua classe também seja abstrata. O fato é que um dia alguém vai fazer uma classe concreta e ela vai ter que definir todos, eu disse, todos os métodos abstratos não implementados de toda a árvore de herança... eu não faria isso se fosse você! E se os meus métodos forem todos concretos? Aí você ganhará um monte de método por herança, legal né?

Você pode combinar os modificadores a vontado... quer dizer, quase né. Os modificadores final e abstract nunca poderão ser combinados, pois isso causará uma crise de existência no compilador java. Uma classe final não pode ser nunca extendida e uma classe abstract deve ser obrigatoriamente extendida... entendeu por que não dá pra combinar né? Ah, o strictfp pode ser usado tanto em classes finais como em abstratas.
Agora para fixar os conceitos vamos trazer alguns exemplos do que vimos até aqui.


Animal.java
//posso combinar strictfp e abstract
//Essa classe deverá ser herdada por alguém
public strictfp abstract class Animal {
 
 //Esse método precisa ser implementado 
 //em alguma subclasse concreta
 public abstract void emitirSom();
 
 //Esse método será herdado por todas as subclasses
 public strictfp void contarAteDez() {
  for (int i = 0; i < 10; i++) {
   System.out.println(i);
  }
 }
}

Dog.java
// Esta classe não poderá ser herdada por ninguém mais
public final strictfp class Dog extends Animal {

 //Implementou o método abstrato, ou sobrescreveu.
 @Override
 public void emitirSom() {
  System.out.println("Auf auf"); 
  contarAteDez(); //posso chamar o método herdado aqui também
 } 

}

ViraLata.java
//ViraLata não pode herdar de Dog
//pois Dog é uma classe final
public class ViraLata extends Dog {

}

A classe Animal é uma classe abstrata e faz uso também do modificador strictfp. Essa classe possui um método abstrato que deverá obrigatoriamente ser implementado por uma subclasse concreta e possui um método concreto que será herdado por todas as subclasses. A classe Dog estende a classe Animal e implementa o seu método abstrato emitirSom, podemos ver que ela chama o método contarAteDez que foi herdado de Animal, ou seja, o nosso cachorro herdou a capacidade de contar até dez do animal. E por fim a classe ViraLata tenta sem sucesso estender a classe Dog que é uma classe final e não pode ser estendida nem sob a mira de uma arma.

No próximo post vamos aprender a nomear nossas classes e vamos trazer também a lista de palavras reservadas da linguagem java. Até lá.

Declarar Classes - Parte 2

2008-08-24T10:52:00.000-07:00

Continuando nosso estudo, iremos agora trazer a segunda parte do objetivo 1.1 que são os modificadores de acesso a classe do java.

O java possui quatro níveis de acesso, porém somente três modificadores de acesso.Parece esquisito mas é isso mesmo. Os modificadores são:

public
protected
private

A vida de um programador java é escrever classes. Mas acontece que essas classe precisam interagir com outras classes (de outros programadores, inclusive os da sun :)). E para que haja essa interação é necessário que a classe que você escreveu tenha 'acesso' às classes dos outros seres. E são os modificadores de acesso que vão definir quem pode acessar sua classe. Acredito que não exista nada mais óbvio do que isso, mas vamos continuar. O java possui dois níveis de acesso à classes: default e public. Peraí, mas você não disse que o java tinha quatro níveis de acesso? É verdade, mas falando em acesso a classe, só podemos utilizar dois deles. Nas próximas seções falaremos sobre os outros modificadores. Então a coisa fica assim:

Se você escreveu uma classe public, qualquer classe do mundo terá acesso a ela. E quando eu falo de acesso, é no sentido de poder criar uma instância ou um objeto da mesma.
Se você escreveu uma classe e NÃO colocou o modificador public nela, então, somente as classes que estivem dentro do mesmo pacote que ela poderão acessá-la. Ou seja, qualquer classe fora do seu pacote nem mesmo saberá que a sua classe existe.

Vamos colocar um pequeno exemplos para firmar o objetivo melhor:


Animal.java
package javeiro;

class Animal {

}

Cat.java
package zoo;

import javeiro.Animal;

class Cat extends Animal{

}

Temos um problema aí. A classe Animal está definida como default e está dentro do pacote javeiro. Isso torna a classe invisívei para qualquer classe fora do pacote javeiro. Assim, a classe Cat terá uma bela surpresa quando tentar herdar da classe animal, o compilador java vai dizer pra ela: Ei Cat, eu não sei que Animal é esse... bem na verdade isso foi uma transliteração do erro: zoo\Cat.java:4: cannot find symbol, mas dá no mesmo. O ponto aqui é que Cat não enxerga Animal, pois o acesso default garante que só as classes dentro de javeiro poderão enxergar Animal.

Não vou colocar o exemplo da classe public porque é óbvio demais. Se você escreveu uma classe e definiu o acesso dela como public, então não adianta chorar, todo mundo vai enxergar sua classe, não importa onde ela ou eles estejam.

Até o próximo post.

Declarar Classes - Parte 1

2008-08-24T08:42:00.000-07:00

Vamos dar início ao estudos dos objetivos da prova de programador a partir deste post. O nosso foco será a prova de programador SCJP 5.0, o código é 310-055, mas sempre que for possível falaremos um pouco da prova 6.0, cujo o código é 310-065. Quem quiser outra fonte de estudos, aconselho o livro mundialmente recomendado da Kathy Sierra e há também uma série de guias da Revista Mundo Java que ajudam bastante, especialmente para momentos antes da prova.

Bom mas vamos deixar de lenga lenga e começar a estudar de verdade.

Um bom programador java precisa saber escrever corretamente uma classe. Existem algumas regrinhas básicas que precisamos saber antes de começarmos a programar feito loucos, e elas são:

Em um arquivo .java só pode haver uma classe pública (public class).

Comentários podem ser colocados em qualquer linha

o nome do arquivo deve ser o mesmo da classe pública dele, se não tiver nenhuma, então pode ser qualquer nome :)

Se a classe estiver em um pacote (package), a declaração do mesmo deve ser a primeria do arquivo (comentário não conta viu)

os imports, se existirem claro, devem vir logo após a declaração de pacote, e se não houver uma, deve vir em primeiro lugar no arquivo.

Abaixo temos um exemplo do que falamos acima, o arquivo foi nomeado como MyClass.java:


//aqui pode ter comentário sem problema
package javeiro; //declaração de pacote em primeiro lugar
import java.util.Date; // declaração de import

public class MyClass {

  public static void main(String args[]) {
       Date d = new Date();
       System.out.println(d);
  }
}

// posso ter zilhões de classe não públicas em um arquivo
class MyOtherClass {

}

class MyAnotherClass {

}

Algumas informações sobre a prova

2008-08-24T07:51:00.000-07:00

Antes de começarmos a estudar os objetivos da prova de certificação, vou trazer algumas informações sobre a prova, para que não sejamos surpreendidos no dia do teste. Pra começar, a sun disponibiliza atualmente a opção de 3 provas de SCJP, e claro, seus respectivos updgrades para aqueles que já fizeram a prova e desejam apenas se atualizar. As opções são:

SCJP 1.4 e Upgrade

SCJP 5.0 e Upgrade

SCJP 6.0 e Upgrade

A primeira, 1.4, é composta de 61 questões e você disporá de 120 minutos para respondê-las e terá que acertar no mínimo 32 questões (52% da prova), se nos fizermos um cálculo do tempo/questão você tem em média 1m:58s para responder cada questão, parece pouco né, mas reza a lenda que dá tempo de sobra.

A segunda é composta de 72 questões e o tempo agora é de 175 minutos e você precisa acertar 43 questões (59% da prova). Agora você tem 2m:25s para cada questão. A sun engrossou o caldo no número de acertos mas em compensação o tempo para cada questão agora é maior.

A última, na verdade a mais atual, é a bola da vez, é o que há de mais moderno e logicamente nosso conselho é que você faça ela, a menos claro, que você já tenha comprado o voucher e marcado a prova :( eu \o/. E se você achou que sun foi cruel ao aumentar o percentual de acertos da prova 5.0, então sente-se pois a coisa ficou ainda pior. A prova do Mustang (esse o nome do java 6.0, vc não sabia?) é composta também de 72 questões só que agora você terá que acertar 47 questões, isso equivale a 65% da prova. Peraí, mas a sun não tão é cruel como você está pensando, olha só que mamada ela deu: você tem agora 210 minutos para terminar sua provinha, o que dá mais ou menos 2m:55s por questão. Bom, não quero ser estraga prazeres mas dizem as más línguas que a prova ficou mais difícil agora... mas com a ajuda do javeiro você poderá chegar lá.

Já ia me esquecendo do detalhe polêmico: A língua da prova. Polêmico porque a prova é disponibilizada para nós ocidentais em inglês, alemão, espanhol e português. Mas acontece que todo mundo manda você fazer a prova em inglês, por questões que não nos cabe discutir neste momento. Mas fique a vontande para 'arriscar' escolher outra língua.

Se o que nós falamos neste post não foi suficiente para você, visite esse site para obter mais informações sobre as provas.

No mais eu só posso desejar bons estudos e boa sorte para todos nós.

Até o nosso próximo post.

Estamos de volta

2008-08-23T14:30:00.000-07:00

Após um período de inatividade, em virtude do nascimente do meu filho Mateus, retornamos agora com a bola toda. Irei trazer a partir de agora posts sobre Java, mais especificamente sobre o conteúdo da prova de certificação de programador (SCJP). Então segura aí que logo logo estarei postando os primeiros artigos. Então até o próximo post!

Casa da Bíbla Online

2008-06-28T06:45:00.000-07:00

O que já era bom ficou ainda melhor. Para todos que já conheciam a casa da bíblia, renomada loja de artigos evangélicos, agora ficou mais fácil comprar. Desde o mês de junho a casa da bíblia passou a funcionar também na internet. Então pra você que como eu morria de preguiça de ir até ao centro da cidade para comprar livros, revistas e outros artigos, basta agora acessar o site da Casa da Bíblia e fazer todas as suas compras sem tirar o pé de casa. Boas compras e até o próximo post.

2 pelo preço de um (ou não)

2008-06-27T17:48:00.000-07:00

Hoje tivemos uma dia muito agitado lá no trabalho. Afinal de contas não é todo dia que a Dell resolve doar (acho que essa seria uma boa palavra pra isso..rs) seus notebooks. O ocorrido iniciou-se após um dito cujo saber por meio de outro dito cujo que a Dell estava com uma promoção: 02 Notebooks pelo preço de 1. Bom, aí já deu pra imaginar no que deu né. Isso mesmo, todo mundo comprando carradas de notebooks. Parecia pegadinha, brincadeira de mau gosto, coisa de hacker, mas ninguém tava nem aí pra isso, o negócio tava baratinho e todo mundo queria garantir o seu. Bom, eu sou bem conservador (burro) para essas coisas e resolvi esperar pra ver no que ia dar. Quando finalmente decidi comprar o note, aí vem a notícia bombástica: Página foi tirada do ar. Para a minha frustação e preocupação dos compradores. 22 note no total..rs, alguns ligaram pra Dell e esta informou que o site estava errado (parece ter sido coisa de estagiário, mas isso é só especulação..hiuaha). Chegou ao final do expediente e os compradores continuavam muito satisfeitos com a recente aquisição. Todos aguardando ansiosamente a manifestação da Dell (ou não né :)) para saber se vão receber o produto ou não. Bom, eu acho que o PROCOM vai ter um trabalho nesse mês de Julho. Só posso lamentar por não ter comprado também :) e desejar boa sorte aos que compraram. Que presentão de Natal! Até o próximo post!

Colocando sua aplicação na SystemTray

2008-06-25T04:09:00.000-07:00

O java 6 trouxe uma série de recursos novos e interessantes para aplicações desktop. Um deles, e que há muito era solicitado, é o de colocar uma aplicação java para rodar na SystemTray. SystemTray para quem não sabe é aquela espacinho que fica perto do relógio onde normalmente você tem um monte de ícones, que são também um monte de programa rodando. Bom, mas não fique triste se você ainda não tem o java 6 na sua máquina (não sei porquê, mas tudo bem), pois existe uma solução para fazer isso no java 5, que é a biblioteca JDIC.
Iremos fazer uma aplicação besta, que não faz absolutamente nada a não ser colocar o programa na tray. Mas explicaremos aqui os principais conceitos para você fazer programas de gente grande com esse novo recurso. Então vamos ao código. \o/
Iremos supor que você já sabe java :) e assim iremos pular alguns conceitos básicos.
Se você não quiser ter trabalho lendo tudo isso aqui, você pode também baixar o projeto protinho. Coloquei alguns comentários no código fonte pra dar uma ajudinha.


import java.awt.AWTException;
import java.awt.FlowLayout;
import java.awt.MenuItem;
import java.awt.PopupMenu;
import java.awt.SystemTray;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;

/**
 *
 * @author Robson de Araújo - http://javeiro.blogspot.com
 */
public class Janela extends JFrame{
    private JButton botao;
    private TrayIcon trayIcon;
    
    public Janela() {
        setTitle("Minha Janela");
        setLayout(new FlowLayout());
        add(botao = new JButton("Enviar para a tray"));        
        criarTrayIcon();
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(200,100);
        setLocationRelativeTo(null);
        adicionarListeners();
        setVisible(true);                
    }   
    
    // habilita os listeners
    private void adicionarListeners(){
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowIconified(WindowEvent e) {
                adicionarATray();
            }            
        });
        
        botao.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                adicionarATray();
            }
        });
    }
    
    private void criarTrayIcon() {
        SystemTray tray = SystemTray.getSystemTray();
        // Verifica se o sistema suporta Ãcones na system tray
        if (!tray.isSupported()) {
            System.out.println("Não é possível executar a app");
            System.exit(0);
        }
        
        //icone q será exibido na bandeja
        ImageIcon icon = new ImageIcon("images/icone.gif");
        setIconImage(icon.getImage());

       // cria um menu popup para interagir com a aplicação na system tray
       PopupMenu menu = new PopupMenu();
       MenuItem itemRestaurar = new MenuItem("Restaurar");
       itemRestaurar.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // remove a aplicação da tray
                SystemTray.getSystemTray().remove(trayIcon);
                setVisible(true);
            }
        });
        
        MenuItem itemSair = new MenuItem("Sair");
        itemSair.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });

        menu.add(itemRestaurar);
        menu.add(itemSair);
        
        // cria o ícone e adiciona o menu a ele
        trayIcon = new TrayIcon(icon.getImage(), "Server",menu);
        trayIcon.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() == 2) {
                    SystemTray.getSystemTray().remove(trayIcon);
                    setVisible(true);
                } 
            }            
        });
    }

    private void adicionarATray() {
        try {
            // esconde a janela
            dispose();
            //adiciona seu programa a systema tray
            SystemTray.getSystemTray().add(trayIcon);
            // aquele balãozinho que aparece qdo o programa tá lá :)
            trayIcon.displayMessage("Minha Janela", "Minha Janela está executando.", TrayIcon.MessageType.INFO);
        } catch (AWTException ex) {
            System.out.println(ex.getMessage());
        }
    }
    
    public static void main(String[] args) {
        new Janela();
    }
}

Aplicação executando :)

Aplicação executando na SystemTray

Menu da aplicação na SystemTray

Se você desejar aprender mais sobre SystemTray é só visitar o site do Java que foi de onde eu tirei parte deste tutorial. Por enquanto é isso. Até o próximo post!

Reporter Inexperiente

2008-06-22T11:09:00.000-07:00

Muito engraçado esse quadro do CQC da band...

Em tempos de olimpíada, nada como relembrar

2008-06-20T16:57:00.000-07:00

Essa aqui é com direito a mixagem com som do Dota e tudo mais...hihuaiuah

Essa da porta é fantástica também... A galera era sem noção mermo.

Pra começar...

2008-06-20T15:34:00.000-07:00

Olá,
meu nome é Robson, e criei esse blog pra discutir sobre a tecnologia java e outras cositas mais. A intenção também é "desarnar" (sei nem se essa palavra existe, mas a minha vó usa é muito) nessa coisa de escrever, afinal de contas já já vou ter que fazer monografia (argh) e é bom já ir treinando. Espero colocar alguma coisinha útil aqui de vez em quando. Portanto seja bem vindo ao meu blog e aproveite pra divulgá-lo também. Quero aproveitar e divulgar o blog do meu chapa "cabeludo" (http://caixadebreguecos.blogspot.com/), o cara que me fez ingressar no insano mundo das ações (Eu devia matar ele, mas não seria um ato muito cristão). Até o próximo post!