Introdução ao JavaScript - Parte 1

Hoje teremos um post sobre JavaScript pra variar um pouco. Farei este post em duas partes. Na primeira vou fazer uma introdução sobre a linguagem dando alguns conteitos básicos e também falarei sobre variáveis e eventos. Na próxima parte teremos objetos importantes, suas propriedades e também sobre semelhanças com a linguagem Java.

O que é JavaScript?

De acordo com a famosa enciclopédia digital "JavaScript é uma linguagem de programação criada por Brendan Eich para a Netscape em 1995, que a princípio se chamava LiveScript. A Netscape, após o sucesso inicial desta linguagem, recebeu uma colaboração considerável da Sun, a qual possibilitou posteriormente dizer que o JavaScript é uma linguagem compatível com a linguagem Java, por esta razão, a semelhança dos nomes."

Pontos importantes sobre JavaScript quanto aos tipos:

• fraca - sua tipagem é mutável;
• dinâmica - uma variável pode assumir vários tipos diferentes durante a execução;
• implícita - as variáveis são declaradas sem tipo.

Porque usar JavaScript? JavaScript permite tornar páginas HTML mais dinâmicas. Usamos a linguagem para interagir com a página, validar formulários, etc. Vamos ao que interessa.

10 Perguntas básicas sobre JavaScript

Estas perguntas foram baseadas num quiz disponível aqui. É necessário obter 100% pra dizer que se tem um conhecimento básico sobre JavaScript.

1. Qual elemento é utilizado para os scripts?

Em uma página HTML colocamos os códigos JavaScript dentro de tags script, como mostra o exemplo:

2. Qual é o lugar correto para inserir JavaScript?

Os scripts podem ser inseridos tanto no cabeçalho(head) quanto no corpo(body) da página.

3. Qual a sintaxe para fazer referência a um script externo?

Scripts externos devem ser salvos com a extenção js e podem ser referenciados utilizando o parâmetro src:

4. Arquivos JavaScript externos precisam ter a tag script?

Não, somente códigos.

5. Como escrever um texto na página?

Para escrever na página usa-se document.write:

document.write("Hello World");

6. Como mostrar mensagens utilizando uma caixa de alerta?

Mensagens podem ser exibidas numa caixa de alerta simplesmente chamando:

alert("Hello World");

7. Como criar uma função?

Funções podem ser criadas utilizando a palavra function, veja:

function myFunction()
{
//Códigos da função
}

8. Como chamar uma função?

Funções podem ser chamadas simplesmente digitando seu nome:

myFunction()

9. Como abrir uma janela?

Pode-se abrir uma janela chamando window.open:

window.open("http://marciosouzajunior.blogspot.com");

10. Como colocar uma mensagem de status no navegador?

Mensagens de status são uma propriedade do objeto window e podem ser modificadas diretamente:

window.status = "Mensagem";

Obviamente existe muito mais sobre JavaScript que você deveria saber. Essas perguntinhas foram apenas pra você poder falar com os amigos que sabe alguma coisa de JavaScript. E também se algum dia for fazer uma prova que caia JavaScript, não passe em branco. Vamos ver outras coisas importantes agora.

Variáveis

JavaScript possui 3 tipos de dados: número, caractere e booleano. Não tem segredo. Como já foi dito, as variáveis podem ser declaradas sem um tipo específico. A simples associação de um valor faz com que a variável passe a existir:

x = 2;

E seu tipo pode mudar como quiser:

var x = 2;
alert(x);
x = "texto";
alert(x);

Usar a palavra var é opcional. Usamos apenas quando queremos declarar a variável sem um valor inicial. Se fizermos isto o seu valor será undefined. Também podemos associar um valor null, que é quase a mesma coisa que undefined.
Não tem muito o que falar sobre variáveis em JavaScript, os criadores da linguagem deixaram as coisas bem simples de trabalhar.

Eventos

Eventos são coisas que podem acontecer durante a execução de um programa (neste caso da página). Um clique de mouse, uma caixa que perde o foco, são eventos que podem ocorrer a qualquer momento. Podemos desejar que esses eventos disparem alguma ação. Logo abaixo temos uma lista de eventos que o JavaScript pode capturar e quando eles acontecem:

• onLoad: Quando a página é carregada.
• onUnload: Quando a página é fechada.

Esses dois eventos só ocorrem no body, portanto poderiam chamar alguma ação da seguinte forma:

<_body onload="alert('Oi');">

Todos sabemos que body não tem underline, mas sou obrigado a escrever assim porque mais uma vez o blogger está confundindo as coisas. Espero que todos tenham entendido. Continuando...Agora vamos ver 3 eventos que podem ocorrer em objetos text, select e textarea:

• onChange: Acontece quando o objeto perde o foco e houve mudança de conteúdo.
• onBlur: Acontece quando o objeto perde o foco, independente de ter mudado o conteúdo.
• onFocus: Quando o objeto ganha o foco.

Aqui temos um exemplo:

O próximo evento pode ser usado para text e textarea:

• onSelect: Ocorre quando seleciona parte ou todo texto do objeto.

Os próximos eventos tem a ver com o mouse:

• onClick: Quando o objeto é clicado. Pode acontecer nos objetos button, checkbox, radio, link, reset e submit.
• onMouseOver: Quando passa o mouse sobre o objeto.
• onSubmit: Quando clica no botão submit. Váido somente para forms.

Exemplo:

 Blog do Márcio 

Certamente numa prova de JavaScript teria pelo menos uma questão sobre esses eventos. Principalmente sobre o evento onBlur, porque facilmente alguém acreditaria que um suposto evento onLostFocus estaria certo.

Fim da Parte 1

Bom, ficamos por aqui com esta introdução ao JavaScript. Espero que você possa ter tirado algum proveito do material. Em breve teremos a segunda parte com mais informações sobre os objetos document, window e também sobre semelhanças com a o Java.

Bons estudos!

Enums - Java

Enums são um tipo de classe Java que quase nunca utilizamos. Acredito que muita gente nem imagina que esse tipo de classe existe. Diferente de classes comuns e interfaces, o Enum foi inserido na versão 5 do Java. Ele permitie enumerar uma quantidade de valores pré-definidos que podem ser aceitos para uma variável.
Vamos a um exemplo prático. Precisamos de uma variável que só aceite 3 valores: maçã, pera e uva. Então declaramos:

enum Frutas { MAÇÃ, PERA, UVA }; //É opcional colocar ponto-e-vírgula

Obs.: Por convenção as constantes são escritas em maiúsculas. Um Enum é constituido basicamente por suas constantes, mas logo veremos que podem existir outras coisas a mais. Eles podem ser declarados como membro de uma classe ou fora da classe, mas nunca dentro de métodos (inclusive o main). Outro ponto importante é que os Enums só aceitam os modificadores default e public (não aceita private, protected, final, abstract nem static). Veja um exemplo de declaração fora da classe:

enum Frutas { MAÇÃ, PERA, UVA }

public class Run {

 Frutas tipo; //Run tem uma variável de instância do tipo Frutas

 public static void main(String[] args) {
 
     Run r = new Run();
     r.tipo = Frutas.MAÇÃ;
 
 }
}

Enums não são do tipo String ou de outro tipo. Eles são do seu próprio tipo, neste caso Frutas. MAÇÃ, PERA ou UVA são tipos de Frutas. Se fizermos o teste:

if (Frutas.MAÇÃ instanceof Frutas)
 System.out.println("Maçã é do tipo Fruta");

O resultado será: Maçã é do tipo Fruta

Então sabemos o que são Enums, como e onde declará-los. E também sabemos que por ser uma classe, tem seu próprio tipo. Agora vamos ver umas coisas mais interessantes.

Construtores, Métodos e Variáveis em um Enum

Como os Enums são um tipo especial de classe, eles podem ter construtores, variáveis e até um corpo de classe para as constantes (mais adiante explico o que é essa coisa bizarra). Vamos ver como funcionam esses membros passando um parâmetro para cada constante:

 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa");

Cada tipo de fruta agora recebe um parâmetro do tipo String, como numa chamada de método normal (poderíamos ter outros tipos, dependendo do construtor). De acordo com os argumentos, neste caso teríamos o seguinte construtor:

 Frutas(String cor){
     this.Cor = cor;
 }

Sendo assim, devemos ter uma variável de instância para receber a cor:

 private String Cor;

E ainda um método para retornar a cor da fruta escolhida:

 void getCor(){
     System.out.println("A cor da fruta escolhida é " + Cor);
 }

O Enum completo ficaria assim:

enum Frutas {

 //Passando parâmetros a cada constante
 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa");

 //Construtor
 Frutas(String cor){
     this.Cor = cor;
 }
 //Variavel de instância
 private String Cor;

 //Método que mostra a cor da fruta escolhida
 void getCor(){
     System.out.println("A fruta escolhida é " + Cor);
 }

}

Observe que quando temos mais membros além das constantes é obrigatório o ponto-e-vírgula após as constantes.
Agora modifique a classe Run para que fique parecida com esta:

public class Run {

 Frutas nome;

 public static void main(String[] args) {
 
     Run r = new Run();
     r.nome = Frutas.MAÇÃ;
     r.nome.getCor();
 }
}

A saída será: A fruta escolhida é vermelha

Sobre o construtor do Enum devemos saber que ele nunca poderá ser invocado diretamente. Ele só pode ser chamado pelo próprio Enum, ou melhor, por cada constante. Os construtores também podem ser sobrecarregados, como no exemplo:

 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa", "verde");

 Frutas(String cor){
     this.Cor = cor;
 }
 //Construtor sobrecarregado
 Frutas(String cor, String cor2){
 }

Corpo de Classe específico da constante

Como eu mencionei anteriormente, os Enums podem possuir uma coisa estranha chamada corpo de classe específico da constante. Esse corpo é um bloco de código que podemos definir para cada constante. Usamos esse corpo para substituir um método definido dentro do Enum. Vamos ver na prática:

enum Frutas {

 MAÇÃ,
 PERA,
 UVA{
     //Corpo da constante UVA
     //Códigos legais aqui...
 };

 void getFoo(){
     System.out.println("Frutas são saudáveis.");
 }

}

Observe que se chamarmos por r.nome.getFoo(), independente de qual fruta tenha sido escolhida, sempre teremos a saída: Frutas são saudáveis. Porém agora vamos sobrescrever o método dentro do corpo da constante UVA:

enum Frutas {

 MAÇÃ,
 PERA,
 UVA{
     void getFoo(){
         System.out.println("BAD FRUIT!!!");
     }
 };

 void getFoo(){
     System.out.println("Frutas são saudáveis.");
 }

}

E então chamamos:

     r.nome = Frutas.UVA;
     r.nome.getFoo();

A saída será: BAD FRUIT!!!

Ok, mas pra que fazer isso? Imagine que todos os elementos do Enum tenham uma propriedade, um código por exemplo. Mas um determinado elemento não pode ter aquele código. Então usamos o corpo da constante para definir um comportamento especial pra ele. É realmente difícil imaginar uma aplicação para isso, mas apenas saiba como funciona que será o bastante para passar no exame! E por hoje é só.

Bons estudos!

Menu Dinâmico - Java

Olá! Hoje vou mostrar como implementar um menu dinâmico. Na verdade eu usei esta aplicação para gerar um menu com todos os LookAndFeels disponíveis. Criar menus ou qualquer outro tipo de objeto dinâmico significa que ele é criado em tempo de execução. Mas pra que fazer isso? Por exemplo, num sistema ERP cada usuário tem um nível de acesso, então dependendo de quem logar no sistema, determinados itens no menu estarão disponíveis ou não. O sistema verifica no banco de dados quais as permissões daquele usuário e monta o menu em tempo de execução.
Mas no exemplo que vou mostrar não usa banco de dados, mas seria interessante implementar alguma forma de salvar o LookAndFeel selecionado. Porque fazer isto dinamicamente? Neste caso o menu teria que ser dinâmico porque os LookAndFeels podem ser instalados ou removidos da JRE.
Também vou mostrar como escrever um ActionListener que será usado ao acionar os eventos dos itens no menu.

Utilizando LookAndFeels

Antes de mais nada vamos fazer os seguintes imports:

import javax.swing.UIManager;
import javax.swing.UIManager.LookAndFeelInfo;

E também declarar uma variável de instância:

static LookAndFeelInfo skins[] = UIManager.getInstalledLookAndFeels();

Agora temos um array com os LookAndFeels disponíveis. Deixaremos como static para não ter que instanciar depois quando for preciso chamar no Listener (mais adiante você vai entender).

Montando o Menu

Para montar o menu eu criei um método que retorna um tipo JMenuBar. Para adicionar o menu na sua aplicação simplesmente chame o método dentro do construtor:

super.setJMenuBar(montaMenu());

O método é algo parecido com isto:

JMenuBar montaMenu(){

//Cria a barra
JMenuBar barraMenu = new JMenuBar();

//Cria o menu
JMenu menuSkins = new JMenu("Skins");

/*Aqui vamos adicionar os itens dinamicamente no menu Skins
Mas por enquanto um pouco de suspense....*/

//Adiciona o menu na barra
barraMenu.add(menuSkins);

//Retornamos a barra prontinha
return barraMenu;

}

Bom, agora só falta adicionar os itens no menu Skins. Esta parte pode parecer um pouco confusa a primeira vista mas não é!
Primeiramente vamos criar um array do tipo JMenuItem do tamanho de skins.length, isto é, com quantas posições forem necessárias para acomodar todos os LookAndFeels instalados.

JMenuItem itemSkin[] = new JMenuItem[skins.length];

Agora criamos outro array do tipo myListener (???) para os ActionListeners dos itens declarados acima. Calma que logo veremos essa classe myListener. O tamanho do array segue o mesmo exemplo mostrado.

myListener [] eventosMenu = new myListener[skins.length];

Agora vai ficar bom! Vamos entrar num for passando por todos skins:

for (int skin = 0; skin /*sinal de menor aqui*/ skins.length; skin++)
{
 itemSkin[skin] = new JMenuItem(skins[skin].getName());
 eventosMenu[skin] = new myListener(skin);
 itemSkin[skin].addActionListener(eventosMenu[skin]);
 menuSkins.add(itemSkin[skin]);
}

O que acontece? Primeiro o array itemSkin recebe um item com o nome do LookAndFeel. Então um Listener é criado no array e recebe como parâmetro o número daquele skin (mais adiante explico porque). Depois o ActionListener é adicionado ao item. Por último o item é adicionado ao menu. Nao esqueça de colocar o sinal de menor no for onde está comentado, se eu colocar o Blogger pensa que é uma tag e atrapalha tudo! Se alguém souber como desativar essa verificação me avise!
O método deverá ficar assim:

JMenuBar montaMenu(){

//Cria a barra
JMenuBar barraMenu = new JMenuBar();

//Cria o menu
JMenu menuSkins = new JMenu("Skins");
 
for (int skin = 0; skin /*sinal de menor aqui*/ skins.length; skin++)
{
 itemSkin[skin] = new JMenuItem(skins[skin].getName());
 eventosMenu[skin] = new myListener(skin);
 itemSkin[skin].addActionListener(eventosMenu[skin]);
 menuSkins.add(itemSkin[skin]);
}

//Adiciona o menu na barra
barraMenu.add(menuSkins);

//Retornamos a barra prontinha
return barraMenu;

}

Escrevendo um Listener

Para acionar os eventos do menu, o autor achou que seria interessante implementar um Listener personalizado. Isto porque o Listener deveria conter o número do LookAndFeel que ele gostaria de mostrar naquele momento. Para escrever um Listener, implemente a classe ActionListener e o método actionPerformed:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import javax.swing.UIManager;

public class myListener implements ActionListener{
private int skin = 0;

public myListener(int newSkin) {
this.skin = newSkin;
}

public void actionPerformed(ActionEvent arg0) {
try{
UIManager.setLookAndFeel(Principal.skins[skin].getClassName());
JOptionPane.showMessageDialog(null, "Seu skin foi alterado para " + Principal.skins[skin].getName() + ".\nCaso tenha janelas internas em execução, reinicie-as para aplicar as alterações.", "Skins", JOptionPane.INFORMATION_MESSAGE);
}catch(Exception e)
{
e.printStackTrace();
}
}
}

Veja que a classe possui um construtor que recebe o LookAndFeel a ser mostrado. Por isso que passamos como parâmetro quando estamos criando os objetos Listener. Dentro do actionPerformed chamamos o método que configura o LookAndFeel recebido e mostra uma mensagem. Coloquei esta mensagem porque estou trabalhando com InternalFrames e eles precisam ser reabertos para que as aplicações ocorram. Lembrando que as duas classes estão no mesmo pacote.
Veja o resultado final:

Agora é só implementar mais alguma coisa pra salvar o LookAndFeel selecionado.
Espero que tenham gostado!