Blog: Java

Rhino: Rodando Javascript em Java

Rhino é um framework para a linguagem Java que permite executar scripts em Javascript. Ele foi feito pelo “mesmo” pessoal da Mozilla Foundation.
O mais legal é que dá para criar um console javascript em prompt de comando (coisa de nerd, eu sei 🙂 ).
Muito bom para quem gosta de Javascript e quer fazer aplicações em Shell/Terminal/Console/Prompt. 😛

Para mais informações, acesse o site:
http://www.mozilla.org/rhino/doc.html

Obs.: A ferramenta de teste Selenium usou ele para executar Javascript em sua versão RC.

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Drag’n Drop de elementos gráficos (Java-AWT)

Um rapaz me perguntou como seria fazer um drag’n drop (na mão) de um elemento gráfico em uma tela.
Então resolvi postar uma resposta aqui no blog. 🙂
Como ele não especificou a linguagem, vou fazer em Java/AWT (será que alguém ainda usa isso?!? 😛 ), que foi a linguagem que mais trabalhei nos últimos 10 anos

Primeiramente, vamos criar uma janela de tamanho fixo (no caso, 300×300):

//Herda de Frame (Janela)
public class MainClass extends Frame {

    //Construtor da classe
    public MainClass() {
        //Tamanho da janela
        this.setSize(300, 300);
        //Título da janela
        this.setTitle(“Exemplo Gráfico”);
    }

    //Método principal que inicia a aplicação
    public static void main(String arg[]) {
        //Instância o objeto
        MainClass main = new MainClass();
        //Exibe a tela
        main.setVisible(true);
    }
}

Para evitar que a janela fique “ad-eterno” na tela, mesmo clicando no “X”, vamos implementar a função de fechar da janela em seu construtor:

    //Construtor da classe
    public MainClass() {
        
         //“Escutador” de eventos de janela
         this.addWindowListener(new WindowAdapter() {
             //Método que é executado quando o usuário clicar no botão de fechar da janela (ou algum evento que tenha a mesma funcionalidade, como o Ctrl+X no MS-Windows)
            @Override
            public void windowClosing(WindowEvent e) {
                //Encerra a aplicação
                System.exit(0);
            }
        });
            
    }

Legal, temos uma janela feita em Java! 🙂

Vamos para o segundo passo: criamos um objeto gráfico (neste caso, um retângulo) como uma propriedade da classe e instanciamos esta em seu construtor:

public class MainClass extends Frame {
    private Rectangle rect;
   
    public MainClass() {
         
          //Retângulo a ser desenhado
          rect = new Rectangle(50, 50, 60, 30);
         
    }
   
}

E agora vamos desenhar este retângulo na tela, reescrevendo os métodos paint e update:

   //Para evitar o “pisca-pisca” (efeito de blink) da tela
    @Override
    public void update(Graphics g) {
        this.paint(g);
    }
   
    //Desenha um retângulo vermelho em um fundo preto (retângulo do tamanho da tela)
    @Override
    public void paint(Graphics g) {
        //Pinta a tela de preto
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, this.getWidth(), this.getHeight());
        //Pinta um retângulo vermelho
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(),
                (int)rect.getWidth(), (int)rect.getHeight());
    }

Executamos e temos um retângulo vermelho em um fundo preto (eu já disse isso em algum lugar?). 🙂

Nesta terceira etapa, precisamos identificar os eventos de drag’n drop, que são (eu acho ):
1) O evento de botão do mouse pressionado para obter o efeito de “pegar” o retângulo;
2) O evento de soltar o botão do mouse para obter o efeito de “largar” o retângulo;
3)  E o evento de movimento do mouse, para que o retângulo acompanhe o “ponteiro” do mouse enquanto ele não for solto;

Com isso, a classe vai ficar mais ou menos assim:

import java.awt.*;
import java.awt.event.*;

//Herda de Frame (Janela)
public class MainClass extends Frame {

    //Retângulo a ser desenhado
    private Rectangle rect;
    //Flag que indica se o objeto esta sendo “arrastado”
    private boolean elementDragged;
    //Ponto (x,y) da tela onde o ponteiro do mouse estava inicialmente
    private Point initial;
 
    //Construtor da classe  
    public MainClass() {
        //Retângulo a ser desenhado
        rect = new Rectangle(50, 50, 50, 50);
        //Tamanho da janela
        this.setSize(300, 300);
        //Título da Janela
        this.setTitle(“Exemplo Gráfico”);
        this.addEventListener();
    }
   
     //Método privado que adiciona os eventos
    private void addEventListener() {
        //“Escutador” de eventos de janela
        this.addWindowListener(new WindowAdapter() {
             //Método que é executado quando o usuário clicar no botão de fechar da janela (ou algum evento que tenha a mesma funcionalidade, como o Ctrl+X no MS-Windows)
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        //“Escutador” de eventos do mouse
        this.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                mousePressedEvent(e);
            }           
            @Override
            public void mouseReleased(MouseEvent e) {
                mouseReleasedEvent(e);
            }
        });
        //“Escutador” de eventos de movimento do mouse
        this.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent e) {
                mouseDraggedEvent(e);
            }
        });
    }
   
    //Quando o botão do mouse é pressionado, este método é executado
    private void mousePressedEvent(MouseEvent e) {
        //Se o ponteiro do mouse esta dentro do retângulo
        if (rect.contains(e.getPoint())) {
            //Obtenho o ponto inicial do ponteiro do mouse
            initial = new Point((int)(e.getPoint().getX() rect.getX()),
                    (int)(e.getPoint().getY() rect.getY()));
            //E digo que o retângulo pode ser “arrastado”
            elementDragged = true;
        }       
    }
   
    //Quando o mouse é “arrastado”, este método é executado
    private void mouseDraggedEvent(MouseEvent e) {
        //Se o retângulo pode ser “arrastado”
        if (elementDragged) {
            //Faço ele movimentar-se de acordo com a posição do ponteiro do mouse
            rect.setLocation((int)((e.getPoint().getX() initial.getX())),
                    (int)(e.getPoint().getY() initial.getY()));
            //Redesenho a tela
            this.repaint();
        }
    }           
 
   //Quando o botão do mouse é “solto”, este método é executado
    public void mouseReleasedEvent(MouseEvent e) {
        //Digo que o retângulo não esta mais “arrastavel”
        elementDragged = false;
        //E “zero” a posição inicial
        initial = null;
    }
   
    //Para evitar o “pisca-pisca” (efeito de blink) da tela
    @Override
    public void update(Graphics g) {
        this.paint(g);
    }
   
     //Desenha um retângulo vermelho em um fundo preto (retângulo do tamanho da tela)
    @Override
    public void paint(Graphics g) {
        //Pinta a tela de preto
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, this.getWidth(), this.getHeight());
        //Pinta um retângulo vermelho
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(),
                (int)rect.getWidth(), (int)rect.getHeight());
    }
 
    //Método principal que inicia a aplicação (tudo começa aqui 🙂 )
    public static void main(String arg[]) {
        //Instância a classe
        MainClass main = new MainClass();
        //Exibe a tela
        main.setVisible(true);
    }
}

Parece que funciona (eu testei no MacOSX 10.7.4, com o JDK 1.6.0_33)

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Qual é a diferença entre métodos public, protected, private e “default” no Java?

Dúvida de um pessoal aqui, que vou tentar (eu disse “tentar” 😛 ) explicar.

No Java, existem quatro tipos de “permissões” de acesso a métodos (isso também vale para classes e propriedades, com algumas exceções ) que, dependendo de sua escolha, parte do seu código-fonte vai ou não “enxerga-la” durante a execução/compilação deste. São elas:

public : A mais fácil de explicar, pois todo código tem acesso a ela! 🙂
Exemplo:

Arquivo: Util.java

package teste.util;
_
_

public class Util {

           public void nothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}

Arquivo: Main.java

package teste.main;
_
_ import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      util.nothing();
           }
}

private : A mais restrita das quatro, onde somente a classe que a declarou tem acesso:

Arquivo: Util.java

package teste.util;
_
_ public class Util {
            //Este método é chamado somente dentro desta classe
           private void privateNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
_
_            public void publicNothing() {
                    System.out.println(“Será que chamo?”);
                    this.privateNothing();
           }
}

Arquivo: Main.java

package teste.main;
_
_ import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.privateNothing(); //NÃO FUNCIONA
                      util.publicNothing();
           }
}

(Até aqui, foi bem simples explicar. Mas a partir de agora que vem o problema :P)

protected : Este “acesso” é meio estranho, mas vamos lá: a classe que declarou, as classes que estão no mesmo pacote e a classe que herdou desta, tem acesso a ela.
Putz Confuso não? Melhor pedir ajuda ao exemplo. (universitários? nem pensar!) 😛

Arquivo: Util.java

package teste.util;
_
_ public class Util {
           protected void protectedNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}
_
_ Arquivo: Inutil.java

package teste.util;
_
_ //Não herdou mas esta no mesmo pacote (isto funciona!)
public class Inutil {
           public void nothing() {
_                   __Util util = new Util();_
_                   util.__protectedNothing();_
_           }_
_}_
_
_ Arquivo: HerancaUtil.java

package teste.heranca;
import teste.util.Util;
_
_ //Herdou, mas não esta no mesmo pacote (isto funciona!)
public class HerancaUtil extends Util {
           public void nothing() {
_                   super__.__protectedNothing();_
_           }_
_}_

Arquivo: Main.java

package teste.main;

__import teste.heranca.HerancaUtil;

import teste.util.Inutil;

import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.protectedNothing(); //NÃO FUNCIONA
                      Inutil inutil = new __Inutil();_
_                      inutil.nothing();_
_                      __HerancaUtil
 h__erancaUtil__ = new HerancaUtil();

                      h__erancaUtil.nothing();
           }
}

(Só falta uma 🙂 )

default : O acesso é restrito as classes que estão no mesmo pacote, ou seja, classes que não estejam no mesmo pacote, mesmo as que herdam da que declarou o método, não o acessam.

Arquivo: Util.java

package teste.util;
_
_ public class Util {
           void defaultNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}
_
_ Arquivo: Inutil.java

package teste.util;
_
_ //Não herdou mas esta no mesmo pacote (isto funciona!)
public class Inutil {
           public void nothing() {
                   Util util = new Util();_
_                   util.__defaultNothing
();

           }
}
_
_ Arquivo: HerancaUtil.java

package teste.heranca;
import teste.util.Util;
_
_ //Herdou, mas não esta no mesmo pacote (NÃO funciona!)
public class HerancaUtil extends Util {
           public void nothing() {
                   //super__.default__Nothing(); //NÃO FUNCIONA
           }
}

Arquivo: Main.java

package teste.main;

__import teste.heranca.HerancaUtil;

import teste.util.Inutil;

import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.defaultNothing(); //NÃO FUNCIONA
_                      __Inutil inutil = new __Inutil();_
_                      inutil.nothing();_
_           }_
_}_

(Ufa, terminou! 🙂 )

Espero que alguém compreenda o que esta escrito 😛

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

TotalCross: Java para iOS

Alguém se lembra de um framework de Java para Palm chamado SuperWaba?
Sim? Então você é um programador tão antigo quanto eu 🙂

Pois é, o tempo passou e as coisas evoluiram: o Palm já era, o iPaq também E, hoje em dia, a moda é iPhone e Android

Mas o SuperWaba também evoluiu Agora ele chama TotalCross e funciona para iPhone e Andro http://www.superwaba.com.br/pt/tc_overview.asp

Esta ferramenta possui uma VM (Virtual Machine ou Máquina Virtual) própria que interpreta código compilado Java e roda em diversas plataformas (cada uma com sua VM, lógico 😛 )

Interessante, porém parece que a ferramenta não é oficializada pela Apple (no caso do iOS ).

Mas não custa experimentar 🙂

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Entendendo a plataforma Java

Entendendo a plataforma Java. Linguagem Java.

Java é uma linguagem de alto nível. Ela roda em mais de 50 milhões de computadores pessoais e em bilhões de dispositivos em todo o mundo.

A linguagem pode ser caracterizada pelas seguintes palavras chave:

  • Simples
  • Orientado a objeto
  • Distribuído
  • Multithreaded
  • Dinâmico
  • Arquitetura neutra
  • Portável
  • Alto desempenho
  • Robusto
  • Seguro

Os dois principais componentes da plataforma Java são: Interface de Programação de Aplicativos Java (API) e a Maquina Virtual Java (JVM), que interpreta o código Java em linguagem de máquina.

A mesma aplicação Java, pode rodar em diversas plataformas sem que seja necessária uma nova compilação ou alterações no programa fonte, bastando que se use a JVM adequada ao sistema operacional destino.

Abaixo um exemplo da mesma aplicação rodando em várias plataformas:

A API e a JVM tornam o programa independente do hardware subjacente.

Na linguagem de programação Java, todo o código fonte é escrito em arquivos de texto simples que terminam com a extensão java. Esses arquivos são compilados pelo compilador javac que gera um arquivo com extensão class. Um arquivo de classe não contém código nativo para seu processador, em vez disso, contém bytecodes (linguagem de máquina do Java Virtual Machine – JVM). A ferramenta de execução (java) em seguida, executa a sua aplicação com uma instância da máquina virtual Java.

Para fazer o seu primeiro programa “Hello World”, siga os passos do post anterior para escrever seu primeiro programa em Java utilizando a IDE NetBeans.

Blog Java Boas vindas!

Blog Java Boas vindas. Assuntos sobre a Linguagem Java e muitas dicas de programação.

Bem-vindo ao Blog, um Guia do Java entre tantos. Aqui você irá encontrar informações sobre a tecnologia Java objetiva, simples e prática. Um dos objetivos é guiar os iniciantes, também profissionais experientes encontrarão facilidades e aplicações que facilitam o cotidiano da programação. Gostaria de convidar a você a enriquecer ainda mais esta experiência contribuindo com suas ideias e tudo mais que desejar compartilhar como vídeos, textos, imagens, links etc.

Se faltar algo que esteja procurando, não esqueça de pedir ajudar, teremos maior prazer em completar o que deseja encontrar aqui. A maioria de tudo publicado neste espaço, como tutoriais, minicursos, vídeos, apostilas, programas, são republicação no objetivo de fazer a coisa chegar a quem precisa.