Jogo da Memória com Apache Pivot

É grande com satisfação que posto este pequeno tutorial!

Tenho percebido, pelas estatísticas do blog, que o “Jogo da Memória em Java”, um de meus primeiros posts neste blog, é o tutorial mais acessado.

A grande maioria da galera que acessa este tutorial está buscando uma solução fácil para algum trabalho de faculdade, mas no fundo, este tutorial representou muito mais pra mim. Foi meu primeiro desafio pessoal em Java, algo que eu quis fazer para realmente me desafiar, e aprender a programar em Swing.

Agora, tenho o prazer de postar aqui o mesmo jogo, com algumas pequenas modificações  funcionais, escrito na plataforma Pivot.

Sim! Apesar de ser escrito em Java, o Apache Pivot é uma plataforma RIA completa.

Não vou entrar em detalhes para explicar o código. Ao invés disso, vou disponibilizar aqui o código do jogo, e deixar o desafio de executar o jogo para aqueles que se interessarem em aprender mais sobre esta fascinante plataforma RIA.

Este jogo, apesar de pequeno, demonstra muitos dos recursos disponíveis no Pivot.

Visitem o site do projeto, e leiam os tutoriais http://pivot.apache.org/.

A versão 2.0 estará saindo em breve (tenho acompanhado a lista de desenvolvimento e de usuários, e recomendo).

 

 

 

Definição da interface através do arquivo memgame.wtkx:

 


<Window title="Pivot's Memory Game" maximized="true"
    xmlns:wtkx="http://pivot.apache.org/wtkx"
    xmlns:content="org.apache.pivot.wtk.content"
    xmlns="org.apache.pivot.wtk">
    <content>
        <Border>
            <content>
	            <GridPane columnCount="6" styles="{horizontalSpacing:1, verticalSpacing:1,
                    showHorizontalGridLines:true, showVerticalGridLines:true}">
                    <rows>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="1">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="2">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="3">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="4">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="5">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="6">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="7">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="8">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="9">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="10">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="11">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="12">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="13">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="14">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="15">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="16">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="17">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="18">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="19">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="20">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="21">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="22">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="23">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="24">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="25">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="26">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="27">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="28">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="29">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="30">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                        <GridPane.Row>
                            <PushButton toggleButton="true" wtkx:id="31">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="32">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="33">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                            <PushButton toggleButton="true" wtkx:id="34">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="35">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
				            <PushButton toggleButton="true" wtkx:id="36">
				                <buttonData>
				                    <content:ButtonData text=""/>
				                </buttonData>
				            </PushButton>
                        </GridPane.Row>
                    </rows>
                </GridPane>
            </content>
        </Border>
    </content>
</Window>

Classe que manipula os componentes de tela:


package votti.pivot.memgame;

import org.apache.pivot.collections.Map;
import org.apache.pivot.wtk.Alert;
import org.apache.pivot.wtk.Application;
import org.apache.pivot.wtk.Button;
import org.apache.pivot.wtk.ButtonPressListener;
import org.apache.pivot.wtk.DesktopApplicationContext;
import org.apache.pivot.wtk.Display;
import org.apache.pivot.wtk.MessageType;
import org.apache.pivot.wtk.PushButton;
import org.apache.pivot.wtk.Window;
import org.apache.pivot.wtkx.WTKXSerializer;

import votti.pivot.memgame.component.MemGameButtonData;

public class Main implements Application, ButtonPressListener {

	private String defaultImage = "img/default.gif";
	private boolean firstClick = true;
	private boolean right = true;
	private PushButton buttonOne;
	private PushButton buttonTwo;
	private Button clickedButtonOne;
	private Button clickedButtonTwo;

    private Window window = null;
    private String[] images18;
    private String[] images36;
    private PushButton[] buttons;

    @Override
    public void startup(Display display, Map<String, String> properties)

        throws Exception {
        WTKXSerializer wtkxSerializer = new WTKXSerializer();
        window = (Window) wtkxSerializer.readObject(this, "memgame.wtkx");

        prepareImagesArray();

        buttons = new PushButton[36];

        for(int aux = 0; aux < 36; aux++){
        	buttons[aux] = (PushButton) wtkxSerializer.get(String.valueOf(aux+1));
        	buttons[aux].setButtonData(new MemGameButtonData(defaultImage, images36[aux]));
        	buttons[aux].getButtonPressListeners().add(this);
        }

        window.open(display);
        window.setWidth(500);
        window.setHeight(520);
    }

    @Override
    public boolean shutdown(boolean optional) {
        if (window != null) {
            window.close();
        }

        return false;
    }

    @Override
    public void suspend() {
    }

    @Override
    public void resume() {
    }

    public static void main(String[] args) {
        DesktopApplicationContext.main(Main.class, args);
    }

    private void prepareImagesArray(){

		int posicaoNoArray, x, y;
		this.images18 = new String[18];

		for ( x = 0; x < (18); x++ ){
			this.images18[ x ] = new String("img/" + ( x + 1 ) + ".gif");
		}

		this.images36 = new String[ (36) ];

		for ( x = 0; x < 2; x++ ){
			for ( y = 0; y < (18); y++ ){
				do{
					posicaoNoArray = ( int ) ( Math.random() * (36) );
				}while( this.images36[ posicaoNoArray ] != null );
				this.images36[ posicaoNoArray ] = images18[ y ];
			}
		}
	}

	@Override
	public void buttonPressed(Button button) {

		if( firstClick ){

			if ( !right ){

				buttonOne = (PushButton) clickedButtonOne;
				buttonTwo = (PushButton) clickedButtonTwo;

				((MemGameButtonData)buttonOne.getButtonData()).setDefaultURL();
				((MemGameButtonData)buttonTwo.getButtonData()).setDefaultURL();

				window.repaint();
			}

			clickedButtonOne = button;

			buttonOne = (PushButton) clickedButtonOne;
			((MemGameButtonData)buttonOne.getButtonData()).setButtonURL();

			firstClick = !firstClick;
		}
		else{

			clickedButtonTwo = button;
			buttonTwo = (PushButton) clickedButtonTwo;

			if ( clickedButtonTwo == clickedButtonOne ){

				right = false;

				Alert.alert(MessageType.WARNING, "Not permited action!", window);
			}
			else{

				((MemGameButtonData)buttonTwo.getButtonData()).setButtonURL();

				if ( ((MemGameButtonData)buttonOne.getButtonData()).getButtonURL().equals(
						((MemGameButtonData)buttonTwo.getButtonData()).getButtonURL())){

					right = true;

					buttonOne.setEnabled( false );
					buttonTwo.setEnabled( false );
				}

				else{
					right = false;
				}

				firstClick = !firstClick;
			}
		}

	}
}

Anúncios

Projeto Money Count – Idealização

Uma dificuldade que percebo nas pessoas que começam a aprender Java (assim com qualquer tecnologia) é conseguir juntar tudo que se lê a respeito em algo executável, ou seja, conseguir entender todas as tecnologias e padrões envolvidos no desenvolvimento de um sistema.

Para Java essa curva de aprendizado é relamente mais acentuada, ainda mais quando alguém se dispõe a aprender por conta própria.

Ainda me lembro de quando vi Java pela primeira vez, na faculdade. Na ocasião o professor chegou nos mostrando um programinha com poucas linhas que apresentava uma janelinha (JOptionPane) que solicitava uma informação e a apresentava na tela novamente. Aquilo me encantou, mas eu não sabia nem por onde começar, nem como instalar a JDK. Era um longo caminho pela frente (que eu ainda estou trilhando, diga-se de passagem).

Depois disso tivemos Java como linguagem para aprender OO, e mais um semestre em que vimos algo a mais de Java (a contragosto da maioria da sala). Na época não usávamos IDEs como Netbeans ou Eclipse; era tudo no JCreator. Me lembro de ter feito várias e várias telas na mão, com Swing, direto no JCreator, sem os recursos de arrastar e soltar.

Levei tempos até conseguir entender coisas como o que são drivers JDBC, pra entender como fazer uma conexão com o banco de dados, como usar padrões, etc, etc, etc.

Até conseguir criar algo considerável, um sisteminha desktop “bobinho” com conexão à base de dados, validações em formulários, e separação em camadas, penei muito nos fóruns, em cima de livros, e posso garantir que a maior dificuldade é realmente organizar todas as informações encontradas em algo funcional.

Quando criei este blog, a minha intenção era de compartilhar um pouco daquilo que aprendi desde então, nos anos que venho trabalhando com tecnologia. Fica claro que o foco é Java, mas prentendo continuar postando sobre tudo aquilo que julgar proveitoso em outras tecnologias. A intenção do blog continua a mesma, mas refletindo sobre essa dificuldade inicial dos estudantes da tecnologia, pensei em estruturar de uma maneira melhor as postagens, “colocá-las nos trilhos” para que aqueles que estão começando possam aproveitar em algum momento posts mais avançados, sem ficarem confusos. Para resumir, pensei em criar um passo-a-passo, que vai do básico até temas mais avançados.

Para conseguir isso, pensei em criar um projeto de estudo de caso, que possa passar pelos processos de análise, projeto, e desenvolvimento, passando pelas tecnologias básicas até as mais avançadas.

A idéia de ter um projeto padrão é poder, a apartir de um momento, não se importar com “o que” desenvolver, mas com o “como”, podendo ainda fazer comparativos entre as tecnologias para o desenvolvimento do mesmo sistema.

Para este objetivo elegi o primeiro sistema que desenvolvi em Java, com conexão a banco de dados e tudo o mais. É um projeto bem simples, mas funcional, e que está até hoje em funcionamento. Esse projeto surgiu da necessidade de um amigo, que me solicitou um sistema para contagem de unidades monetárias, há muito tempo atrás. A seguir darei o escopo do projeto, e a partir de agora alguns posts serão referentes a este projeto, começando do básico até alcançarmos conceitos e tecnologias mais avançadas.

Money Count

A necessidade do cliente resume-se ao seguinte:

O cliente necessita efetuar pagamentos a funcionários e fornecedores em dinheiro vivo, e para isso calcula todos os pagamentos a serem efetuados no dia e realiza saques no banco. O problema é que a soma dos valores é sacada em notas grandes, e geralmente faltam moedas e notas menores para efetuar o pagamento de valores “quebrados”. Como o cálculo dos valores é realizado por funcionários, de uma maneira não automatizada, erros são possíveis.

O que o sistema a ser desenvolvido deverá realizar:

O cliente solicitou o desenvolvimento de um sistema que permita o cadastro de contas em um banco de dados, para que posteriormente possa emitir relatórios de pagamentos diários de maneira fácil.

O sistema deverá permitir que se saiba, ao final de um relatório, quais e quantas unidades monetárias serão necessárias para se efetuar todos os pagamentos do dia.

Parece fácil não? E é!

Olhando esta especificação, muito simples, é fácil entender a necessidade do cliente e imaginar o sistema a ser desenvolvido.

O problema é o desenvolvimento desse sistema por uma pessoa que está começando agora.

No próximo post começaremos a analisar este sistema mais a fundo (processo de análise), elegendo as classes conceituais que irão compor o sistema, trabalhando com diagramação UML (só o necessário) e nos preparando para o desenvolvimento.

Até lá!

Visão geral da tecnologia Java

Motivação

Estava eu aqui, escrevendo alguns tópicos da minha monografia que falam sobre a tecnologia Java, e me veio a idéia de publicar o conteúdo na forma de um artigo, dando uma visão geral da tecnologia.
Por um momento pensei que seria perda de tempo, afinal, já existe muito material por aí que fala sobre a história da linguagem, e sobre a tecnologia como um todo.

Mas escrevendo os tópicos da monografia percebi o quanto é difícil encontrar, em um único lugar, várias informações sobre a plataforma Java, o que é muito importante para quem está começando a se aventurar nesta tecnologia.

Portanto resolvi criar este artigo para registrar em um único lugar algumas informações relevantes sobre a tecnologia. As fontes de referência serão citadas ao final, e nelas poderão ser encontradas informações adicionais.
Críticas e sugestões são bem vindas na forma de comentários (até porque a monografia ainda não foi entregue até a presente data).

Se você chegou até aqui à procura de informações sobre a tecnologia Java, espero que este artigo possa ser interessante e atender às suas espectativas.

JavaTM

A tecnologia JavaTM há algum tempo, tem sido a principal escolha do mercado de TI para o desenvolvimento de sistemas distribuídos.

Segundo o ínice TIOBE, de fevereiro de 2009, Java ainda é a linguagem mais popular para o desenvolvimento de sistemas.

tpci_trends

É importante observar que este índice não se refere a melhor linguagem de programação, ou a linguagem com a qual se escreveu a maior quantidade de linhas de código até o momento. Este é um índice que leva em consideração, entre outras coisas, a quantidade de profissionais capacitados ao redor do mundo, cursos disponíveis e produtos no mercado.
Esta convergência para a tecnologia JavaTM se deve, principalmente, ao reconhecimento por parte do mercado de TI das qualidades inerentes da linguagem e da plataforma JavaTM como um todo.

Histórico

A tecnologia Java surgiu de uma pesquisa corporativa interna, financiada pela Sun Microsystems, em 1991. O objetivo era o desenvolvimento de uma linguagem que atendesse ao mercado de dispositivos eletrônicos inteligentes.
O resultado foi a criação de uma linguagem baseada em C e C++, que teve o nome inicial de Oak. Pouco tempo depois, rebatizada de Java, a linguagem se mostrou adequada para o desenvolvimento de páginas web dinâmicas, e em 1995 foi apresentada formalmente pela Sun Microsystems em uma conferência. Nascia aí a plataforma Java.

Hoje, muito mais do que uma linguagem, Java é uma plataforma rica, que permite o desenvolvimento de aplicações para dispositivos móveis, como celulares e PDAs, até aplicações corporativas complexas, baseadas em web services, passando ainda por aplicações desktop e discos blue-ray.

A linguagem de programação JavaTM

Ao criar a linguagem de programação Java, os engenheiros da Sun se basearam em duas das linguagens de implementação mais utilizadas até então, C e C++. Isso permitiu que Java estivesse facilmente acessível a uma enorme base de desenvolvedores ao redor do mundo, a maioria dos quais envolvidos no desenvolvimento de sistemas operacionais, sistemas de bancos de dados, telecomunicações e aplicativos para computadores pessoais.
Foram removidos da linguagem os recursos mais confusos, complexos, e propensos a erros encontrados em C e C++, mantendo assim a linguagem concisa, com aquilo que havia de melhor das duas linguagens.
Foram incluídos na linguagem recursos realmente necessários à grande maioria dos desenvolvedores, como strings, imagens gráficas, componentes de interface gráfica com o usuário, tratamento de exceções, multithreading, multimídia, processamento de arquivos, processamento de bancos de dados, redes cliente/servidor baseados na Internet e na World Wide Web e em computação distribuída, e estruturas de dados pré-empacotadas.
Java foi também a primeira linguagem verdadeiramenteo multiplataforma, implementando o conceito de “write once, run everywhere”, graças à sua arquitetura baseada em uma máquina virtual, que interpreta um código intermediário, conhecido como bytecode. A existência de máquinas virtuais para sistemas operacionais específicos permite que um mesmo bytecode gerado por um código compilado de uma classe Java seja executado em qualquer sistema operacional sem a necessidade de recompilação.

Desde sua criação, muitas características vem sendo adicionadas à linguagem Java e à plataforma Java como um todo. Todas estas características tornam a linguagem Java adequada, ao contrário do que muitos pensam, para o desenvolvimento de uma ampla variedade de sistemas, que incluem aplicações desktop, aplicações multimídia, applets, aplicações para Internet, intranet, extranet, portais, aplicações distribuídas baseadas em web services, aplicações para dispositivos móveis, discos blue-ray, aplicações para tv digital, e muito mais.

A plataforma tecnológica JavaTM

A tecnologia JavaTM não está limitada somente à linguagem de programação Java. Antes disso, JavaTM é uma ampla plataforma de desenvolvimento, constituída de várias APIs e ambientes de execução.
Apesar de ter sido desenvolvida inicialmente pela Sun, hoje a evolução da especificação da plataforma JavaTM é determinada por uma comunidade de empresas e indivíduos denominada JCP (Java Community Process) que, com suas experiências, ajudam a definir os rumos da plataforma, contribuindo com o melhor de cada segmento. Este modelo de evolução da plataforma permite que qualquer empresa possa implementar a espefificação da plataforma Java, na forma de um produto.
A platafoma JavaTM é dividida em três segmentos, ou edições principais: JSE, JEE e JME. Cada edição engloba e licencia um conjunto de APIs e ambiente de execução da plataforma Java para atender às necessidades específicas dos desenvolvedores de aplicações.

A JSE, ou Java Standard Edition, é o segmento base da plataforma JavaTM . É nele que encontramos as principais APIs a plataforma, que servem de base para os outro dois segmentos, além de APIs para o desenvolvimento de aplicações desktop.
A imagem abaixo apresenta o segmento JSE da plataforma JavaTM .

api_jse

Como é possível ver na imagem, a linguagem Java está no topo de uma série de tecnologias que compõem a plataforma JSE.
É possível visualizar também, nesta imagem, além das APIs que compõem a plataforma JSE, as ferramentas que acompanham o kit de desenvolvimento (JDK) e as tecnologias de implantação que acompanham ambiente de execução (JRE).

A JEE, ou Java Enterprise Edition, é o segmento da plataforma JavaTM que apresenta APIs para o desenvolvimento e aplicações corporativas distribuídas, transacionais, baseadas principalmente em tecnologias web.
A imagem abaixo ilustra a distribuição das APIs da plataforma JEE de acordo com o tipo de container JEE.

overview-j2eearchitecture

Como pode-se ver, a plataforma JSE é a base para todas as outras tecnologias presentes na plataforma JEE.

A JME, ou Java Micro Editon, é o segmento da plataforma Java destinado a dispositivos móveis como celulares, PDAs, e outros dispositivos embarcados que suportam JavaTM , mas não toda a API JSE ou JEE, e de certa forma é porção da tecnologia JavaTM que vai ao encontro das intenções originais ao se criar a linguagem Java.
Hoje, a plataforma JME evoluiu para uma arquitetura organizada de tecnologias distintas para dispositivos embarcados, e está dividida conforme a imagem abaixo.

fig2

Conclusão

Como pode-se ver, Java vai muito além da linguagem de programação. É uma plataforma completa, um conjunto de soluções para o desenvolvimento de aplicações de diversos tipos.
Apesar das novas tecnologias que surgem, Java ainda é uma tecnologia de destaque no mercado de desenvolvimento de aplicações, e as constantes melhorias na plataforma tendem a consolidar ainda mais a tecnologia, durante os próximos anos, como uma das principais do mercado.

Referências

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

http://java.sun.com/j2se/1.5.0/docs/

http://developers.sun.com/mobility/getstart/articles/survey/

http://java.sun.com/javaee/5/docs/tutorial/doc/

Deitel & Deitel – Java Como Programar 4ª Ed.

Érico Casella Tavares de Mattos – Programação de Softwares em Java

Érico Casella Tavares de Mattos – Programação Java para Wireless

Rick Cattell, Jim Inscore – Criando aplicações comerciais com a plataforma Java 2 Enterprise Edition