Arquivo da tag: Tutorial

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.

códigoa java, java download,programação Java,

Blog Java

Aprenda a fazer jogos pelo youtube!

Uma vez eu disse que entrei em computação por querer fazer jogos e que, até certo momento em minha carreira, eu nunca tinha feito…

De certa maneira, não tenho muito tempo livre para começar um projeto deste tipo.

Mas também, eu nem sei como começar a programar (para os que não estão na área: por incrível que pareça, fazer sites para empresas é uma coisa totalmente diferente que fazer games)! 😛

Porém, assistindo a um dos vídeos do canal do garotoverde no youtube, vi que ele citou uma pessoa que posta tutoriais de como criar jogos:

http://www.youtube.com/user/wemakeagame

Não sei como o cara tem tempo, mas a iniciativa é muito legal! 😛

Valeu, agora vou tentar ver se começo a assistir e esboçar meu primeiro joguinho. 😉

Até mais!

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)

Até mais!

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.