Fiz o que você sugeriu acima…
Porém, tenho algumas duvidas.
Criei a interface com as variaveis que são constantes(imutaveis - nunca mudam).
Declarei essas Strings como constantes, pois elas nunca mudam na aplicação. E é nisso que me surgiu a primeira duvida…
package menus;
public interface Const {
public final String MENU = "MENU ";
public final String INSERIR = "\n01 - INSERIR ";
public final String EDITAR = "\n02 - EDITAR ";
public final String BUSCAR = "\n03 - BUSCAR ";
public final String EXCLUIR = "\n04 - EXCLUIR ";
public final String INFORMACOES = "\n04 - INFORMACOES ";
public final String SAIR = "\n05 - SAIR ";
public final String RETORNAR = "\n06 - RETORNAR ";
public final String CLIENTE = "CLIENTE ";
public final String FILME = "FILME ";
public final String LOCACAO = "LOCACAO ";
public final byte RETORNO = (byte) 5;
String creatMenuMain();
String creatSubMenu();
}
[color=red]Duvida 01:[/color]
Em termos de processamento e memoria…
1 - Criar um variavel constante em uma interface e ficar chamando ela como eu fiz…
2 - Criar uma variavel String em cada classe que for usar…
Na minha opinião na primeira gastamos mais processamento e na segunda gastamos mais memoria. Pode parecer uma pergunta meio tola, mas qual das duas seria recomendavel para uma boa programação?
Criei uma classe pai para declarar metodos que vão se repetir em mais de uma classe.
Ex: O metodo inserir se repetirá em cliente, filme e locacao.
Ainda não implementei esses metodos aqui.
package menus;
public class Functions implements Const {
public void Retornar(byte a) {
while (a != RETORNO);
}
public void Sair() {
System.exit(0);
}
@Override
public String creatMenuMain() {
return null;
}
@Override
public String creatSubMenu() {
return null;
}
}
[color=red]Duvida 02:[/color]
Os metodos creatMenuMain() e creatSubMenu() foram declarados na interface.
Porem eles não me são uteis nessa classe. Só estão ai porque precisava pegar a constante RETORNO que se encontra na interface.
Então, quando estava programando o compilar acusou um erro falando que eu deveria implementar esses metodos. Implementei eles para não dar mais erro, porem isso é um tanto desnecessario ao meu ver.
Alguem poderia me explicar o porque disso mais detalhadamente?
Logo em seguida criei os menus que seriam necessarios:
Menu Principal:
package menus;
public class MenuPrincipal extends Functions implements Const {
@Override
public String creatMenuMain() {
StringBuilder menuMain = new StringBuilder();
menuMain.append("\n01 - " + MENU + CLIENTE);
menuMain.append("\n02 - " + MENU + FILME);
menuMain.append("\n03 - " + MENU + LOCACAO);
menuMain.append(INFORMACOES);
menuMain.append(SAIR);
return menuMain.toString();
}
@Override
public String creatSubMenu() {
return null;
}
}
Menu Cliente:
package menus;
public class MenuCliente extends Functions implements Const{
@Override
public String creatSubMenu() {
StringBuilder menuCliente = new StringBuilder();
menuCliente.append(INSERIR + CLIENTE);
menuCliente.append(EDITAR + CLIENTE);
menuCliente.append(BUSCAR + CLIENTE);
menuCliente.append(EXCLUIR + CLIENTE);
menuCliente.append(SAIR);
menuCliente.append(RETORNAR);
return menuCliente.toString();
}
@Override
public String creatMenuMain() {
return null;
}
}
Menu Filme:
package menus;
public class MenuFilme extends Functions implements Const{
@Override
public String creatSubMenu() {
StringBuilder menuFilme = new StringBuilder();
menuFilme.append(INSERIR + FILME);
menuFilme.append(EDITAR + FILME);
menuFilme.append(BUSCAR + FILME);
menuFilme.append(EXCLUIR + FILME);
menuFilme.append(SAIR);
menuFilme.append(RETORNAR);
return menuFilme.toString();
}
@Override
public String creatMenuMain() {
return null;
}
}
Menu Locacao:
package menus;
public class MenuLocacao extends Functions implements Const{
@Override
public String creatSubMenu() {
StringBuilder menuLocacao = new StringBuilder();
menuLocacao.append(INSERIR + LOCACAO);
menuLocacao.append(EDITAR + LOCACAO);
menuLocacao.append(BUSCAR + LOCACAO);
menuLocacao.append(EXCLUIR + LOCACAO);
menuLocacao.append(SAIR);
menuLocacao.append(RETORNAR);
return menuLocacao.toString();
}
@Override
public String creatMenuMain() {
return null;
}
}
Para tratar as opcoes de menu, chamei todos eles na main:
package driver;
import javax.swing.JOptionPane;
import menus.MenuCliente;
import menus.MenuFilme;
import menus.MenuLocacao;
import menus.MenuPrincipal;
public class Driver {
public static void main(String[] args){
MenuPrincipal menuPrincipal = new MenuPrincipal();
MenuCliente menuCliente = new MenuCliente();
MenuFilme menuFilme = new MenuFilme();
MenuLocacao menulocacao = new MenuLocacao();
byte optionMenuMain;
byte optionMenuClient;
byte optionMenuFilm;
byte optionMenuLocation;
do{
optionMenuMain = Byte.parseByte(JOptionPane.showInputDialog(menuPrincipal.creatMenuMain()));
switch(optionMenuMain){
case 1:
//Inicia o menu de cliente
optionMenuClient = Byte.parseByte(JOptionPane.showInputDialog(menuCliente.creatSubMenu()));
if(optionMenuClient == 1){
//Inserir Cliente
JOptionPane.showMessageDialog(null, "Inseriu");
}else if(optionMenuClient == 2){
//Editar Cliente
JOptionPane.showMessageDialog(null, "Editou");
}else if(optionMenuClient == 3){
//Buscar Cliente
JOptionPane.showMessageDialog(null, "Buscou");
}else if(optionMenuClient == 4){
//Retornar
JOptionPane.showMessageDialog(null, "Excluiu");
}else if(optionMenuClient == 5){
//Sair
JOptionPane.showMessageDialog(null, "Saiu");
}else if(optionMenuClient == 6){
//Retornar
JOptionPane.showMessageDialog(null, "Retornou");
}else{
//Comando invalido
JOptionPane.showMessageDialog(null, "Comando Invalido");
}
break;
case 2:
//Inicia o menu de filme
optionMenuFilm = Byte.parseByte(JOptionPane.showInputDialog(menuFilme.creatSubMenu()));
break;
case 3:
//Inicia o menu de locacao
optionMenuLocation = Byte.parseByte(JOptionPane.showInputDialog(menulocacao.creatSubMenu()));
break;
case 4:
break;
case 5:
//Sai da aplicacao
menuPrincipal.Sair();
break;
}
}while(true);
}
}
[color=red]Duvida 3:[/color]
Tenho muitas opcoes para tratar ainda. Porem, qual seria a melhor maneira de trata-los…digo, Usarei o switch ou o if e else?
De qual maneira ficarei menos perdido dentre tantas condições?