Hola.
Basta con que "relajes" la restricción del modificador de acceso del ArrayList en la clase
Implementacion.
Ahora mismo está como
private, la más restrictiva. A este nivel solo los métodos o clases declarados dentro de la clase
Implementación (dentro de una clase, puedes crear otras clases... es lo que se llama "anidar clases" (Nested Classes)) pueden ver el ArrayList.
Por eso antes el método main() podía acceder a él. Pero ahora que lo has sacado a otra clase, ya no puede verlo. Ha quedado fuera de su alcance (scope).
Por norma habitual, y por la filosofía de "encapsulamiento", siempre se recomienda que los atributos sean
private y controlar su acceso "al exterior" mediante getters y setters.
Esto es importante sobre todo cuando escribimos clases y programas que vamos a compartir con otros programadores, y no queremos que estos metan la pata accediendo a "a lo loco" a estos atributos, ya que no conocen los entresijos de nuestro código y pueden hacer un uso erróneo de estos atributos.
Pero, si es un código que escribimos para nosotros, y que sabemos lo que nos hacemos y tal... podemos relajar el control de acceso a los atributos si esto nos ayuda a hacer más fácil el código.
De nuevo, la norma dice que debemos ir aumentando el nivel escalonadamente, de más restrictivo a menos, hasta que encontremos el nivel que necesitemos sin "abrir las puertas" del todo.
Hay cuatro niveles de acceso:
private ArrayList<Medicamentos> medicamentos = new ArrayList<>();private ya lo conocemos. El atributo solo es visible dentro de su propia clase.
Este ahora mismo no te sirve. Puedes salvarlo haciendo un getter que devuelva el ArrayList de Medicamentos.
O si no, pasar al siguiente nivel:
ArrayList<Medicamentos> medicamentos = new ArrayList<>();El siguiente nivel, es no poner ningún modificador de acceso. Así de simple.
A este nivel se le llama
default y hace que el atributo sea visible a todas las clases que pertenezcan al mismo paquete
(package)Con este nivel ya te serviría para tu proposito. Tu nueva clase
Main, al estar en el mismo paquete que
Implementacion, podría acceder al ArrayList sin problemas.
protected ArrayList<Medicamentos> medicamentos = new ArrayList<>();El siguiente escalón es
protected. Aquí le abrimos la puerta de acceso a clases de otros paquetes, pero
solo si son subclases (es decir, que heredan) de
Implementacion.
Esto significa que una clase de otro package declarada como:
class nuevaClase extends ImplementacionSí podría acceder al ArrayList, porque es una subclase. De lo contrario, no podría.
public ArrayList<Medicamentos> medicamentos = new ArrayList<>();Este es último nivel. Con
public abrimos la puerta para que
cualquier clase, de cualquier paquete, pueda acceder al ArrayList y hacer con él lo quiera.
Esto significa que cualquier programador al que le pases tu clase
Implementacion,podrá instanciar un objeto de esta clase y acceder libremente al ArrayList de Medicamentos, tal vez sin saber a ciencia cierta si es un ArrayList, o sin saber que tipo de datos puede albergar, o sin saber cuál es su propósito dentro del programa ni que importancia tiene.
Y si esto fuese un programa profesional, del mundo real, este ArrayList sería muy importante porque básicamente es una base de datos donde se estaría guardando todo el stock de productos de una empresa farmaceutica.
Así que si este programador es un poco osado o torpe, y piensa que en un momento dado se le puede poner valor null a ese atributo llamado
medicamentos que no sabe muy bien lo que es (muy torpe hay que ser, pero los hay...) pues podría hacer perder una información valiosísima para la empresa.
Por esto debemos ser muy cuidadosos a la hora de declarar como
public un atributo, porque lo estamos dejando "indefenso" ante otros programadores que no conocen a fondo nuestra clase.
En cambio, poniéndolo como
private y usando getters y setters para establecer unas normas de seguridad de como debe usarse este atributo, evitamos errores y hacemos que nuestra clase sea sólida y fiable.
Por ejemplo (en plan humor):
if (nuevoArrayRecibido == null)
mostrarMensajeAlerta("Pero cómo se te ocurre pasarme un null, cerebro de melón..");
else
{
medicamentos = nuevoArrayRecibido;
mostrarMensajeInformativo("Nuevo Array aceptado. Datos farmaceutica actualizados");
}Bueno, y tras estas explicaciones (puedes ver más en
un capitulo del curso de Aprender A Programar, volvamos a tu programa.
En
Implementacion, basta con que elimines el modificador de acceso
private al ArrayList de
Medicamentos y no pongas nada. Así estaría en
default, suficiente para que la clase
Main tenga acceso a este array.
Luego en la clase
Main, en realidad no necesitas declarar ningún atributo, ni tampoco usar ningún constructor.
Lo único importante es que lo primero que haga el programa sea instanciar la clase
Implementacion que es por así decirlo, el "director de la orquesta" y el resto de clases dependen de ella.
Y así es como lo tienes, por tanto, basta con que elimines los atributos y el constructor, porque no los necesitas.
Ahora
Main ya puede ver el ArrayList de Medicamentos y puede encargarse de pasárselo al resto de clases.
Pongo en comentario, lo que puedes quitar (atributos y constructor).
Clase
Mainpackage farmaceutica;
import java.io.*;
import java.util.ArrayList;
import javax.swing.JOptionPane;
public class Main
{
//private File archivo = new File("archiyect.txt");
//private ArrayList<Medicamentos> medicamentos = new ArrayList<>();
/*
public Main(ArrayList<Medicamentos> medicamentos)
{
this.medicamentos = medicamentos;
}*/
public static void main(String args[])throws FileNotFoundException, IOException
{
//Inicializamos implementacion, quien tiene el ArrayList de Medicamentos
Implementacion implementacion = new Implementacion();
//Inicializamos el objeto que contiene las funciones del programa
AltasListado al = new AltasListado(implementacion.medicamentos);//Recibe el ArrayList de Medicamentos.
Modificacion modifica = new Modificacion(implementacion.medicamentos);
Consultas consultas = new Consultas(implementacion.medicamentos);
Bajas bajas = new Bajas(implementacion.medicamentos);
String opcions;
int opcion;
do{
opcions = JOptionPane.showInputDialog ("Menu\n 1.Altas productos\n 2.Listado de productos\n 3.Consulta de productos\n 4.Bajas\n 5. Modificacion 6.SALIR\n");
//opcions = JOptionPane.showInputDialog ("Menu\n 1.Altas productos\n 2.Consulta productos\n 3.Baja porductos\n 4.Modificacion de un producto\n 5.Listado de productos\n 6. Salir\n ");
opcion=Integer.parseInt (opcions);
switch(opcion)
{
case 1:
al.altas();
break;
case 2:
al.listado();
break;
case 3:
String opcionl;
int opc;
do{
opcionl=JOptionPane.showInputDialog ("Menu\n 1.Busqueda por clave\n 2.Busqueda por nombre\n 3.SALIR");
opc=Integer.parseInt(opcionl);
switch(opc){
case 1:
consultas.consultasc();
break;
case 2:
consultas.consultasn();
break;
}
}while(opc!=3);
break;
case 4:
bajas.mebajas();
break;
case 5:
modifica.modificar();
break;
case 6:
JOptionPane.showMessageDialog(null, "FIN del programa");
break;
default:
JOptionPane.showMessageDialog(null, "Opcion invalida");
}
}while(opcion!=6);
}
}Creo que con esto ya debería funcionar. Ya nos contarás.
Un saludo.
Tema: Programa Java de altas, bajas consulta y listado productos menú con JOptionPane (Leído 14463 veces)
RSS -
WAP2