Pivot - Hello World com Maven

Saudações Rangos!

Esse post vai tratar de ajudar a fazer seu primeiro "hello world!" no Apache Pivot. Deve estar se perguntando o porque disso? Bom é simples. O tutorial que tem no site oficial está errado! E também vou aproveitar para dar uma desenferrujada e digitar um pouco ... eheheheh.

Bom para inicio de conversa eu estruturei meu exemplo no Maven. Porque? Porque eu gosto da maneira que o Maven gerencia minhas dependências de outros jars, segue o meu POM:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.sf.gaia.test</groupId>
    <artifactId>pivot-tutorial</artifactId>
    <name>Pivot Maven Tutorial</name>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-core</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-wtk</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.pivot</groupId>
            <artifactId>pivot-web</artifactId>
            <version>1.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <inherited>true</inherited>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
    </build>
</project>

Basicamente no POM eu adicionei as dependências utilizada no tutorial para compilar a classe. E também adicionei o pluging para compilar utilizando o Java 6 com codificação de texto UTF-8.

A classe de exemplo eu usei a mesma que está no site oficial Apache Pivot - Hello World, mas segue ele ai:

package org.apache.pivot.tutorials;

import java.awt.Color;
import java.awt.Font;

import org.apache.pivot.collections.Map;
import org.apache.pivot.wtk.Application;
import org.apache.pivot.wtk.DesktopApplicationContext;
import org.apache.pivot.wtk.Display;
import org.apache.pivot.wtk.HorizontalAlignment;
import org.apache.pivot.wtk.Label;
import org.apache.pivot.wtk.VerticalAlignment;
import org.apache.pivot.wtk.Window;

public class HelloJava implements Application {
    private Window window = null;
 
    @Override
    public void startup(Display display, Map<String, String> properties) {
        Label label = new Label();
        label.setText("Hello World!");
        label.getStyles().put("font", new Font("Arial", Font.BOLD, 24));
        label.getStyles().put("color", Color.RED);
        label.getStyles().put("horizontalAlignment", HorizontalAlignment.CENTER);
        label.getStyles().put("verticalAlignment", VerticalAlignment.CENTER);
 
        window = new Window();
        window.setContent(label);
        window.setTitle("Hello World!");
        window.setMaximized(true);
        window.open(display);
    }
 
    @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(HelloJava.class, args);
    }
}

O que mais incomodo não foram nem o Maven e nem o classe. O que estava errado mesmo era o código HTML para adicionar a Applet e ver o exemplo funcionando. Tudo por causa de um que no tutorial era dito para usar o parâmetro "applicationClassName" quando na verdade era para ser usado "application_class_name". Esse simples troca já da uma dor de cabeça, segue como ficou:

<applet code="org.apache.pivot.wtk.BrowserApplicationContext$HostApplet" archive="lib/pivot-core-1.4.jar,lib/pivot-wtk-1.4.jar,lib/pivot-wtk-terra-1.4.jar,lib/pivot-tutorial-1.0-SNASHOT.jar" width="400" height="200" >
     <param name="application_class_name" value="org.apache.pivot.tutorials.HelloJava" >
</applet>

Java - Manipulação de String

E ai pessoal, passei na SCJP e finalmente consegui tempo para terminar esse post ehehe :D ... Valeu ai a toda ajuda, mas agora voltando aos post queria falar um pouco sobre algo que me chamou muita atenção no estudo de Java - Manipulação de String. Parece simples né? Na verdade não é bem assim, vou justificar.

Todo mundo sabe que em Java você tem dois tipo de variáveis de referência, uma para tipos primitivos: int, float, double, boolean, char, shot e long(não sei se esqueci de algum) e outra que são referências aos objetos, isto é, as classes em si que você utiliza no seu dia a dia.

Essas classes em especial por padrão estendem a classe Object, isso é, todas os objetos no Java são derivados da classe Object (menos a propia Object ... obvio né ehehehe).

Mas tá e porque escrever um post sobre a classe String? Que que ela tem de diferente? Bom é que diferente dos outros objetos a uma String só pode ser criada uma vez, ela nunca poderá ser modificada. Então o que acontece quando um objeto String parece estar se modificando? Vamos ao exemplo:

String ola = "Ola!";

Vejamos, o que temos é uma variável de nome ola que serve se referência para um objeto String com valor "Ola!", até ai tudo bem né? Mas se continuarmos:

String olaAux = ola;
ola = ola.concat(" Como vai?");
if (ola.equals(olaAux))
      System.out.print("Igual");
else
      System.out.print("Diferente");

Uh que código mais tosco deve estar pensando hehehe ... Mas e ai, o que vai aparecer na saída? Resposta: "Diferente". Pode testar se não acreditar.

Intrigado? Bem isso é normal, mas lembre-se que comentei que uma variável String nunca pode ser modificada, então o que aconteceu? Simples, Quando criamos a variável se referência olaAux a atribuímos o valor de ola. Depois quando usamos o método concat adicionamos no final da String o valor " Como vai?", mas como String não pode ser mudada a JVM cria uma nova instância de String somando os dois valores "Ola!" e " Como vai!". Assim a variável ola passa a apontar para uma nova instância se String com valor "Ola! Como vai?", enquanto que olaAux continua apontando para "Ola!".

Vale destacar que a JVM cria uma lista da memória de todas as Strings que são criadas, isso quer dizer que no nosso exemplo foram criadas cinco Strings nessa lista. Cinco? Sim! Cada String criada no texto é adiciona na lista, são elas: "Ola!", " Como vai?", "Ola! Como vai?", "Igual" e "Diferente".

A JVM cria essa lista como uma forma de otimizar a utilização de memória, assim se diversas variáveis de String precisarem utilizar o mesmo conteúdo elas irão apontar para a mesma referência e não ficar criando novas instâncias todas as vezes que precisar.

Bom esse foi só um breve resumo, se quiserem mais detalhes o livro do SCJP tem um capitulo inteiro sobre Strings. Até mais!