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.

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

Blog Java

Sistema Operacional Java

O projeto já tem um tempo, mas descobri um sistema operacional de código aberto feito em Java, chamado JNode:
http://www.jnode.org/

Agora, quem reclamar que a JVM demora para interpretar o bytecode, pode tentar usar um sistema operacional nativo para ver se fica mais rápido. 🙂

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.

Como Reescrever um Método de um Único Objeto em Java

Pela pergunta, parece muito difícil codificar Mas, para fazer, até que é fácil! 🙂

A gente pode reescrever o método de um único objeto, codificando ele durante a instanciação deste (chamada do construtor). Exemplo:

List listaStrings = new ArrayList() {
      public String toString() {
               return “Reescrevi o método”;
      }
};
listaStrings.add(“Primeira String”);
System.out.println(listaStrings);

Interessante, ele escreveu “Reescrevi o método” na tela!

Se você retirar as linhas de “reescrita”:

List listaStrings = new ArrayList();
listaStrings.add(“Primeira String”);
System.out.println(listaStrings);

Ele escreve “[Primeira String]” (agora parece normal 😛 ).

Obs.: Isso só pode ser feito em objetos que não são de classes “final”.

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.

Posso mudar o valor de um parâmetro em Java

Resposta direta: Não! 😛

Em Java, um parâmetro sempre é passado por valor (e não por referência). Ou seja, se eu fizer um código assim:

public class Main {
      public static void inc(int i) {
             i++;
      }
      public static void main(String args[]) {
            int a = 0;
            System.out.println(“Valor de a : ” + a);
            inc(a);
            System.out.println(“Valor de a : ” + a);
      }
}

O que será exibido na tela é:
Valor de a : 0
Valor de a : 0

O mesmo vale para uma String:

public class Main {
      public static void helloWorld(String str) {
             str += “ Hello World”;
      }
      public static void main(String args[]) {
            String s = “Alo mundo”;
            System.out.println(s);
            helloWorld(s);
            System.out.println(s);
      }
}

Tela:
Alo mundo
Alo mundo

Ou seja, o valor da variável passada por parametro não muda depois que você retorna para a função que o chamou

Mas existe um jeito de contornar isso! 🙂

Podemos usar classes que possuem funções e/ou atributos que modificam o estado inicial de um objeto (hã, o que é isso???).

Para facilitar, vejamos o exemplo a seguir:

public class Main {
      public static void helloWorld(StringBuilder str) {
             str.append(“ Hello World”);
      }
      public static void main(String args[]) {
            StringBuilder s = new StringBuilder(“Alo mundo”);
            System.out.println(s);
            helloWorld(s);
            System.out.println(s);
      }
}

Quando você executar, verá algo assim:
Alo mundo
Alo mundo Hello World

A mesma coisa acontece se eu criar um atributo inteiro em uma classe:
class MutableInteger {
         public int i = 0;
         public String toString() {
                 return String.valueOf(i);
         }       
}
E incrementar este na função, passando um objeto instanciado desta: 

public class Main {
      public static void inc(MutableInteger b) {
             b.i++;
      }
      public static void main(String args[]) {
            MutableInteger a = new MutableInteger();
            System.out.println(“Valor de a : ” + a);
            inc(a);
            System.out.println(“Valor de a : ” + a);
      }
}

E o que será exibido é:

Valor de a : 0
Valor de a : 1

Uau! Que coisa estranha 😛

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.

Propriedades estáticas em Java

Esta dúvida também apareceu semana passada

Se eu criar uma propriedade estática do tipo contador e incrementa-la no construtor do objeto

public class Usuario {
      private static int contador = 0;
      //Construtor
      public Usuario() {
              contador++;
      }
      //Exibe o valor
       public void exibirContador() {
               System.out.println(“No. de Usuarios: ” + contador);
       }
}

E criar e instanciar 5 objetos desta classe, não importa em qual objeto chamar o método exibirContador, que ele sempre retornará o mesmo valor, ou seja, 5 (é como se a variável fosse global):

Usuario u1 = new Usuario();
Usuario u2 = new Usuario();
Usuario u3 = new Usuario();
Usuario u4 = new Usuario();
Usuario u5 = new Usuario();

u2.exibirContador(); //Tente trocar para qualquer outro objeto que sempre dará o mesmo valor

Outra dúvida que surgiu é a chamada desta variável. Será que é possível chamar assim:
      public Usuario() {
              contador++;
      }
Ou assim:
      public Usuario() {
              this.contador++;
      }

Ou assim:
      public Usuario() {
              Usuario.contador++;
      }

Sim, por incrivel que pareça, é possível. (agora, não me pergunte o porque parece que isso tem haver com escopo da variável e outras coisas a mais que não faço a menor idéia de como funciona )

Que confusão Será que eu consegui explicar alguma coisa?
Bem, de qualquer forma, é bom testar o código acima 😛

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 classe abstrata e interface em Java

Isso foi me perguntado semana passada .

A resposta:

Classe Abstrata é uma classe que não pode ser instanciada, pode possuir métodos abstratos (ou seja, sem implementação) e que somente pode ser extendida (ou seja, as classes filhas somente podem herdar de uma única classe abstrata).

Interface é uma estrutura que também não pode ser instanciada, possui sempre métodos abstratos e podem ser implementadas em várias classes (ou seja, as classes filhas podem herdar de uma ou mais interfaces).

Exemplo:

//Classe abstrata Som
abstract class Som {
    public abstract void tocar();
    public void info() {
           System.out.println(“Testando som, 1, 2, 3”);
    }
}

//Classe abstrata Video
abstract class Video {
     public abstract void exibir();
     public void info() {
            System.out.println(“Luzes, Camera e Acao”);
     }
}

//Classe Musica que extende a classe Som (funciona!)
class Musica extends Som {
       public void tocar() {
              System.out.println(“Do re mi fa sol la si”);
       }
}

//Classe Filme que extende as classes Video e Som (não funciona )
class Filme extends Video, Som {
       public void tocar() {
              System.out.println(“Do re mi fa sol la si”);

       }
       public void exibir() {
               System.out.println(“Vendo o filme”);
       }

}

A classe Filme somente funcionaria, se as classes abstratas Video e Som fossem interfaces:

//Interface Video (não há implementação de método)
interface Video {
      public void exibir(); 
}

//Interface Som (não há implementação de método)
interface Som {
      public void tocar();
}

//Classe Filme que implementa as interfaces Video e Som (funciona )
class Filme implements Video, Som {
       public void tocar() {
              System.out.println(“Do re mi fa sol la si”);

       }
       public void exibir() {
               System.out.println(“Vendo o filme”);
       }

}

Complicado, não? Mas com o tempo, a gente pega a prática 🙂

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.

Upload de arquivo com DWR

DWR é um framework Java que simula chamadas de métodos Java em Javascript.

Legal, não? 🙂

Aqui, vou mostrar um exemplo de upload de uma imagem

Primeiro, a gente cria a classe que vai fazer o upload:

package com.blogspot.blogdotakemura.test;

import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class UploadFile {

public String uploadImage(BufferedImage image) {
try {
File file = new File(“teste.png”);
ImageIO.write(image, “png”, file);
return file.toURI().toString();
} catch (Exception e) {
e.printStackTrace();
return “”;
}
}

}

Depois, crio o arquivo dwr.xml em WEB-INF e adiciono as seguintes linhas:




Agora, é só criar a página JSP:

Upload test

Se tudo der certo, agora você pode fazer upload de imagens com javascript!!!!

Uau! 😛

Obs.: Para que isso funcione, é preciso configurar o dwr corretamente na aplicação web.

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.

Como executar um programa Java dentro de seu programa Java

Pergunta estranha não?

É que eu não tinha mais nada para inventar 😛

É possivel executar um programa Java dentro de outro de várias maneiras Vou citar duas delas:

1) Rodando via a classe/objeto Runtime:
Runtime.getRuntime().exec(“java HelloWorld”);

2) Chamando diretamente o método estático main da outra classe:
public static void main(String[] args) throws Exception {

HelloWorld.main(args);

}

É isso aí Será que isso é interessante para alguém? 😛

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.

O que é synchronized em Java

Como prometido, vou falar do que seja o synchronized em Java. 🙂

Sincronizar métodos significa que, ao rodar sua aplicação e um mesmo método for chamado ao mesmo tempo (por exemplo, em uma execução de Thread), a execução da primeira chamada será feita por completo para que, depois, a próxima chamada seja feita, ou seja, o bloco sincronizado não é executado de forma paralela e sim, em forma de uma fila (um depois do outro).

Sei que não é fácil entender (e nem de explicar ), mas com o tempo a gente pega a prática

O importante é saber que, na maioria das vezes, prefira usar classes que não usam métodos sincronizados (tipo ArrayList em vez de Vector, StringBuilder em vez de StringBuffer), pois são mais performáticos.

Somente utilize classes com métodos sincronizados, se você precisar que o bloco de execução seja executado por inteiro, sem interrupções (isso é mais para sistemas que usam Thread ).

Acho que em vez de explicar, compliquei mais a vida dos programadores 😛

Exemplo? Fica para a próxima (é díficil de fazer :P), mas se quiser, a declaração do método é assim:

public synchronized void incA() {
a++;
}

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.

O que é transient em Java

Afinal, para que serve a palavra reservada transient?

Hum Sei lá, deve servir para alguma coisa. 😛

Falando sério, serve para deixar a propriedade de uma classe “gravável”, não “gravável”.

Está bem Concordo que a explicação ficou meio “tosca”. Vamos ao exemplo, que é melhor:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;

public class Usuario implements Serializable {

private static final long serialVersionUID = 2898873189053002193L;
private String username;
//Password é uma propriedade “transient”
private transient String password;

//Construtor da classe
public Usuario(String username, String password) {
this.username = username;
this.password = password;
}

//Método que salva o estado do objeto
public void save() {
ObjectOutputStream output = null;
try {
output = new ObjectOutputStream(new FileOutputStream(hashCode() + “.obj”));
output.writeObject(this);
} catch (IOException e) {
e.printStackTrace();
} finally {
close(output);
}
}

//Fecha o arquivo de saída
private static void close(OutputStream output) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}

//Carrega o último estado do objeto salvo
public void load() {
ObjectInputStream input = null;
try {
input = new ObjectInputStream(new FileInputStream(hashCode() + “.obj”));
Usuario usuario = (Usuario)input.readObject();
this.username = usuario.username;
this.password = usuario.password;
} catch (Exception e) {
e.printStackTrace();
} finally {
close(input);
}
}

//Fecha o arquivo de leitura
private static void close(InputStream input) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}

//Transforma o objeto em uma String
public String toString() {
return “Username:” + username + “ Password:” + password;
}

//Método principal
public static void main(String[] args) {
//Cria um novo usuário
Usuario usuario = new Usuario(“ricardo”, “takemura”);
//Salva ele
usuario.save();
//Exibe as informações
System.out.println(usuario);
//Carrega ele
usuario.load();
//Exibe as informações
System.out.println(usuario);
}
}

Agora, se executarmos o código acima, veremos que o sistema exibirá as seguintes linhas:

Username:ricardo Password:takemura
Username:ricardo Password:null

Ué Cadê o valor da password na segunda linha?

Então, é isso que a palavra “transient” significa, ou seja, mesmo que o objeto seja “gravável” (estendendo de “Serializable”), uma propriedade transient não será salva.

Agora, para que isso?

Para informações sigilosas, calculadas ou “não importantes” (e deixar um objeto grávavel custa processamento ).

Deu para entender? 😛

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.