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.
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
-------------------------------------------\\-----------------------------------------------
Figura 5 - Calculadora em funcionamento.
Math.sqrt(número);
java.awt.Toolkit.getDefaultToolkit().beep();
tela.setHorizontalAlignment(JTextField.RIGHT);
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!
Gostei muito do blog. O código completo pode ficar em um site externo.
ResponderExcluir