#6 Projeto Boot (1) & Listas e Arrays

Bom dia!

Hoje resolvi fazer um rápido post comentando sobre o projeto a ser desenvolvido neste mês de Março. O projeto trata-se de um programa que gerencia Urls, captando dados a partir da entrada do usuário (como o nome da Url, metatags, comentários) e armazenando-a em uma lista capaz de armazenar várias Urls, mostrá-las de acordo com determinada metatag e ainda armazenar os dados em um banco de dados, em um arquivo de texto.

---//---

[Projeto Boot - 1]

O projeto começou com uma breve reunião entre eu e minha equipe (a minha dupla de trabalho). Decidimos por começar a implementar duas classes principais para o projeto, Boot.java (contendo o método main e o corpo principal do problema) e Hyperlink.java (contendo as funções de edição das variáveis de um Hyperlink):

Figura 1 - Boot.java.

Figura 2 - Hyperlink.java.

Os códigos das duas classes ainda estão sendo desenvolvidos, de forma que ainda não os disponibilizarei aqui. Entretanto, durante o início da codificação, percebi que seria útil utilizar uma estrutura Array para armazenar múltiplos comentários e metatags. Como a classe Array é utilizada para um número limitado e previamente conhecido de elementos, optamos por utilizar uma lista, que abordaremos na segunda parte deste post:

---//---

[Listas e Arrays]

A classe ArrayList é utilizada para coleções de objetos quaisquer, com métodos prontos para adicionar novos elementos,  retirá-los, ordená-los e procurar por algum elemento. Note que em um ArrayList a quantidade de objetos na coleção não é predeterminada, dando flexibilidade ao projeto.

Para declará-lo, é preciso usar os imports:

import java.util.Arrays;

import java.util.ArrayList;

A sintaxe da declaração de uma Lista é a seguinte:

ArrayList <Objeto> nomeDoArrayList = new ArrayList <Objeto> ():

Ex:

ArrayList<String> metatags = new ArrayList<String>();

ArrayList<String> comentarios = new ArrayList<String>();

Para adicionar um novo elemento nesta lista de metatags, basta usar o comando add():

metatags.add("aprender java");

metatags.add("java divertido");

É possível adicionar um novo elemento em qualquer posição da lista:

metatags.add(0, "lista java");

Para acessar determinada posição da lista:

metatags.get(0);

Há também métodos para determinar o tamanho da lista:

metatags.size();

Para remover um elemento, é só usar o comando remove():

metatags.remove("aprender java");

metatags.clear(); // Remove todos os elementos.

Como eu fiquei encarregado de desenvolver o método main (Classe Boot) e o meu parceiro a classe Hyperlink, minha tarefa consiste em desenvolver um ArrayList de Hyperlinks. Usando a estrutura esboço da Figura 2, criei um pequeno código para demonstrar as funcionalidades de uma lista:

-------------------------------------------\\-----------------------------------------------

package hyperlink;

import java.util.Arrays;

import java.util.ArrayList;

public class Boot {

       public static void imprimeLista(ArrayList<Hyperlink> U){

           System.out.println("");

           for (int i=0; i<U.size(); i++)

               System.out.println("Url "+(i+1)+": "+U.get(i).getNome() );

           if (U.size()==0)

               System.out.println("Lista Vazia!");

        }

       public static void main(String[] args) {

            ArrayList<Hyperlink> Urls = new ArrayList<Hyperlink>();

            Hyperlink Url1 = new Hyperlink();

            Url1.setNome("Youtube");

            Urls.add(Url1);

            imprimeLista(Urls);

            Hyperlink Url2 = new Hyperlink();

            Url2.setNome("Java divertido");

            Urls.add(Url2);

            imprimeLista(Urls);

            Hyperlink Url3 = new Hyperlink();

            Url3.setNome("Gmail");

            Urls.add(0,Url3);

            imprimeLista(Urls);

            Urls.remove(Url1);

            imprimeLista(Urls);

            

            Urls.clear();

            imprimeLista(Urls);

       

       }

    

}

-------------------------------------------\\-----------------------------------------------

Código 1 - Exemplo do uso da Lista de Hyperlinks.

Figura 3 - Saídas do exemplo da Lista de Hyperlinks.

E assim encerramos a lição de hoje. Assim que houver evolução do código do método main, disponibilizo ele aqui, explicando o seu funcionamento.

Até.

#5 POO (1) & Calculadora

Olá queridos leitores!

Hoje abordaremos um dos tópicos mais importantes, a Programação Orientação a Objetos, na qual a linguagem Java se baseia fortemente. Vamos também desenvolver o programa da Calculadora com interface gráfica.

---//---

[POO - Programação orientada a Objetos]

A OO (Orientação a Objetos) é muito utilizada na atualidade no mercado de desenvolvimento de software. O modelo OO é uma técnica de programação que facilita a manutenção de um programa e decompõe o problema em métodos desconexos e independentes, facilitando o desenvolvimento de sistemas.

Na OO trabalhamos com classes e objetos. Uma classe é algo abstrato que engloba variáveis e métodos sobre os objetos, que são concretos. Por exemplo, podemos ter uma classe Carro com métodos para acelerar e frear, variáveis como data de fabricação, cor, preço, etc. E o objeto carro seria por exemplo um fusca, que teria os métodos declarados na classe (acelerar e frear) e determinados valores para as variáveis (fabricado em 1990, branco, etc).

Para construir o novo exemplo, vamos criar uma nova classe Java, basta abrir o pacote helloworld à direita, clique da direita e criar a classe Carro.java:

Figura 1 - Criação de nova Classe.

Para começar, criemos variáveis de modelo, cor e velocidade, bem como métodos para acelerar, frear e mostrar a velocidade no carro:

-------------------------------------------\\-----------------------------------------------

package helloworld;

    public class Carro

    {

        private float velocidade;

        public String cor, modelo;

        

        // A variável velocidade não pode ser mudada diretamente na main por ser private

        // Usar, por exemplo, "fusca.velocidade = 100;" daria um erro de compilação do código.

        public void setVelocidade(float velocidade){

            this.velocidade = velocidade;    // this.velocidade se refere à velocidade do objeto

        }                                                  // diferenciando da velocidade recebida como parâmetro

        public void mostrarVelocidade(){

            System.out.println(modelo+" "+cor+" a"+velocidade);

        }

        public void acelerar(float aumento){

            velocidade += aumento;

        }

        public void frear(float diminuicao){

            velocidade -= diminuicao;

        }

    }

-------------------------------------------\\-----------------------------------------------

Código 1 - Classe básico do carro.

Note que devido ao qualificador private da variável velocidade somente as funções da própria classe Carro podem alterar a variável ou obter o seu valor, de forma que se torna necessário a criação de funções como setVelocidade(), acelerar() e frear(). Já o qualificador public das variáveis cor e modelo permitem a sua alteração por outros métodos e classes, como o método main.

Agora, utilizamos o método main para fazer uso da classe criada, executando algumas operações sobre o objeto carro fusca, pertencente à classe Carro.

-------------------------------------------\\-----------------------------------------------

package helloworld;

public class HelloWorld {

    public static void main(String args[]){

        Carro fusca = new Carro();

        fusca.cor = "branco";

        fusca.modelo = "fusca";

        

        fusca.setVelocidade(150);

        fusca.mostrarVelocidade();

        fusca.acelerar(50);

        fusca.mostrarVelocidade();

        fusca.frear(100);

        fusca.mostrarVelocidade();

    }

}

-------------------------------------------\\-----------------------------------------------

Código 2 - Método main utilizando classe básica do carro.

Figura 2 - Método main utilizando classe básica do carro.

Note que as atribuições de cor, modelo e velocidade inicial poderiam ser realizados por uma função construtora, chamada imediatamente após o comando fusca = new Carro():

-------------------------------------------\\-----------------------------------------------

package helloworld;

    public class Carro

    {

        private float velocidade;

        public String cor, modelo;

        public Carro(String cor, String modelo, float velocidade){

            this.cor = cor;

            this.modelo = modelo;

            this.velocidade = velocidade;

        }

        public void setVelocidade(float velocidade){

            this.velocidade = velocidade;    // this.velocidade se refere à velocidade do objeto

        }                                                  // diferenciando da velocidade recebida como parâmetro

        public void mostrarVelocidade(){

            System.out.println(modelo+" "+cor+" a"+velocidade);

        }

        public void acelerar(float aumento){

            velocidade += aumento;

        }

        public void frear(float diminuicao){

            velocidade -= diminuicao;

        }

    }

-------------------------------------------\\-----------------------------------------------

Código 3 - Classe Carro com construtor.

-------------------------------------------\\-----------------------------------------------

package helloworld;

public class HelloWorld {

    public static void main(String args[]){

        Carro fusca = new Carro("branco","fusca",150);

        

        fusca.mostrarVelocidade();

        fusca.acelerar(50);

        fusca.mostrarVelocidade();

        fusca.frear(100);

        fusca.mostrarVelocidade();

    }

}

-------------------------------------------\\-----------------------------------------------

Código 4 - Método main utilizando construtor da classe Carro.

E assim obtemos o mesmo resultado usando um construtor.

---//---

[Calculadora]

Muito bem, é hora de arregaçar as mangas e se preparar para o desafio de um primeiro projeto! A ideia é desenvolver uma calculadora simples, como as de nosso cotidiano, com uma interface gráfica (botões, tela display, etc).

Pensei dividir o projeto em duas grandes classes: A primeira seria Calculadora.java, contendo o método main e parte da interface gráfica, enquanto uma outra classe CalculatorEngine.java cuidasse das operações internas da calculadora, como se fosse uma espécie de circuito interno.

Comecei então criando um novo projeto e estas duas classes, tomei a liberdade de adicionar as bibliotecas usuais para a criação de um programa, vistas até agora:

Figura 3 - Projeto da Calculadora.

Agora é hora de modelar a parte gráfica do projeto. Comece adicionando aos poucos os botões, a tela, eventuais textos na calculadora. Use a criatividade, deverá ser uma tarefa bem divertida. Para adicionar os botões dos dígitos, recomendo usar a técnica de Arrays, uma espécie de conjunto numerado de objetos da mesma classe:

private JButton [] b = new JButton[10];

Assim, cada botão b[0], b[1], b[2], ... , b[9] representará um dígito da calculadora, ficando mais fácil de acessar e escrever cada um. Podemos usar um laço de repetição para manipular esses Arrays:

        for (int i = 1; i<10; i++){    // Para cada botão de dígito:
            b[i] = new JButton(""+i);  // Colocar o texto do dígito
            b[i].setBounds(k,j,50,25); // e posicionar segundo as variáveis
            add(b[i]);                 // auxiliares

        }
Com base nesse exemplo, pode-se reduzir bruscamente o tamanho do código e o esforço do programador, tornando o código mais claro e sucinto.

Bem, após terminar a parte da interface gráfica, você deverá ter algo no seguinte formato:

-------------------------------------------\\-----------------------------------------------

package calculadora;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
public class Calculadora extends JFrame{
    private JButton [] bOp = new JButton[4];  // Botões Operações
    private JButton [] b = new JButton[10];  // Botões dos dígitos
    private JButton bponto, bresult, blimpa, bexit;  // Botão = e Quit
    private JTextField tela;                 // Display Calculadora
    private JLabel cred;                     // Créditos do Blog
    CalculatorEngine Engine = new CalculatorEngine();
 
    public Calculadora(){  // Método construtor da classe Calculadora
        inicializar();
        eventos();
    }
 
    private void inicializar(){
        // Definindo a janela da Calculadora
        setTitle("Calculadora");
        setBounds(200,200,300,400);
        setBackground(new Color(150,150,150));
 
        // Adicionando os botões dos dígitos da calculadora
        b[0] = new JButton("0");
        b[0].setBounds(50,250,50,25);
        add(b[0]);
 
        int k = 50, j =100;  // Variáveis auxiliares
        for (int i = 1; i<10; i++){    // Para cada botão de dígito:
            b[i] = new JButton(""+i);  // Colocar o texto do dígito
            b[i].setBounds(k,j,50,25); // e posicionar segundo as variáveis
            add(b[i]);                 // auxiliares
 
            if (i%3==0) { // Chegado ao extremo da direita
                k=50;     // (Botões 3,6,9), descer uma linha
                j+=50;    // e voltar para a esquerda
            }
            else k+=50; // Ou colocar o botão mais à direita
        }
        bOp[0] = new JButton("+"); bOp[1] = new JButton("-");
        bOp[2] = new JButton("*"); bOp[3] = new JButton("/");
        for (int i = 0; i<4; i++){
            bOp[i].setBounds(200,100+50*i,50,25); add(bOp[i]);
        }
 
        // Adicionando os demais botões do programa.
 
        bponto= new JButton("."); bponto.setBounds(150,250,50,25); add(bponto);
        bresult = new JButton("="); bresult.setBounds(100,250,50,25); add(bresult);
        blimpa = new JButton("C"); blimpa.setBounds(50,300,100,25); add(blimpa);
        bexit = new JButton("Quit"); bexit.setBounds(150,300,100,25); add(bexit);
 
        tela = new JTextField(); tela.setBounds(50,50,200,30); add(tela);
        cred = new JLabel("Aprender Java é divertido");
        cred.setBounds(25,325,200,30); add(cred);
        setLayout(null);
 
    }
 
    public static void main(String[] args) {
        JFrame frame = new Calculadora();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
 
}

-------------------------------------------\\-----------------------------------------------

Código 5 - Interface Gráfica da Calculadora.

Figura 4 - Interface gráfica da calculadora.

Aproveitemos para montar o esqueleto do método eventos(), deixando espaços para implementar as funções de cada botão relacionado ao CalculatorEngine.java.

Para não poluir demais o blog, conforme comentários dos leitores, foi decidido publicar o código final do projeto em um link externo do GitHub, disponibilizado logo abaixo:

-------------------------------------------\\-----------------------------------------------

  #1 Projeto - Calculadora

https://gist.github.com/ftuyama/fc510bd511dae407ae52

-------------------------------------------\\-----------------------------------------------

Figura 5 - Calculadora em funcionamento.

A melhor parte vem agora: O projeto não tem limites. Você pode adicionar, por exemplo, um botão para o cálculo de raiz quadrada, utilizando o comando:

Math.sqrt(número);

Pode também adicionar o comando de Beep ao digitar algum dígito numérico (que não funcionou em meu computador :-( ):

java.awt.Toolkit.getDefaultToolkit().beep();

Sei que alguns detalhes não foram explicados, como por exemplo o comando de alinhamento do texto da tela à direita, segundo o comando:

tela.setHorizontalAlignment(JTextField.RIGHT);

Mas nem sempre é possível conhecer todos os comandos Java existentes. Para isso, aconselho usar algum mecanismo de busca para pesquisar a funcionalidade desejada, como eu mesmo o fiz na elaboração desse programa. Pode-se também recorrer ao autopreenchimento do NetBeans (intellisense) pressionando Ctrl+Espaço, o que mostrará alguns dos comandos existentes e suas sintaxes.

Espero que tenha apreciado o pequeno primeiro projeto. Dentro de alguns dias, daremos início a um projeto um pouco maior, sobre o qual logo explicarei mais aqui no Blog.

Até a próxima!