Countdown

Final Countdown

Faltam dias. Ou segundos.

sexta-feira, 27 de março de 2015

#12) Manipulação de Arquivos

Boa noite!

Hoje venho aqui novamente relatar novidades descobertas durante o desenvolvimento do projeto Boot (o programa gerenciador de Hyperlinks), que agora se encontra em sua versão V 1.2:

Link do código do Projeto (Versão 1.2):

O assunto de hoje é a manipulação de arquivos (Files) diversos, sendo que vamos tratar em particular a criação de arquivos .txt para armazenar informações do nosso programa, de modo que seja possível salvar os dados fornecidos pelo usuário em um arquivo externo. 
Assim, é possível recuperar esses dados em uma futura execução do programa, como estamos habituados a abrir e salvar arquivos de texto .doc, por exemplo.

---//---

[Class File]

Essa classe tem a função exclusiva de navegação através dos diretórios e exibição das propriedades dos arquivos, como tamanho, última alteração, sua existência, etc. Resumindo, tem as funcionalidades do explorer. Sua importação é feita por:
import java.io.File;

Nada melhor para mostrar o emprego de uma classe que um exemplo de aplicação prática. A seguinte aplicação é um explorador rústico de arquivos, que mostra as informações do arquivo/diretório digitado:

-------------------------------------------\\-----------------------------------------------
package cmd;
import javax.swing.*;
import java.io.File;
 
public class CMD
{
    public static void main(String[] args) {
 
        JOptionPane.showMessageDialog(null, "Bem vindo ao Explorer",
                    "Explorer", JOptionPane.WARNING_MESSAGE);
        String caminho = JOptionPane.showInputDialog(null,"Digite algum endereço.");
 
        while(!navega(caminho))
            caminho = JOptionPane.showInputDialog(null,">>"+caminho+"\nDigite algum endereço.");
    }
 
    public static boolean navega(String caminho)
    {
        String info = "";
        File arquivo = new File(caminho);
 
        if( arquivo.exists() )
        {
            info+= "O caminho especificado existe !\n"+ ">>"+caminho+"\n\n";
            if(arquivo.isFile()){
                 info += "É um arquivo de tamanho "+arquivo.length()+ " bytes\n"
                        + "Útima vez modificado "+arquivo.lastModified()+"\n"
                        + "Cujo caminho é "+arquivo.getPath()+"\n";
                 JOptionPane.showMessageDialog(null, info,
                    "Alerta", JOptionPane.WARNING_MESSAGE);
                 return true;
            }
            else
            {
                 info += "O diretório contém os arquivos:\n";
                 String[] arquivos = arquivo.list();
 
                 for( String file : arquivos)
                   info += file +"\n";
            }
        }
        else  info += "Endereço errado";
        JOptionPane.showMessageDialog(null, info,
                    "Alerta", JOptionPane.WARNING_MESSAGE);
        return false;
    }
}
-------------------------------------------\\-----------------------------------------------
Código 1 - Explorador de arquivos e diretórios.

Cuidado apenas ao abrir diretórios muito grandes, pois poderá gerar uma janela muito grande, o que será um pouco desconfortável.

Figura 1 - Programa Explorer.

---//---

[Class Formatter]

A classe Formatter é usada para escrever em arquivos. Assim como na linguagem C, deve-se usar comandos para abrir e fechar o arquivo .txt a ser manipulado. Sua inclusão é feita por:
import java.util.Formatter;
A chamada "fopen" é feita por:
  try {                                                        
            arquivo = new Formatter(file + ".txt");
        } catch (...) { ...}                                          

A estrutura try - catch tem a funcionalidade de evitar possíveis erros na geração do arquivo, como falta de permissão de criação do arquivo (diretório restrito ou arquivo já existente).

A chamada "fclose" é bem simples:
arquivo.close();

Sua escrita é relativamente simples e sem complicação:
            arquivo.format(stringAescrever);


---//---

[Class Scanner]

A classe Scanner é usada ler arquivos. Assim como na linguagem C, deve-se usar comandos para abrir e fechar o arquivo .txt a ser manipulado. Percebe-se grandes semelhanças entre esta classe e a classe Formatter:
import java.util.Scanner;
A chamada "fopen" é feita por:
  try {                                                                              
            arquivo = new Scanner(new File(filename + ".txt");
        } catch (...) { ...}                                                              

A estrutura try - catch tem a funcionalidade de evitar possíveis erros na leitura do arquivo, como a inexistência do arquivo. Note que este problema pode ser resolvido usando a Classe File, vista no post de hoje.

A chamada "fclose" é bem simples e idêntica à da classe Formatter:
arquivo.close();

Sua leitura não poderia ser mais simples:
entrada.hasNext();

terça-feira, 24 de março de 2015

#11) Data e Hora

Bom dia!

Hoje a ideia é relatar uma descoberta feita durante o desenvolvimento do projeto do programa Gerenciador de Hyperlinks, o primeiro projeto (projeto Boot) do curso de CES-22, que eu já havia comentado em posts passados.
Link do Wiki do Projeto:
Link do código do Projeto (Versão 1.1):

---//---

[Data e Hora]

Uma das tarefas neste projeto é armazenar a data e hora da última modificação de uma dada Url de um banco de dados. Para esta finalidade, podemos usar algumas classes já prontas em Java, que serão abordadas no tópico de hoje.

1. Classe Date

A classe Date representa um instante no tempo, através do método getTime. Para marcar o tempo, é considerado o número de milissegundos decorridos desde 1º de janeiro de 1970. Essa classe é especialmente útil para calcular diferenças entre datas.
-------------------------------------------\\-----------------------------------------------
package simples;
import java.util.Date;

public class Simples {
    public static void main(String[] args) {
        Date agora = new Date();
        long tempo = agora.getTime();   // Número de milissegundos desde 01/01/1970
        Date novaData = new Date(agora.getTime());
        System.out.println(tempo);    
    }
}
-------------------------------------------\\-----------------------------------------------
Código 1 - Uso da Classe Date

2. Classe DateFormat

A classe DateFormat complementa a classe anterior, formatando a data em uma String com informações sobre a data em um objeto Date, no formato xx/xx/xxxx que utilizamos no cotidiano. Abaixo uma demonstração de como utilizar a classe:
-------------------------------------------\\-----------------------------------------------
package simples;
import java.util.Date;
import java.text.DateFormat;

public class Simples {
    public static void main(String[] args) {
        DateFormat dateformat = DateFormat.getDateInstance(DateFormat.MEDIUM);
        Date agora = new Date();
        long tempo = agora.getTime();  
        Date novaData = new Date(agora.getTime());
        System.out.println(dateformat.format(tempo));  // Data formatada. xx/xx/xxxx
    }
}
-------------------------------------------\\-----------------------------------------------
Código 2 - Uso da Classe DateFormat

3. Classe SimplesDateFormat

A classe SimplesDateFormat permite ao programador criar a sua própria formatação de data, o que pode ser muito vantajoso caso ele queira exibir alguma informação específica e omitir outras. Há toda uma codificação para data e hora, que não abordaremos nesse tópico:

-------------------------------------------\\-----------------------------------------------
package simples;
import java.util.Date;
import java.text.DateFormat;
import java.text.SimplesDateFormat;

public class Simples {
    public static void main(String[] args) {
        String formato1 = "dd/MM/yyyy, hh:mm:ss";
        DateFormat dateFormat1 = new SimpleDateFormat(formato1);
        Date agora = new Date();
        long tempo = agora.getTime();  
        Date novaData = new Date(agora.getTime());
        System.out.println(dateFormat1.format(tempo));
    }
}
-------------------------------------------\\-----------------------------------------------
Código 3 - Uso da Classe SimplesDateFormat

4. Classe Calendar

Mudando um pouco a estrutura de classe utilizada, temos a Classe Calendar, que foi a adotada em nosso projeto pela sua facilidade de se manipular a data numericamente com comandos .set e .get de diferentes parâmetros da data, como o ano, mês, dia, hora e minutos.

-------------------------------------------\\-----------------------------------------------
package simples;
import java.util.Calendar;

public class Simples {
    public static void main(String[] args) {
        String aux = "";
        Calendar data = Calendar.getInstance();
        aux += (1+data.get(Calendar.YEAR));
        System.out.println("Ano que vem será: "+aux);
        System.out.println("Já são "+data.get(Calendar.HOUR)+
                ":"+data.get(Calendar.MINUTE));
    }
}
-------------------------------------------\\-----------------------------------------------
Código 4 - Uso da Classe Calendar

Bem, por hoje é tudo! É uma técnica simples, mas que pode ter a sua utilidade, evitando que o usuário fique digitando a data, evitando erros de entrada e formatação, padronizando o seu programa e agilizando o processo de captura de data.


domingo, 22 de março de 2015

#10 Recomendação de Site

[Recomendação de Site]

Minha ideia é que este post evolua a medida que eu for descobrindo novas referências de site conforme o andamento do curso. Uma boa biblioteca sempre é necessária para o aprendizado, assim como ferramentas de trabalho podem aprimorar o desenvolvimento de novas programas.

(#1)
Tenho grande admiração pelo conteúdo deste blog, muito minucioso no sentido de que ele começa as suas explicações do básico. Assim, eu o indico a todos os leitores iniciantes do blog, que desejem aprender mais sobre a linguagem Java:
[Java Progressivo]
http://www.javaprogressivo.net/2012/08/curso-completo.html

(#2)
O próprio site do NetBeans também traz informações muito úteis sobre temas e a aplicações diversas, incluindo até mesmo pequenos tutoriais de programas com ilustrações. O conteúdo apresentado é em inglês, mas também existem algumas páginas em português:
[NetBeans]
https://netbeans.org/kb/index.html

Esse site é realmente muito bom, oferece cursos, tem opções de revistas, tutoriais diversos, bem escrito em português e com um visual agradável, trata não apenas da linguagem Java. Fortemente recomendado:
[DevMedia]
http://www.devmedia.com.br/java/

(#3)
O GitHub Gist é um site muito bom (e vocês já devem ter notado que eu faço uso dele aqui no Blog) para armazenar os códigos dos seus programas de maneira simples e rápida em um ambiente virtual. Recomendo como ferramenta de publicação.
[GitHub Gist]
https://gist.github.com/

(#4)
Esse site traz tutoriais diversos para linguagens diversas, seu conteúdo e vasto e ainda conta com um terminal e IDE online com diversas linguagens de programação disponíveis. Tem ainda possibilidade de acessar tutores online e cursos avançados online. Acho que essa é a dica mais forte que trago hoje. O conteúdo do site é inteiramente em inglês.
[TutorialsPoint]
http://tutorialspoint.com/
http://www.tutorialspoint.com/compile_java_online.php

TutorialsPoint.

(#5)
Site indicado para aqueles que desejam aprender sobre a linguagem HTML e afins relacionados à estruturação de um Website. HTML (esqueleto do site), CSS(folha de estilo em cascata - ferramenta para definir a apresentação de um site), PHP (funcionalidades avançadas do site), Javascript (código semelhante à linguagem C com grande liberdade de criação), dentre outros.  Como recomendação:
[W3schools]
http://www.w3schools.com/html/

quarta-feira, 18 de março de 2015

#9 Criação de GUI & Browser

Bom dia!

Hoje eu tratarei de uma descoberta que fiz recentemente relativa à ferramenta do NetBeans para a criação de uma interface gráfica (GUI - Graphic User Interface) de maneira muito mais simplificada que a apresentada em posts passados.
Em vez de declarar, criar, posicionar, adicionar, colocar funcionalidades de interação (Quantos verbos!), iremos editar diretamente a interface gráfica do nosso programa com auxílio do NetBeans. Todas as funções já estarão implementadas para nós, bastando preenchê-las conforme o nosso desejo.

---//---

[Criação de GUI]

Comecemos criando um novo projeto normalmente, com a diferença de não criar uma "Classe Principal", na segunda tela da criação de um novo projeto. Depois, navegue pelo pacote do projeto e crie um novo Form JFrame, conforme a imagem:

Figura 1 - Criação de um novo Form JFrame.

 A próxima Figura 2 resume o assunto que é abordado no tópico de hoje: uma GUI para a criação de uma outra GUI (pelo usuário).

Figura 2 - GUI para a criação de uma GUI.

O seu uso é bem intuitivo. Clique e arraste os elementos do painel da direita para a tela do seu programa. Arrume conforme desejar, use o clique da direita para acessar as propriedades dos elementos, renomeá-los e editar suas propriedades.

Nas abas superiores, temos na primeira aba "Código Fonte" do programa. Alguns trechos se apresentarão cinzentos, o que indica que não poderão ser editados pela codificação, somente através da aba "Projeto", ou seja, graficamente.

Você pode a qualquer momento clicar duas vezes sobre um botão, por exemplo, e adicionar uma nova funcionalidade:

Figura 3 -Adicionando o botão Quit.

É possível também editar o nome da aplicação, acessando as propriedades da tela principal (Frame), basta acessá-la usando o clique da direita:
Figura 4 -Mudando o título da tela principal.

Na aba "Eventos" é possível você adicionar os ActionListenners abordados em tópicos anteriores, adicionando funções como "Tecla pressionada", "Mouse clicado", etc..

Bem, a ideia de hoje é apresentar a funcionalidade ao leitor, mas gostaria de mostrar uma aplicação interessante do assunto. Vamos criar um navegador Browser simplista em Java. Comece tentando criar algo da forma:
Figura 5 - Interface GUI do navegador.

O painel interno com o símbolo Java é um "Quadro Interno". Já a tela branca no interior é um "Painel do Editor". Edite o link do Browser para que ele comece em "https://". Muito bem. clique no botão "Go" e adicione o pequeno código a seguir:

        try {
            jEditorPane1.setPage(jTextField1.getText());
        } catch (IOException ex) {
            Logger.getLogger(GuiAppGUI.class.getName()).log(Level.SEVERE, null, ex);
        }

O resultado será um tanto bronco. A visualização dos sites perderá o formato e erros surgirão ao se digitar uma URL incorretamente (sem o https://) ou ao clicar em algum link. Enfim, apesar de ser um programa um tanto rudimentar, podemos ainda assim ver os resultados do nosso projeto:

Figura 6 - Resultado no mini - projeto.

Aos interessados no projeto de um browser, aconselho o seguinte site para aprofundar os seus estudos, não somente deste programa, mas da linguagem Java em geral. Aconselho fortemente a pesquisar suas dúvidas e ideias no conteúdo muito rico e bem feito do devmedia:

Também recomendo o site do NetBeans para quem quiser aprofundar mais no tema da Criação de GUI. Voltarei a abordar o tema muito em breve neste blog, por isso é importante fixar bem o conteúdo para acompanhar os futuros projetos aqui desenvolvidos.

Por hoje é só! 

segunda-feira, 16 de março de 2015

#8 Criando o executável

Boa noite!

Hoje me perguntaram como obter um arquivo executável a partir do seu código .java. Foi então que eu reparei que até o dado momento eu não abordei o assunto devidamente. Acho que é de grande interesse do leitor obter conhecimento sobre esse assunto, pois um arquivo executável torna o projeto versátil e facilita sua utilização por outras pessoas por fora do assunto.

---//---

[O Arquivo Executável]

Cada IDE, seja ela NetBeans, Eclipse ou até mesmo o bloco de notas, contém uma forma diferente de se criar o arquivo executável .jar - Java Archive, um arquivo compactado para distribuir um conjunto de classes Java. O arquivo pode ser comprimido até mesmo por compactadores como o Winzip. A diferença é que o arquivo .jar possui um manifesto que tem a intenção de ser executado, como um arquivo .exe do Windows. Portanto apresentarei cada método separadamente:

1) NetBeans

Os leitores do blog já devem estar habituados à IDE, porém devem se perguntar como executar o seu programa fora do ambiente de desenvolvimento. A solução é simples, basta pressionar F11 ou acessar na aba [Executar] -> [Criar Projeto].

Figura 1 - Criando o arquivo executável do Projeto.

O arquivo executável (.jar) se encontrará na pasta do projeto, que geralmente fica no diretório dos projetos do NetBeans, em:
 C:\Users\[Nome do Usuário]\Documents\NetBeansProjects

Uma vez na pasta do projeto, procurar a pasta "dist". O arquivo com o símbolo do Java (a xícara de café) é o executável procurado.

Figura 2 - Arquivo Jar.

Aconselho fortemente a ler o item 3, devido a uma restrição de execução do arquivo .jar: se o seu programa utilizava comandos de escrita no prompt de comando (na janela de saída do Netbeans), os comandos não serão exibidos na tela, a menos que você execute seu programa do prompt de comando.

2) Eclipse

Apesar de eu não possuir a IDE, hoje ajudei um colega de turma a criar o arquivo .jar. O método é bem parecido, mas não utiliza a função Build, como o esperado. É preciso acessar a primeira aba [Arquivos] -> [Export]. Expanda a seção "Java" e então escolha Runnable Jar. Depois é só escolher o método principal a ser compactado e a pasta de destino do arquivo. 
Aconselho fortemente a ler o item 3, devido a uma restrição de execução do arquivo .jar: se o seu programa utilizava comandos de escrita no prompt de comando (na janela de saída do Eclipse), os comandos não serão exibidos na tela, a menos que você execute seu programa do prompt de comando.


3) Bloco de Notas (Prompt de Comando)

É possível utilizar o Bloco de Notas para digitar o código e salvá-lo no formato .java. Mas não há como fazer mágica. É preciso ter o "Java Software Development Kit" (JDK) instalado para poder compilar o seu programa:

Figura 3 - JDK deve estar instalado.

O próximo passo é configurar corretamente as variáveis de ambiente do Windows:

Uma vez corretamente configuradas as variáveis de ambiente, acesse o prompt de comando do Windows:
-> [Tecla Windows] + R
-> Digite "cmd"
-> Enter

É bom ter alguma noção sobre os comandos DOS para não se perder na navegação. Contudo, basta usar o comando
cd [Diretório do Arquivo .java]
 como por exemplo:   cd C:\Users\[Usuário]\Desktop

Para ser encaminhado ao diretório. Lá, use o comando
javac seuPrograma.java

Perceba que um arvquivo seuPrograma.class foi criado na mesma pasta. Agora é possível executar o seu programa com o comando:
java seuPrograma

Para arquivos que utilizam mais de uma classe o comando javac é ligeiramente alterado, sendo que este caso não será tratado neste Blog, mas caso o leitor se interesse, pode consultar o seguinte material:

Caso o seu arquivo já se encontre na forma executável .jar e você queira executá-lo do prompt de comando, utilize o comando:
java -jar seuPrograma.jar

Creio que esse método para executar o arquivo não o agradou muito, assim como não me agradou. Assim, bolei um pequeno arquivo .bat (programação de comandos DOS) a fim de realizar essas tarefas chatas automáticamente:

  1. @echo off
  2. java -jar seuPrograma.jar
  3. pause

E depois salve o arquivo como [NomeDoArquivo].bat e coloque este arquivo no mesmo diretório do arquivo .jar. Muito bem, agora um prompt de comando será executado ao abrir o arquivo .bat.

domingo, 15 de março de 2015

#7 POO (2) - Subclasses & Herança

Olá, tudo bem?

A ideia de hoje é explorar alguns conceitos de Orientação a Objetos, como Subclasses e Herança, extensão quase imediata dos conceitos de Classe vistos na Lição 5.


---//---

[POO (2) - Subclasses e Herança]

Uma Subclasse é uma divisão hierárquica de classes, uma espécie de subconjunto de métodos e variáveis de um conjunto maior. Por exemplo, podemos ter uma Classe Pessoa com variáveis como Nome e RG, e métodos como Comer() e Dormir(). Podemos ter uma SubClasse Engenheiro com a variável Salário, métodos Projetar() e Construir(), por exemplo. Um objeto da Subclasse Engenherio teria também as variáveis de uma pessoa, Nome e RG além de poder usar os seus métodos, Comer() e Dormir(). Porém um objeto da classe Pessoa não pode ter as variáveis ou usar métodos de um Engenheiro.
Figura 1 - Diagrama de Venn de Classes e Subclasses.

O conceito de a Subclasse poder usar os métodos Comer( ) e Dormir( ) da Classe Pessoa, além de suas variáveis, é chamado de Herança.
Podemos denominar a Classe Pessoa como uma Superclasse.

Às vezes alguma subclasse é abstrata demais, de forma a não admitir um objeto. Imagine uma superclasse Animal de acordo com a Figura 2 abaixo, extraída do material do curso de CES-22:

Figura 2 - Diagrama hierárquico de Classes.

Como Animal é generalizada demais, podemos declará-la como:
abstract class Animal {...}

Essa classe pode até ter métodos, como Comer( ) e Dormir( ), porém não irá admitir nenhum objeto, ou seja, não podemos fazer:
Animal Homem = new Animal();

Vamos agora para um exemplo prático. Temos a superclasse das formas geométricas e duas subclasses círculo e quadrado, conforme a Figura 3 extraída do curso de CES-22:
Figura 3 - Superclasse Formas e suas duas subclasses.

A classe Shape teria a seguinte implementação básica:

-------------------------------------------\\-----------------------------------------------
public class Shapes 
{
    private String name;
    Shapes(String aName){ name = aName;} // Construtor
    public String getName(){ return name;}
    public float calculateArea(){return 0.0f;}
}
-------------------------------------------\\-----------------------------------------------
Código 1 - Superclasse Shapes.

Agora usaremos como exercício a criação de uma subclasse triângulo. Ela deverá ter as seguintes propriedades básicas:
-> Construtor - Herdado da superclasse Shapes
-> name - Herança
-> lados (vetor de 3 elementos -  vamos simplificar o problema)
-> getName( ); - Herança
-> calculateArea( ); (deve ter uma implementação própria).

A declaração da subclasse triângulo deve ter a seguinte forma:
class Triangle extends Shape { ... }

Note que no exemplo da Calculadora já utilizamos conceitos de subclasse, mesmo sem ter conhecimento sobre o que ela era de fato e suas potencialidades. 

Assim, implementando a subclasse:

-------------------------------------------\\-----------------------------------------------
public class Shapes 
{
    private String name;
    Shapes(String aName){ name = aName;} // Construtor
    public String getName(){ return name;}
    public float calculateArea(){return 0.0f;}

    public class Triangle extends Shapes {
        private float a, b, c;              // Lados do triângulo
        Triangle (String aName){  // Construtor da subclasse Triangle.
            super(aName);                // Chama o Construtor da superclasse
            c = 3; b = 4; a = 5; 
        }
        public float calculateArea(){  // Fórmula de Heron para calcular a área (Matemática)
            float p = (a+b+c)/2;
            return (float)Math.sqrt(p*(p-a)*(p-b)*(p-c));
        }
    }
}
-------------------------------------------\\-----------------------------------------------
Código 2 - Subclasse Triangle.

Observe que o uso de uma SubClasse torna o código mais elegante e facilita a modificação do programa. Digamos que queiramos adicionar à figura geométrica a informação Número de lados, por exemplo. Bastaria adicionar essa variável à Superclasse Shapes para que todas as suas Subclasses sofressem essa modificação também.
Igualmente, fica mais fácil editar cada Subclasse e suas peculiaridades separadamente, como no cálculo da área, que é bem diferente para um círculo ou para um quadrado. O compilador realizará uma vinculação dinâmica (Dynamic Binding) do determinado Objeto ao devido método referente a ele, por exemplo, se o objeto for um quadrado, o cálculo de sua área será lado*lado, um círculo, Pi*raio*raio, a partir de uma mesma chamada de método.

O leitor pode testar o código no método main, se quiser conferir as funcionalidades do programa. Pode também conferir as Subclasses Circle e Square no código abaixo, se tiver curiosidade:
Código 3 - Subclasses Circle e Square.

Como últimas observações, não existe Herança múltipla em Java. Ou seja, não podemos implementar, por exemplo, uma pessoa hermafrodita herdando variáveis e métodos das superclasses Homem e Mulher simultaneamente. 

Temos ainda uma estrutura chamada Interface, puramente abstrata em Java. Ela é uma espécie de contrato: Todos os métodos e (variáveis que devem ser todas constantes ali) presentes devem ser implementados pelas classes que fizerem uso destas interfaces. Uma classe pode fazer uso de várias interfaces simultaneamente, contornando a limitação de não haver herança múltipla em Java. A sintaxe de uma interface é:
interface Poligono
{                           
    float area();
            float perimetro();
}                           

E depois a classe que utilizará essa interface deverá necessariamente implementar todos os métodos dessa classe, e também usar a seguinte sintaxe em sua declaração:
 public class Triangle implements Poligono { ... }

Por hoje é só! A lição foi um pouco abstrata (péssima piada), mas com uma boa superclasse de conhecimentos fica muito mais fácil desenvolver a subclasse da sua imaginação e ideias.

Gente, o blog "Aprender Java é Divertido" está no Google!! Página 1!!! Esse é um momento de glória para mim. Espero sinceramente que pelo menos algum leitor desfrute de algum conhecimento deste site algum dia. Muito bem, #PartiuTop1 !!! Até mais!