Java crear archivo CSV almacenar datos File createNewFile sistema citas clínicas

[jonatthan23]

Hola a todos, soy nuevo en programacion y tengo un problema que no puedo resolver, me ayudan por favor con el codigo en java??

El problema es este:

Crear un programa que simulará un sistema de administración de citas para un consultorio clínico. El programa deberá poder realizar las siguientes acciones:

• Dar de alta doctores.
• Dar de alta pacientes.
• Crear una cita con fecha y hora.
• Relacionar una cita con un doctor y un paciente.
• Tener control de acceso mediante administradores, esto es, solo ciertos usuarios podrán acceder al sistema mediante un identificador y una contraseña.

El producto final será un programa que simulará un sistema de administración de citas con las siguientes funcionalidades:

• Dar de alta doctores: se deberán poder dar de alta los doctores del consultorio médico, los datos básicos serán:
• Identificador único.
• Nombre completo.
• Especialidad.
• Dar de alta pacientes: se deberán poder registrar los pacientes que acudan al consultorio médico, los datos básicos serán:
• Identificador único.
• Nombre completo.
• Crear una cita con fecha y hora: se deberán poder crear múltiples citas, los datos básicos serán:
• Identificador único.
• Fecha y hora de la cita.
• Motivo de la cita.
• Relacionar una cita con un doctor y un paciente: cada una de las citas creadas deberá estar relacionada con un doctor y un paciente.
• Tener control de acceso mediante administradores: solo ciertos usuarios podrán acceder al sistema mediante un identificador y una contraseña.

Gracias...

[Kabuto]

Hola.
Comienza a elaborarlo poco a poco, dando pequeños pasos.

Parece evidente que como mínimo, se van a necesitar dos clases: Doctor y Paciente
De hecho el enunciado ya te dice cuáles serían sus atributos básicos.

Comienza por escribir estas clases y cuando las tengas, vemos cómo seguir.

[jonatthan23]

Hola Kabuto,
Muchas gracias por responder, te dejo el codigo la clase doctor, te comento que no me manda la pantalla para ingresar la informacion pero no me marca errores:

Código: [Seleccionar]

package clinica;

import javax.swing.JOptionPane;


public class doctor {

public static void main(String[] args) {}

private String id;
private String nombre;
private String apellidos;
private String especialidad;

public doctor(String id, String nombre, String apellidos, String especialidad) {
this.id = id;
this.nombre = nombre;
this.apellidos = apellidos;
this.especialidad = especialidad;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public String getEspecialidad() {
return especialidad;
}

public void setEspecialidad(String especialidad) {
this.especialidad = especialidad;
}

/**
* Muestra por panel todos los datos del doctor
*/
public void mostrar() {
String mensaje = "ID doctor: " + id + "\nNombre: " + nombre
+ "\nApellidos: " + apellidos + "\nEspecialidad: " + especialidad;
JOptionPane.showMessageDialog(null, mensaje, "Mostrar doctor", JOptionPane.INFORMATION_MESSAGE);
}

}


[Kabuto]

La clase Doctor (mejor con la primera letra en mayúscula para respetar la convenciones) no debería tener un método main().

El método main() irá en otra clase, que será la clase principal encargada de poner el programa en marcha, mostrar menús, pedir datos al usuario, gestionar doctores, pacientes y citas, etc...

La clase Doctor simplemente ha de modelar los atributos y métodos que podamos necesitar de un Doctor para este programa.
La clase Doctor, por si sola, no debe funcionar como un programa que se pueda ejecutar, por eso no debe llevar un método main().
Le has puesto un método main() vacío, así que en realidad no afecta demasiado. Pero es que no debe tenerlo, ni lleno ni vacío.

Así que se lo puedes(debes) quitar.
Por lo demás, parece todo correcto. Así que de igual modo, puedes escribir la clase Paciente (recuerda, sin método main()  )

package clinica;

import javax.swing.JOptionPane;


public class Doctor {

   public static void main(String[] args) {}
   
      private String id;
      private String nombre;
      private String apellidos;
      private String especialidad;
     
      public Doctor(String id, String nombre, String apellidos, String especialidad) {
         this.id = id;
         this.nombre = nombre;
         this.apellidos = apellidos;
         this.especialidad = especialidad;
      }

      public String getId() {
         return id;
      }

      public void setId(String id) {
         this.id = id;
      }

      public String getNombre() {
         return nombre;
      }

      public void setNombre(String nombre) {
         this.nombre = nombre;
      }

      public String getApellidos() {
         return apellidos;
      }

      public void setApellidos(String apellidos) {
         this.apellidos = apellidos;
      }

      public String getEspecialidad() {
         return especialidad;
      }

      public void setEspecialidad(String especialidad) {
         this.especialidad = especialidad;
      }
     
      /**
       * Muestra por panel todos los datos del doctor
       */
      public void mostrar() {
         String mensaje = "ID doctor: " + id + "\nNombre: " + nombre
               + "\nApellidos: " + apellidos + "\nEspecialidad: " + especialidad;
         JOptionPane.showMessageDialog(null, mensaje, "Mostrar doctor", JOptionPane.INFORMATION_MESSAGE);
      }

}

[jonatthan23]

Muchas gracias Kabuto por tu respuesta me ayudo mucho, ya termine las clases Paciente y Cita y estoy trabajando en unas clases gestoras de estas clases, tengo la clase GestorPacientes, te dejo el codigo de la clase main a ver que te parece: tambien podrias ayudarme con el codigo Tener control de acceso mediante administradores: solo ciertos usuarios podrán acceder al sistema mediante un identificador y una contraseña. De este no tengo ni idea.
Muchas gracias...

Código: [Seleccionar]

package clinica;

public final class TestClinica {

static GestorPacientes pacientes = new GestorPacientes();

public static void main(String[] args) {

pacientes.nuevoPaciente();
pacientes.nuevoPaciente();
pacientes.mostrarPacientes();
pacientes.modificarPaciente();
pacientes.mostrarPacientes();
pacientes.borrarPaciente();
pacientes.mostrarPacientes();

}

}

[Kabuto]

tambien podrias ayudarme con el codigo Tener control de acceso mediante administradores: solo ciertos usuarios podrán acceder al sistema mediante un identificador y una contraseña.

Sí, esta parte tampoco yo tengo claro que se espera que hagamos.
Si algo sencillo como establecer un nombre y contraseña y solicitarlos al iniciar programa, o algo más elaborado usando una clase Usuario y que solo algunos de estos usuarios sean considerados como administradores y solo a ellos se les permita acceder al programa.

Quizás esto lo podemos dejar para lo último, además ahora mismo no puedo ayudar demasiado porque, misterios de la vida, se me acaba de morir la tecla "espacio" del teclado y escribir cosas es un suplicio.
Este texto que escribo, los espacios en blanco los consigo haciendo copy/paste del espacio en blanco de otro texto, ja, ja..
Me río, pero mañana me tocará comprarme otro teclado 

[jonatthan23]

Hola, gracias por tu respuesta, esto es lo que piden de los usuarios

Tener control de acceso mediante administradores, esto es, solo ciertos usuarios podrán acceder al sistema mediante un identificador y una contraseña.

ya estoy trabajando en todas las clases y cree una clase main y ya aparecen los mensajes en pantalla para llenarlos.

saludos.

[Kabuto]

Venga, en marcha, que ya tengo teclado nuevo je je ...

Mira, para lo del acceso autorizado, para no quedarnos cortos haciéndolo demasiado sencillo, pues haremos una clase Administrador, que total tampoco es tanto trabajo.
Como lo único que tenemos que hacer es comprobar si el Administrador que accede al programa existe o no, esta clase puede ser muy sencilla.

De atributos, un nombre y un password.
Un constructor que reciba los valores para estos atributos.

Y de método, podemos sobreescribir el método equals() para facilitar el poder comparar distintos objetos Administrador para decidir si son el mismo y aceptar su acceso, o si son diferentes y no dejarle acceder.

El método equals() lo heredan TODAS las clases que escribamos en Java, pero si queremos que funcione correctamente tenemos que sobreescribirlo y "enseñarle" como debe compararse con otros objetos para determinar si son equivalentes o no.

En nuestro caso, queremos que dos Administradores se consideren equivalentes si coinciden el nombre y el password. Han de coincidir los dos.
Así que eso es lo que escribo en el método equals().

Código: [Seleccionar]

public class Administrador {

private String nombre;
private String password;

public Administrador(String nom, String pass) {
nombre = nom;
password = pass;
}

@Override
public boolean equals(Object objeto) {
if (objeto instanceof Administrador) { //Objeto si es clase Administrador
//Casteamos objeto a Administrador
Administrador otroAdmin = (Administrador)objeto;
//Comparamos si coinciden nombre y password
if (nombre.equals(otroAdmin.nombre) && password.equals(otroAdmin.password))
return true; //Coinciden ambos, los objetos representan al mismo Administrador
else
return false;//Nombre o contraseña no coinciden, son Administradores diferentes.
}
else //Objeto a comparar no es de clase Administrador
return false;
}

}

Una vez tenemos esta clase, en la clase main, podemos crear un ArrayList con unos cuantos Administradores ya creados por defecto.
Y podemos usar un método de tipo boolean para validar el acceso.
Este método pedirá al usuario un nombre y una contraseña.
Con estos datos creará un objeto Administrador.
Y comprobará si el ArrayList contiene un Administrador equivalente, en caso afirmativo se retorna true y es entonces cuando comenzará el programa que tú ya llevas escrito.

Si no hay un Administrador con esos datos de acceso, se retorna false y entonces sale un mensaje indicando que este usuario no está autorizado y el programa termina.

Código: [Seleccionar]

public class Clinica {

private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {
crearAdmins();

if (validarAcceso()) {
System.out.println("\nUsuario autorizado\n");
//Comienza el programa
//...
//...
//...
//...
}
else
System.out.println("\nUsuario no autorizado.");

System.out.println("\n\t\tFIN DE PROGRAMA");

}

private static void crearAdmins() {
administradores.add(new Administrador("Kabuto", "1234"));
administradores.add(new Administrador("jonatthan23", "5678"));
administradores.add(new Administrador("Ogramar", "0000"));
}

private static boolean validarAcceso( ) {

System.out.println("ACCESO AL SISTEMA");
System.out.println("------ -- -------\n");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Password: ");
String password = teclado.nextLine();

Administrador admin = new Administrador(nombre, password);

return administradores.contains(admin);

}

}

Y yo creo que con esto es más que suficiente para cumplir con ese punto del enunciado. 

[jonatthan23]

Hola de nuevo. Qué bueno que ya tienes teclado nuevo jeje.

Ya hice la clase administrador y funciona muy bien gracias, ahora lo que quiero es que despues de autentificar con el usuario siga corriendo el programa que ya tengo, despues de pedir usuario y contraseña, que siga con el nuevo doctor y asi sucesivamente.

También cómo puedo ir guardando los datos en un archivo CSV.

Muchas gracias por tu ayuda...

Te dejo el código :

Código: [Seleccionar]

package clinica;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public final class TestClinica {

private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
private static Scanner teclado = new Scanner(System.in);
static GestorPacientes pacientes = new GestorPacientes();
static GestorCita citas = new GestorCita();
static GestorDoctor doctores = new GestorDoctor();


public static void main(String[] args) {

crearAdmins();

if (validarAcceso()) {
System.out.println("\nUsuario autorizado\n");
//Comienza el programa
//...
//...
//...
//...
}
else
System.out.println("\nUsuario no autorizado.");

System.out.println("\n\t\tFIN DE PROGRAMA");

}

private static void crearAdmins() {
administradores.add(new Administrador("Kabuto", "1234"));
administradores.add(new Administrador("jonatthan23", "5678"));
administradores.add(new Administrador("Ogramar", "0000"));
}

private static boolean validarAcceso( ) {

System.out.println("ACCESO AL SISTEMA");
System.out.println("------ -- -------\n");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Password: ");
String password = teclado.nextLine();

Administrador admin = new Administrador(nombre, password);

return administradores.contains(admin);
}
{
doctores.nuevoDoctor();
doctores.modificarDoctor();
doctores.mostrarDoctores();
pacientes.nuevoPaciente();
pacientes.mostrarPacientes();
pacientes.modificarPaciente();
pacientes.borrarPaciente();
citas.nuevoCita();
citas.mostrarCitas();

}

}

[Kabuto]

El resto de tu programa, lo colocas dentro del if que acepta la validación.

   public static void main(String[] args) {
      crearAdmins();

      if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         doctores.nuevoDoctor();
         doctores.modificarDoctor();
         doctores.mostrarDoctores();
         pacientes.nuevoPaciente();
         pacientes.mostrarPacientes();
         pacientes.modificarPaciente();
         pacientes.borrarPaciente();
         citas.nuevoCita();
         citas.mostrarCitas();
      }
      else
         System.out.println("\nUsuario no autorizado.");

      System.out.println("\n\t\tFIN DE PROGRAMA");

   }

Para crear un CSV. Hay librerías externas que se pueden usar.
Pero en realidad un CSV es un tipo de archivo muy sencillo y si tan solo queremos crearlos, podemos hacerlo fácilmente nosotros.

Un CSV básicamente son líneas de datos separados por un delimitador, habitualmente un punto y coma ;

Para facilitar aún más el proceso, podemos enseñarle a nuestras clases a crear una línea CSV con sus datos.
Por ejemplo la clase Doctor, podemos incluirle este método:

Código: [Seleccionar]

     
      public String generaLineaCSV() {
      return String.format("%s;%s;%s;%s\n", id, nombre, apellidos, especialidad);
      }
Con ese método, podmos pedirle a cada objeto Doctor que nos retorne un String con sus datos formateados en CSV.

Luego, desde la clase GestorDoctor, ahí podemos escribir otro método que se encargue de escribir en disco un archivo CSV, con las líneas que le proporcione cada uno de los doctores que está gestionando.
Un método como este:

Código: [Seleccionar]


public void crearCSV() {

File archivo = new File("D:/csv/doctores.csv");

try {
//Si no existe archivo, intentamos crearlo
if (!archivo.exists()) {
File carpeta = archivo.getParentFile();
carpeta.mkdirs();
archivo.createNewFile();
}

FileWriter escritor = new FileWriter(archivo);
//Cabecera para datos del CSV
escritor.append("#ID;Nombre;Apellidos;Especialidad\n");

//Datos de los doctores
for (Doctor doc: doctores)
escritor.append(doc.generaLineaCSV());//Insertamos linea CSV

escritor.close();
} catch (IOException e) {
System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
}
}

De este modo, si en mi programa clínica (que no está completo y solo gestiona doctores) doy de alta a tres doctores y genero un CSV:

Código: [Seleccionar]

public static void main(String[] args) {
crearAdmins();

if (validarAcceso()) {
System.out.println("\nUsuario autorizado\n");
doctores.nuevoDoctor();
doctores.nuevoDoctor();
doctores.nuevoDoctor();
doctores.crearCSV();
}
else
System.out.println("\nUsuario no autorizado.");

System.out.println("\n\t\tFIN DE PROGRAMA");

}

ACCESO AL SISTEMA
------ -- -------

Nombre: Kabuto
Password: 1234

Usuario autorizado


ALTA NUEVO DOCTOR
---- ----- ------

ID: ID001
Nombre: Ramon
Apellidos: Luna
Especialidad: Cardiologia

ALTA NUEVO DOCTOR
---- ----- ------

ID: ID002
Nombre: Susana
Apellidos: Lopez
Especialidad: Hematologia

ALTA NUEVO DOCTOR
---- ----- ------

ID: ID003
Nombre: Raul
Apellidos: Molino
Especialidad: Endoscopia

      FIN DE PROGRAMA

Puedo comprobar que se ha generado un archivo CSV:


Y si lo abro, tengo los datos disponibles en una hoja de cálculo:

[jonatthan23]

Muchas gracias eres un master
ya estoy trabajando en ello, lo ultimo que me hace falta para terminar es lo siguiente
Relacionar una cita con un doctor y un paciente.
me ayudas con este por favor?
Saludos desde Los Cabos, México.

[jonatthan23]

Hola de nuevo, acerca de los archivos CSV, ¿cada vez que corro el programa me crea un archivo nuevo o sobreescribe la informacion?

Lo que busco es que cada vez que ingrese un administrador se vayan agregando nuevos doctores, pacientes, citas a las ya existentes y poder ir agregando y almacenando la informacion.

Te comparto un par de clases ya con el código:

Muchas gracias de nuevo


Clase con el main:

Código: [Seleccionar]

package clinica;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public final class TestClinica {

private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
private static Scanner teclado = new Scanner(System.in);
static GestorPacientes pacientes = new GestorPacientes();
static GestorCita citas = new GestorCita();
static GestorDoctor doctores = new GestorDoctor();


public static void main(String[] args) {

crearAdmins();

if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         doctores.nuevoDoctor();
         doctores.modificarDoctor();
         doctores.mostrarDoctores();
         pacientes.nuevoPaciente();
         pacientes.mostrarPacientes();
         pacientes.modificarPaciente();
         pacientes.borrarPaciente();
         citas.nuevoCita();
         citas.mostrarCitas();
         doctores.crearCSV();
         citas.crearCSV();
         pacientes.crearCSV();
      }
      else
         System.out.println("\nUsuario no autorizado.");

      System.out.println("\t\tFIN DE PROGRAMA");

   }


Clase paciente:

Código: [Seleccionar]

package clinica;

import javax.swing.JOptionPane;

public class Paciente {


private String id;
private String nombre;
private String apellidos;

public String generaLineaCSV() {
      return String.format("%s;%s;%s;%s\n", id, nombre, apellidos); 
}


public Paciente(String id, String nombre, String apellidos) {
this.id = id;
this.nombre = nombre;
this.apellidos = apellidos;

}


Clase gestorPaciente:

Código: [Seleccionar]

package clinica;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

import javax.swing.JOptionPane;

public final class GestorPacientes {

private ArrayList<Paciente> pacientes;

public void crearCSV() {

File archivo = new File("C:/csv/pacientes.csv");

try {
//Si no existe archivo, intentamos crearlo
if (!archivo.exists()) {
File carpeta = archivo.getParentFile();
carpeta.mkdirs();
archivo.createNewFile();
}

FileWriter escritor = new FileWriter(archivo);
//Cabecera para datos del CSV
escritor.append("#ID;Nombre;Apellidos\n");

//Datos de los pacientes
for (Paciente doc: pacientes)
escritor.append(doc.generaLineaCSV());//Insertamos linea CSV

escritor.close();
} catch (IOException e) {
System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
}
}

[Kabuto]

Cada vez que se ejecuta el método crearCSV(), se genera un archivo nuevo.
Si en lugar de eso queremos que se vaya agregando información al archivo, entonces hay que añadirle el parámetro TRUE al constructor del objeto FileWriter que usamos para escribir los datos en el archivo.

FileWriter escritor = new FileWriter(archivo, true);

Ahora las líneas se irán añadiendo al archivo, pero esto plantea un problema.
El código que escribí, SIEMPRE inserta una línea con una cabecera, y SIEMPRE escribe TODOS los objetos contenidos en el ArrayList.

Es decir, si registro al Doctor Pepe y creo el CSV. Insertará una cabecera y los datos del Doctor Pepe.
Eso está bien.

Pero si acto seguido registros a la Dra Susana y creo de nuevo el CSV, lo que añadirá a continuación es otra vez la cabecera, otra vez los datos del Dr. Pepe y por último a la Dra.Susana.
Y si registro un tercer doctor, de nuevo redundará otra cabecera, otra vez el Dr. Pepe, la Dra Susana y el tercer doctor..


Habría que cambiar la estrategia, que solo inserte la línea de cabecera (la que da nombres a las columnas de datos) la primera vez que se crea el archivo.
Esto lo podemos controlar con un boolean

Y que solo escriba la última entrada recibida en el ArrayList, para que no repita los datos de los registros anteriores.
Esto lo conseguimos consultando cuánto mide el ArrayList y restándole -1 para obtener el indice del último registro recibido.
Marco en negrita los cambios que haríamos al método de crearCSV().

   
   public void crearCSV() {
      
      File archivo = new File("D:/csv/doctores.csv");
      
      try {
         //Si no existe archivo, intentamos crearlo
         boolean primeraVez = false;
         if (!archivo.exists()) {
            File carpeta = archivo.getParentFile();
            carpeta.mkdirs();
            archivo.createNewFile();
            primeraVez = true; //Primera vez que trabajamos en este archivo
         }
         
         FileWriter escritor = new FileWriter(archivo, true);
         //Cabecera para datos del CSV, solo si es la primera vez
         if (primeraVez)
            escritor.append("#ID;Nombre;Apellidos;Especialidad\n");
         
         //Datos del último Doctor registrado
         int ultimo = doctores.size() - 1;
         escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV
         
         escritor.close();
      } catch (IOException e) {
         System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
      }
   }

De este modo, solo escribe el último Doctor registrado. Por lo tanto, nos será más comodo si en lugar de invocar este método desde el main() después de cada Doctor registrado, lo podemos invocar desde dentro del método que usemos para crear Doctores.
Así cada vez que se da de alta un nuevo Doctor, automáticamente se genera la línea CSV correspondiente.
Ya no es necesario solicitarlo en el main de la clase principal

   
   public void nuevoDoctor() {
      System.out.println("\nALTA NUEVO DOCTOR");
      System.out.println("---- ----- ------\n");
      System.out.print("ID: ");
      String id = teclado.nextLine();
      System.out.print("Nombre: ");
      String nombre = teclado.nextLine();
      System.out.print("Apellidos: ");
      String apell = teclado.nextLine();
      System.out.print("Especialidad: ");
      String espe = teclado.nextLine();
      
      doctores.add(new Doctor(id, nombre, apell, espe));
      crearCSV(); //Añadimos nueva línea CSV al archivo en disco
   }

Lo mismo habrá que hacer con las Citas y los Pacientes.

**************************************

Sobre las Citas, y relacionar Doctores y Pacientes.

No se como habrás escrito tu clase Cita, pero entiendo que lo de relacionar consiste en que una Cita tendrá entre sus atributos, un Doctor y un Paciente, además de los otros atributos indicados por el enunciado.

Puedes incluso porporcionarle dos constructores.
Uno que reciba todos los parámetros para todos los atributos.
Otro que solo reciba ID, hora, fecha y motivo. Con la idea de luego usar los setters para agregar un Doctor y un Paciente a esta Cita.

Código: [Seleccionar]

public class Cita {

private String id;
private String fecha;
private String hora;
private String motivo;
private Doctor doctor;
private Paciente paciente;

public Cita(String id, String fecha, String hora, String motivo,
Doctor doctor, Paciente paciente) {
this.id = id;
this.fecha = fecha;
this.hora = hora;
this.motivo = motivo;
this.doctor = doctor;
this.paciente = paciente;
}

public Cita(String id, String fecha, String hora, String motivo) {
this.id = id;
this.fecha = fecha;
this.hora = hora;
this.motivo = motivo;
}

public String getMotivo() {
return motivo;
}

public void setMotivo(String motivo) {
this.motivo = motivo;
}

public Paciente getPaciente() {
return paciente;
}

public void setPaciente(Paciente paciente) {
this.paciente = paciente;
}

}

[jonatthan23]

Hola, en la clase GestorCita hice los cambios para ligar un doctor y un paciente y me marca error

Código: [Seleccionar]

public boolean nuevoCita() {
String id = JOptionPane.showInputDialog(null, "Introduzca Identificador:", "Nuevo Cita", JOptionPane.QUESTION_MESSAGE);
String fecha = JOptionPane.showInputDialog(null, "Fecha:", "Nuevo Fecha", JOptionPane.QUESTION_MESSAGE);
String hora = JOptionPane.showInputDialog(null, "Hora:", "Nuevo Hora", JOptionPane.QUESTION_MESSAGE);
String motivo = JOptionPane.showInputDialog(null, "Motivo:", "Nuevo Motivo", JOptionPane.QUESTION_MESSAGE);
Doctor doctor = JOptionPane.showInputDialog(null, "Doctor:", "Nuevo Doctor", JOptionPane.QUESTION_MESSAGE);
Paciente paciente = JOptionPane.showInputDialog(null, "Paciente:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);

Cita nuevoCita = new Cita(id, fecha, hora, motivo, doctor, paciente);
return citas.add(nuevoCita);
//Devuelve TRUE si se insertó correctamente, FALSE si no se pudo insertar
}
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
   Type mismatch: cannot convert from String to Doctor
   Type mismatch: cannot convert from String to Paciente

   at clinica.GestorCita.nuevoCita(GestorCita.java:54)
   at clinica.TestClinica.main(TestClinica.java:28)

[jonatthan23]

Esta es mi clase cita

Código: [Seleccionar]

package clinica;

import javax.swing.JOptionPane;

public final class Cita {

private String id;
private String fecha;
private String hora;
private String motivo;
private Doctor doctor;
private Paciente paciente;

public String generaLineaCSV() {
    return String.format("%s;%s;%s;%s;%s;%s\n", id, fecha, hora, motivo, doctor, paciente); 
}

public Cita(String id, String fecha, String hora, String motivo, Doctor doctor, Paciente paciente) {
this.id = id;
this.fecha = fecha;
this.hora = hora;
this.motivo = motivo;

}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public String getHora() {
return hora;
}

public void setHora(String hora) {
this.hora = hora;
}

public String getMotivo() {
return motivo;
}

public void setMotivo(String motivo) {
this.motivo = motivo;
}

public Doctor getDoctor() {
return doctor;
}

public void setDoctor(Doctor doctor) {
this.doctor = doctor;
}

public Paciente getPaciente() {
return paciente;
}

public void setPaciente(Paciente paciente) {
this.paciente = paciente;
}


/**
* Muestra por panel todos los datos de la cita
*/
public void mostrar() {
String mensaje = "\nid cita: " + id + "\nFecha: " + fecha
+ "\nHora: " + hora + "\nMotivo: " + motivo;
JOptionPane.showMessageDialog(null, mensaje, "Mostrar Cita", JOptionPane.INFORMATION_MESSAGE);
}
}

[Kabuto]

El problema está aquí:

Doctor doctor = JOptionPane.showInputDialog(null, "Doctor:", "Nuevo Doctor", JOptionPane.QUESTION_MESSAGE);
      Paciente paciente = JOptionPane.showInputDialog(null, "Paciente:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);

JOptionPane te devuelve una cadena String pero tu estás intentado guardar ese dato como si fuera un objeto Doctor y un objeto Paciente.
Esto no es así de fácil 

Lo que te de el JOptionPane, lo tienes que guardar en un String.
Y con ese String, pedirle a las clase GestorDoctor que te propocione un Doctor, y a la clase GestorPaciente que te de un paciente.

Entonces, primero hay que pensar que dato queremos pedir con el JOptionPane, para que las clases Gestoras sepan encontrar el Doctor y Paciente que deseamos.

Lo ideal sería pedir el ID, ya que es un identificador único. Así le pasamos el ID a la clase Gestora, busca en su ArrayList, y devuelve el Doctor/Paciente que tenga ese ID.

También se puede buscar por nombre, pero en el "mundo real" cabe la posibilidad de que dos doctores o dos pacientes se llamen igual.
Además se complica porque habría que pedir nombre y apellidos.

Por eso se prefiere usar identificadores únicos.
Pero bueno, esto solo es un ejercicio, decide tú cuál atributo quieres pedir para buscar.

Entonces, a la clase GestorDoctor le podemos añadir un método como este:

Código: [Seleccionar]


public Doctor getDoctor(String id) {
for (Doctor doc: doctores)
if (doc.getId().equals(id))
return doc; //Doctor encontrado
//Si el bucle no ha retornado ningún Doctor, es que no existe ese ID
return null;
}
Esto recorre el ArrayList de doctores y si encuentra uno que coincida con el ID recibido por parámetro, lo retorna.
Si no hay ninguno, retorna valor null.

A la clase GestorPaciente le pondremos un método que haga lo mismo.

Con esto al crear Cita, cogemos los String que nos da el JOptionPane y los usamos para buscar Doctores y Pacientes.
Pero, aquí nos topamos con otro problema.

Para buscar Doctores y Pacientes, tenemos que tener acceso a la instancia de GestorDoctor y de GestorPaciente.

Pero la clase GestorCita, no tiene acceso a estas instancias. Estas instancias existen y son visibles solo en el método main() de la clase principal, quedan fuera del ámbito de GestorCita.
¿Cómo solucionarlo?
Pues para no tener que hacer un rediseño del código, lo más fácil es proporcionar a la clase GestorCita unas referencias a las instancias de GestorDoctor y GestorPaciente, para que pueda acceder a ellas y obtener los datos que necesita.
Así que GestorCita tendrá dos nuevos atributos, que serán las referencias a estos objetos.

Estas referencias, se las podemos pasar por su constructor.
La clase GestorCita podría quedar más o menos así:

public class GestorCita {

   private ArrayList<Cita> citas;

   //Referencias a las instancias de los gestores de doctores y pacientes
   private GestorDoctor doctores;
   private GestorPaciente pacientes;

   public GestorCita(GestorDoctor gestDoc, GestorPaciente gestPaci) {
      citas = new ArrayList<Cita>();
      doctores = gestDoc;
      pacientes = gestPaci;
   }

   public boolean nuevoCita() {
      String id = JOptionPane.showInputDialog(null, "Introduzca Identificador:", "Nuevo Cita", JOptionPane.QUESTION_MESSAGE);
      String fecha = JOptionPane.showInputDialog(null, "Fecha:", "Nuevo Fecha", JOptionPane.QUESTION_MESSAGE);
      String hora = JOptionPane.showInputDialog(null, "Hora:", "Nuevo Hora", JOptionPane.QUESTION_MESSAGE);
      String motivo = JOptionPane.showInputDialog(null, "Motivo:", "Nuevo Motivo", JOptionPane.QUESTION_MESSAGE);
      String iDdoctor = JOptionPane.showInputDialog(null, "ID del Doctor:", "Nuevo Doctor", JOptionPane.QUESTION_MESSAGE);
      String iDpaciente = JOptionPane.showInputDialog(null, "ID del Paciente:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);

      //Pedimos los datos a los gestores que tenemos referenciados
      Doctor doctor = doctores.getDoctor(iDdoctor);
      Paciente paciente = pacientes.getPaciente(iDpaciente);
      
      Cita nuevoCita = new Cita(id, fecha, hora, motivo, doctor, paciente);
      return citas.add(nuevoCita);
      //Devuelve TRUE si se insertó correctamente, FALSE si no se pudo insertar
   }

}

Y ahora, en la clase principal donde instanciamos los gestores, primero instanciamos los gestores de Doctores y Pacientes, y por último el gestor de Citas, quien recibirá referencias de los dos gestores anteriores.

public class Clinica {

   private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
   private static GestorDoctor doctores = new GestorDoctor();
   private static GestorPaciente pacientes = new GestorPaciente();
   private static GestorCita citas = new GestorCita(doctores, pacientes);//Pasamos referencias
   private static Scanner teclado = new Scanner(System.in);

   public static void main(String[] args) {
      crearAdmins();

      if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         ................
         ................
         ................

[EmethP]

Kabuto, buenos dias

Me guie por las respuestas de este foro sin embargo no logro que mi programa ejecute, al darle build me sale el siguiente error

C:\Users\Emeth.Paredes\IdeaProjects\EvidenciaFinal\src\Clinica.java:39:9
java: illegal start of expression

C:\Users\Emeth.Paredes\IdeaProjects\EvidenciaFinal\src\Clinica.java:59
java: class, interface, enum, or record expected


Te comparto el codigo y las clases

Clase Main

Código: [Seleccionar]

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public final class Clinica {

    private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
    private static Scanner teclado = new Scanner(System.in);
    static GestorPacientes pacientes = new GestorPacientes();
    static GestorCita citas = new GestorCita();
    static GestorDoctor doctores = new GestorDoctor();


    public static void main(String[] args) {

        crearAdmins();

        if (validarAcceso()) {
            System.out.println("\nUsuario autorizado\n");
            if (validarAcceso()) {
                System.out.println("\nUsuario autorizado\n");
                doctores.nuevoDoctor();
                doctores.modificarDoctor();
                doctores.mostrarDoctores();
                pacientes.nuevoPaciente();
                pacientes.mostrarPacientes();
                pacientes.modificarPaciente();
                pacientes.borrarPaciente();
                citas.nuevoCita();
                citas.mostrarCitas();
            }
            else
                System.out.println("\nUsuario no autorizado.");

            System.out.println("\n\t\tFIN DE PROGRAMA");

        }

        private static void crearAdmins() {
            administradores.add(new Administrador("Kabuto", "1234"));
            administradores.add(new Administrador("EmethP", "5678"));
            administradores.add(new Administrador("AnaT", "0000"));
        }

        private static boolean validarAcceso( ) {

            System.out.println("ACCESO AL SISTEMA");
            System.out.println("------ -- -------\n");
            System.out.print("Nombre: ");
            String nombre = teclado.nextLine();
            System.out.print("Password: ");
            String password = teclado.nextLine();

            Administrador admin = new Administrador(nombre, password);

            return administradores.contains(admin);
        }
    }
}
Clase Doctor

Código: [Seleccionar]

package clinica;

import javax.swing.JOptionPane;


public class Doctor {

    private String id;
    private String nombre;
    private String apellidos;
    private String especialidad;

    public Doctor(String id, String nombre, String apellidos, String especialidad) {
        this.id = id;
        this.nombre = nombre;
        this.apellidos = apellidos;
        this.especialidad = especialidad;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getEspecialidad() {
        return especialidad;
    }

    public void setEspecialidad(String especialidad) {
        this.especialidad = especialidad;
    }

    /**
     * Muestra por panel todos los datos del doctor
     */
    public void mostrar() {
        String mensaje = "ID doctor: " + id + "\nNombre: " + nombre
                + "\nApellidos: " + apellidos + "\nEspecialidad: " + especialidad;
        JOptionPane.showMessageDialog(null, mensaje, "Mostrar doctor", JOptionPane.INFORMATION_MESSAGE);
    }

    public Doctor getDoctor(String id) {
        for (Doctor doc: doctores)
            if (doc.getId().equals(id))
                return doc; //Doctor encontrado
        //Si el bucle no ha retornado ningún Doctor, es que no existe ese ID
        return null;
    }

}
Clase Paciente

Código: [Seleccionar]

import javax.swing.JOptionPane;

public class Paciente {


    private String id;
    private String nombre;
    private String apellidos;

    public String generaLineaCSV() {
        return String.format("%s;%s;%s;%s\n", id, nombre, apellidos);
    }


    public Paciente(String id, String nombre, String apellidos) {
        this.id = id;
        this.nombre = nombre;
        this.apellidos = apellidos;

    }
}
Clase Administrador

Código: [Seleccionar]

public class Administrador {

    private String nombre;
    private String password;

    public Administrador(String nom, String pass) {
        nombre = nom;
        password = pass;
    }

    @Override
    public boolean equals(Object objeto) {
        if (objeto instanceof Administrador) { //Objeto si es clase Administrador
            //Casteamos objeto a Administrador
            Administrador otroAdmin = (Administrador)objeto;
            //Comparamos si coinciden nombre y password
            if (nombre.equals(otroAdmin.nombre) && password.equals(otroAdmin.password))
                return true; //Coinciden ambos, los objetos representan al mismo Administrador
            else
                return false;//Nombre o contraseña no coinciden, son Administradores diferentes.
        }
        else //Objeto a comparar no es de clase Administrador
            return false;
    }

}
Clase Cita

Código: [Seleccionar]

public class Cita {

    private String id;
    private String fecha;
    private String hora;
    private String motivo;
    private Doctor doctor;
    private Paciente paciente;

    public Cita(String id, String fecha, String hora, String motivo,
                Doctor doctor, Paciente paciente) {
        this.id = id;
        this.fecha = fecha;
        this.hora = hora;
        this.motivo = motivo;
        this.doctor = doctor;
        this.paciente = paciente;
    }

    public Cita(String id, String fecha, String hora, String motivo) {
        this.id = id;
        this.fecha = fecha;
        this.hora = hora;
        this.motivo = motivo;
    }

    public String getMotivo() {
        return motivo;
    }

    public void setMotivo(String motivo) {
        this.motivo = motivo;
    }

    public Paciente getPaciente() {
        return paciente;
    }

    public void setPaciente(Paciente paciente) {
        this.paciente = paciente;
    }

}
Clase GestorPaciente

Código: [Seleccionar]

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

import javax.swing.JOptionPane;

public final class GestorPacientes {

    private ArrayList<Paciente> pacientes;

    public void crearCSV() {

        File archivo = new File("C:\\Users\\Emeth.Paredes\\IdeaProjects\\EvidenciaFinal\\src");

        try {
            //Si no existe archivo, intentamos crearlo
            boolean primeraVez = false;
            if (!archivo.exists()) {
                File carpeta = archivo.getParentFile();
                carpeta.mkdirs();
                archivo.createNewFile();
                primeraVez = true; //Primera vez que trabajamos en este archivo
            }

            FileWriter escritor = new FileWriter(archivo, true);
            //Cabecera para datos del CSV, solo si es la primera vez
            if (primeraVez)
                escritor.append("#ID;Nombre;Apellidos;Especialidad\n");

            //Datos del último Doctor registrado
            int ultimo = doctores.size() - 1;
            escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV

            escritor.close();
        } catch (IOException e) {
            System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
        }
    }
}

Clase GestorDoctor

Código: [Seleccionar]

public class GestorDoctor {

    public void crearCSV() {

        File archivo = new File("C:\\Users\\Emeth.Paredes\\IdeaProjects\\EvidenciaFinal\\src");

        try {
            //Si no existe archivo, intentamos crearlo
            boolean primeraVez = false;
            if (!archivo.exists()) {
                File carpeta = archivo.getParentFile();
                carpeta.mkdirs();
                archivo.createNewFile();
                primeraVez = true; //Primera vez que trabajamos en este archivo
            }

            FileWriter escritor = new FileWriter(archivo, true);
            //Cabecera para datos del CSV, solo si es la primera vez
            if (primeraVez)
                escritor.append("#ID;Nombre;Apellidos;Especialidad\n");

            //Datos del último Doctor registrado
            int ultimo = doctores.size() - 1;
            escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV

            escritor.close();
        } catch (IOException e) {
            System.out.println("Error de acceso a: " + archivo.getAbsolutePath());
        }
    }
}

Clase GestorCita

Código: [Seleccionar]

public class GestorCita {

    private ArrayList<Cita> citas;

    //Referencias a las instancias de los gestores de doctores y pacientes
    private GestorDoctor doctores;
    private GestorPaciente pacientes;

    public GestorCita(GestorDoctor gestDoc, GestorPaciente gestPaci) {
        citas = new ArrayList<Cita>();
        doctores = gestDoc;
        pacientes = gestPaci;
    }

    public boolean nuevoCita() {
        String id = JOptionPane.showInputDialog(null, "Introduzca Identificador:", "Nuevo Cita", JOptionPane.QUESTION_MESSAGE);
        String fecha = JOptionPane.showInputDialog(null, "Fecha:", "Nuevo Fecha", JOptionPane.QUESTION_MESSAGE);
        String hora = JOptionPane.showInputDialog(null, "Hora:", "Nuevo Hora", JOptionPane.QUESTION_MESSAGE);
        String motivo = JOptionPane.showInputDialog(null, "Motivo:", "Nuevo Motivo", JOptionPane.QUESTION_MESSAGE);
        String iDdoctor = JOptionPane.showInputDialog(null, "ID del Doctor:", "Nuevo Doctor", JOptionPane.QUESTION_MESSAGE);
        String iDpaciente = JOptionPane.showInputDialog(null, "ID del Paciente:", "Nuevo Paciente", JOptionPane.QUESTION_MESSAGE);

        //Pedimos los datos a los gestores que tenemos referenciados
        Doctor doctor = doctores.getDoctor(iDdoctor);
        Paciente paciente = pacientes.getPaciente(iDpaciente);

        Cita nuevoCita = new Cita(id, fecha, hora, motivo, doctor, paciente);
        return citas.add(nuevoCita);
        //Devuelve TRUE si se insertó correctamente, FALSE si no se pudo insertar
    }

}
Podrias apoyarme por favor? No encuentro que es lo que puede estar mal.

Te agradezco de antemano, saludos!

[Kabuto]

A ver, veo varios problemas.

Primero, la clase GestorPacientes,

Código: [Seleccionar]

public final class GestorPacientes {
En algunas partes del código se la llama en singular: GestorPaciente

public class GestorCita {

    private ArrayList<Cita> citas;

    //Referencias a las instancias de los gestores de doctores y pacientes
    private GestorDoctor doctores;
    private GestorPaciente pacientes;

    public GestorCita(GestorDoctor gestDoc, GestorPaciente gestPaci) {
        citas = new ArrayList<Cita>();
        doctores = gestDoc;
        pacientes = gestPaci;
    }

Revisa que en todas las clases la estés llamando igual.

Otra cosa, el constructor de la clase GestorCita está declarado como que ha de recibir dos argumentos: un objeto GestorDoctor y un objeto GestorPacientes

Pero luego en la clase Clinica, cuando invocas este constructor no le das esos dos objetos:

public final class Clinica {

    private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
    private static Scanner teclado = new Scanner(System.in);
    static GestorPacientes pacientes = new GestorPacientes();
    static GestorCita citas = new GestorCita();
    static GestorDoctor doctores = new GestorDoctor();

Has de propocionarselos, y para poder hacerlo, el gestor de citas tendrá que ser el último gestor en construirse.

public final class Clinica {

    private static ArrayList<Administrador> administradores = new ArrayList<Administrador>();
    private static Scanner teclado = new Scanner(System.in);
    static GestorPacientes pacientes = new GestorPacientes();
    static GestorDoctor doctores = new GestorDoctor();
    static GestorCita citas = new GestorCita(doctores, pacientes);

Otro fallo en la clase Clinica, es la declaración de los métodos crearAdmins() y validarAcceso().
¡¡Están dentro del método main!!

    public static void main(String[] args) {//Apertura de main

        crearAdmins();

        if (validarAcceso()) {
            System.out.println("\nUsuario autorizado\n");
            if (validarAcceso()) {
                System.out.println("\nUsuario autorizado\n");
                doctores.nuevoDoctor();
                doctores.modificarDoctor();
                doctores.mostrarDoctores();
                pacientes.nuevoPaciente();
                pacientes.mostrarPacientes();
                pacientes.modificarPaciente();
                pacientes.borrarPaciente();
                citas.nuevoCita();
                citas.mostrarCitas();
            }
            else
                System.out.println("\nUsuario no autorizado.");

            System.out.println("\n\t\tFIN DE PROGRAMA");

        }

        private static void crearAdmins() {
            administradores.add(new Administrador("Kabuto", "1234"));
            administradores.add(new Administrador("EmethP", "5678"));
            administradores.add(new Administrador("AnaT", "0000"));
        }

        private static boolean validarAcceso( ) {

            System.out.println("ACCESO AL SISTEMA");
            System.out.println("------ -- -------\n");
            System.out.print("Nombre: ");
            String nombre = teclado.nextLine();
            System.out.print("Password: ");
            String password = teclado.nextLine();

            Administrador admin = new Administrador(nombre, password);

            return administradores.contains(admin);
        }
    }//Cierre de main

Deben ir FUERA del método main(), puedes ponerlos antes o después, pero siempre fuera del cuerpo del main()

   public static void main(String[] args) {//Apertura de main

      crearAdmins();

      if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         if (validarAcceso()) {
            System.out.println("\nUsuario autorizado\n");
            doctores.nuevoDoctor();
            doctores.modificarDoctor();
            doctores.mostrarDoctores();
            pacientes.nuevoPaciente();
            pacientes.mostrarPacientes();
            pacientes.modificarPaciente();
            pacientes.borrarPaciente();
            citas.nuevoCita();
            citas.mostrarCitas();
         }
         else
            System.out.println("\nUsuario no autorizado.");

         System.out.println("\n\t\tFIN DE PROGRAMA");

      }

   }//Cierre de main

   private static void crearAdmins() {
      administradores.add(new Administrador("Kabuto", "1234"));
      administradores.add(new Administrador("EmethP", "5678"));
      administradores.add(new Administrador("AnaT", "0000"));
   }

   private static boolean validarAcceso( ) {

      System.out.println("ACCESO AL SISTEMA");
      System.out.println("------ -- -------\n");
      System.out.print("Nombre: ");
      String nombre = teclado.nextLine();
      System.out.print("Password: ");
      String password = teclado.nextLine();

      Administrador admin = new Administrador(nombre, password);

      return administradores.contains(admin);
   }

Seguimos con la clase Clinica.
Tras validar acceso, invocas a una serie de métodos de los gestores de doctores, pacientes y citas:
nuevoDoctor(), modificarDoctor(), borrarPaciente(), etc...

¡¡Pero esos métodos en realidad no existen!! No han sido escritos, ni en sus respectivas clases ni en ningún sitio.
El único que existe es el de nuevoCita()

      if (validarAcceso()) {
         System.out.println("\nUsuario autorizado\n");
         if (validarAcceso()) {
            System.out.println("\nUsuario autorizado\n");
            doctores.nuevoDoctor();
            doctores.modificarDoctor();
            doctores.mostrarDoctores();
            pacientes.nuevoPaciente();
            pacientes.mostrarPacientes();
            pacientes.modificarPaciente();
            pacientes.borrarPaciente();
            citas.nuevoCita();//Este es el único método que existe
            citas.mostrarCitas();
         }

No puedes iniciar el programa si estás invocando métodos que no han sido escritos.

Lo mismo ocurre en la clase GestorCita, se están llamando a métodos que no existen:

        //Pedimos los datos a los gestores que tenemos referenciados
        Doctor doctor = doctores.getDoctor(iDdoctor);
        Paciente paciente = pacientes.getPaciente(iDpaciente);

En la clase GestorDoctor, se nombra a un objeto llamado "doctores", que no existe.

            //Datos del último Doctor registrado
            int ultimo = doctores.size() - 1;
            escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV

Supongo que eso tendría que ser un ArrayList<Doctor>, atributo de la clase GestorDoctor, pero no ha sido declarado.


En la clase GestorPacientes, sí que se ha declarado el ArrayList<Paciente>

public final class GestorPacientes {

    private ArrayList<Paciente> pacientes;

Pero luego, más abajo, supongo que por un error al copiar/pegar código, se llama a un objeto "doctores", en lugar de llamar al objeto "pacientes"
Además la cabecera del archivo CSV parece propia de los "doctores", no de "pacientes" como debería ser en este caso:

            FileWriter escritor = new FileWriter(archivo, true);
            //Cabecera para datos del CSV, solo si es la primera vez
            if (primeraVez)
                escritor.append("#ID;Nombre;Apellidos;Especialidad\n");

            //Datos del último Doctor registrado
            int ultimo = doctores.size() - 1;
            escritor.append(doctores.get(ultimo).generaLineaCSV());//Insertamos linea CSV

Corrige todos estos errores y añade los métodos que faltan.
Solo entonces podrás poner en marcha el programa y así seguir depurándolo.

Un saludo.