ANALISIS DETALLADO DEL CODIGO
Control Academico - Java
Programacion Orientada a Objetos
EXPLICACION LINEA POR LINEA DEL CODIGO
1. Declaracion del paquete e importaciones
package controlacademico;
Define el paquete al que pertenece esta clase. Organiza el codigo en carpetas logicas.
import [Link];
import [Link];
import [Link];
Se importan las clases necesarias: ArrayList y List para manejar colecciones de alumnos, y
Scanner para leer datos desde el teclado.
2. Clase principal y atributos estaticos
public class ControlAcademico {
Se declara la clase principal del programa. Todo el codigo vive dentro de esta clase.
static Scanner input = new Scanner([Link]);
Se crea un objeto Scanner estatico compartido por todos los metodos. Sirve para leer lo que el
usuario escribe.
static List<Alumno> registros = new ArrayList<>();
Se crea una lista estatica que guardara todos los objetos Alumno registrados. Al ser estatica,
todos los metodos la comparten sin necesidad de pasarla como parametro.
3. Clase interna Alumno (atributos y constructor)
static class Alumno {
Se define una clase interna estatica llamada Alumno. Es estatica para que pueda usarse desde
los metodos estaticos de la clase externa.
String nombreCompleto;
String correo;
String telefono;
String codigo;
String carrera;
double[] calificaciones;
Estos son los ATRIBUTOS (o campos) de la clase Alumno. Representan los datos que tendra
cada estudiante. Son variables de instancia, es decir, cada objeto Alumno tendra sus propios
valores.
Constructor de la clase Alumno:
public Alumno(String nombreCompleto, String correo, String telefono,
String codigo, String carrera, double[] calificaciones) {
[Link] = nombreCompleto;
[Link] = correo;
[Link] = telefono;
[Link] = codigo;
[Link] = carrera;
[Link] = calificaciones;
}
Este es el constructor. Se llama igual que la clase (Alumno) y no tiene tipo de retorno. Recibe
todos los datos como parametros y los asigna a los atributos usando 'this.' para distinguir entre
el atributo del objeto y el parametro del metodo.
4. Metodos de la clase Alumno
Metodo promedio():
double promedio() {
double total = 0;
for (double n : calificaciones) total += n;
return total / [Link];
}
Calcula y retorna el promedio de las calificaciones del alumno sumando todos los valores y
dividiendo entre la cantidad total de notas.
Metodo mostrarInfo():
void mostrarInfo() {
[Link]("\n--- DATOS DEL ALUMNO ---");
[Link]("Nombre y apellido: " + nombreCompleto);
// ... imprime todos los atributos ...
[Link]("Promedio: " + [Link]("%.2f", promedio()));
}
Imprime en pantalla todos los datos del alumno. Llama al metodo promedio() para mostrar el
promedio con 2 decimales usando [Link].
5. Metodo main y menu principal
public static void main(String[] args) {
int opcion;
do {
// Muestra el menu...
opcion = [Link]([Link]());
switch (opcion) { ... }
} while (opcion != 5);
}
Es el punto de entrada del programa. Usa un bucle do-while para mostrar el menu
repetidamente hasta que el usuario elija la opcion 5 (Salir). El switch redirige a cada funcion
segun la opcion elegida.
6. Metodo agregarAlumno()
static void agregarAlumno() {
[Link]("Nombre y apellido: ");
String nombre = [Link]();
// ... lee todos los demas datos ...
for (Alumno a : registros) {
if ([Link](codigo)) {
[Link]("Ese codigo ya existe.");
return;
}
}
[Link](new Alumno(nombre, correo, telefono, codigo, carrera, notas));
}
Lee todos los datos del usuario por teclado. Valida que el codigo no este duplicado. Crea un
nuevo objeto Alumno con el constructor y lo agrega a la lista registros. Las calificaciones se
leen en un bucle for con validacion de formato.
7. Metodo listarAlumnos()
static void listarAlumnos() {
if ([Link]()) {
[Link]("No hay datos registrados.");
return;
}
for (Alumno a : registros) {
[Link]();
}
}
Recorre la lista de registros y llama al metodo mostrarInfo() de cada objeto Alumno para
mostrar sus datos en pantalla.
8. Metodo consultarAlumno()
static void consultarAlumno() {
// Permite buscar por nombre, codigo o correo
for (Alumno a : registros) {
if ((op == 1 && [Link](dato)) ||
(op == 2 && [Link](dato)) ||
(op == 3 && [Link](dato))) {
[Link]();
}
}
}
Permite buscar un alumno por tres criterios distintos. Compara sin distinguir
mayusculas/minusculas con equalsIgnoreCase().
9. Metodo eliminarAlumno()
static void eliminarAlumno() {
// Busca por codigo...
if ([Link](i).[Link](codigo)) {
[Link]("Confirmar eliminacion? (s/n): ");
String r = [Link]();
if ([Link]("s")) {
[Link](i);
}
}
}
Busca el alumno por codigo de matricula, pide confirmacion al usuario y si acepta, lo elimina de
la lista con [Link](i).
RESPUESTAS A LAS 10 PREGUNTAS
Pregunta 1: Como le das valores a los atributos
En este codigo, los atributos reciben valores DENTRO DEL CONSTRUCTOR usando la
palabra clave 'this':
[Link] = nombreCompleto;
[Link] = correo;
[Link] = telefono;
[Link] = codigo;
[Link] = carrera;
[Link] = calificaciones;
'[Link]' hace referencia al atributo del objeto actual. El valor de la derecha viene del
parametro que se paso al constructor cuando se creo el objeto. Es la forma mas comun y
ordenada de asignar valores a los atributos en Java.
Pregunta 2: Como creamos los objetos
Los objetos se crean usando la palabra clave 'new' seguida del nombre del constructor:
[Link](new Alumno(nombre, correo, telefono, codigo, carrera, notas));
Aqui 'new Alumno(...)' crea un nuevo objeto de tipo Alumno en memoria. Java asigna espacio
en el heap, llama al constructor y lo inicializa con los datos proporcionados. El objeto queda
almacenado en la lista registros.
Pregunta 3: De donde sale el constructor
El constructor lo ESCRIBIO EL PROGRAMADOR manualmente dentro de la clase Alumno. Se
reconoce porque:
• Tiene el mismo nombre que la clase (Alumno)
• No tiene tipo de retorno (ni void, ni int, ni nada)
• Se usa junto con 'new' para crear objetos
Aqui esta el constructor en el codigo:
public Alumno(String nombreCompleto, String correo, String telefono,
String codigo, String carrera, double[] calificaciones) {
[Link] = nombreCompleto;
// ... resto de asignaciones
}
Si el programador NO escribiera ningun constructor, Java proporcionaria automaticamente un
constructor vacio (sin parametros) llamado constructor por defecto. Pero en este caso se
definio uno explicito con todos los parametros.
Pregunta 4: De donde salen los getters y los setters
En este codigo NO hay getters ni setters. Fue una decision de diseno del programador. Los
getters y setters son metodos que normalmente se escriben asi:
// GETTER - metodo para OBTENER el valor de un atributo
public String getNombreCompleto() {
return [Link];
}
// SETTER - metodo para ASIGNAR un nuevo valor a un atributo
public void setNombreCompleto(String nombreCompleto) {
[Link] = nombreCompleto;
}
En este programa los atributos son accedidos directamente: [Link], [Link],
[Link], etc. Esto es posible porque la clase Alumno es interna y el acceso directo funciona,
aunque no es la mejor practica de POO.
Pregunta 5: Como darle valores a los objetos SIN usar el constructor
Sin constructor, se puede crear el objeto con 'new' y luego asignar los atributos directamente (si
son publicos o de acceso de paquete):
// Crear el objeto sin constructor con parametros
Alumno a = new Alumno(); // constructor vacio
// Asignar los valores uno por uno
[Link] = "Juan Perez";
[Link] = "juan@[Link]";
[Link] = "123456789";
[Link] = "2024001";
[Link] = "Ingenieria";
[Link] = new double[]{8.5, 9.0, 7.5, 8.0};
// Luego agregarlo a la lista
[Link](a);
IMPORTANTE: Para que esto funcione, la clase necesitaria un constructor sin parametros (o
ninguno declarado para que Java use el por defecto) y los atributos deben ser accesibles (no
privados).
Pregunta 6: Que es una clase
Una CLASE es un molde o plantilla que define como seran los objetos. En este codigo:
static class Alumno {
String nombreCompleto;
String correo;
String telefono;
String codigo;
String carrera;
double[] calificaciones;
// Constructor y metodos...
}
La clase Alumno define QUE DATOS tendra cada estudiante (atributos) y QUE PUEDE HACER
(metodos como promedio() y mostrarInfo()). La clase por si sola no ocupa espacio de datos
reales, solo describe la estructura. Los objetos son los que realmente existen en memoria con
datos concretos.
Pregunta 7: Que es un objeto
Un OBJETO es una instancia concreta de una clase. Es la clase 'hecha realidad' con datos
reales en memoria. En este codigo, cada vez que se ejecuta:
new Alumno(nombre, correo, telefono, codigo, carrera, notas)
Se crea un nuevo objeto Alumno independiente. Por ejemplo, si registras a Juan y a Maria, hay
DOS objetos Alumno en memoria, cada uno con sus propios datos. Todos comparten la misma
estructura (definida en la clase) pero tienen valores diferentes.
Pregunta 8: Como saber con que valores se inicializo el objeto al ser
creado
En este codigo se puede saber usando el metodo mostrarInfo():
[Link]();
Que imprime todos los atributos del objeto. Tambien dentro del metodo listarAlumnos() se
recorren todos los objetos y se muestran sus datos:
for (Alumno a : registros) {
[Link]();
}
En el constructor, los valores con los que se creo el objeto quedan almacenados en los
atributos de instancia ([Link], etc.). Siempre que necesites verlos, llamas a
mostrarInfo() o accedes directamente al atributo: [Link]
Pregunta 9: Donde se evidencia el encapsulamiento en el codigo
El encapsulamiento EN ESTE CODIGO es PARCIAL. Los atributos de la clase Alumno no
tienen modificadores de acceso (son de paquete por defecto), lo que significa que se acceden
directamente desde la clase externa:
[Link](codigo) // acceso directo al atributo
[Link](dato) // acceso directo
Un encapsulamiento CORRECTO y completo se veria asi:
// Atributos privados - nadie los ve desde afuera
private String nombreCompleto;
private String codigo;
// Getter publico - unica forma de acceder
public String getCodigo() { return [Link]; }
Sin embargo, si hay algo de encapsulamiento en que los metodos del programa
(agregarAlumno, consultarAlumno, etc.) actuan como intermediarios entre el usuario y los
datos, y la logica de calculo esta encapsulada dentro del metodo promedio() de la clase
Alumno.
Pregunta 10: Como se evidencia el uso del polimorfismo en el codigo
Este codigo NO tiene polimorfismo real. El polimorfismo requiere herencia o interfaces donde
una misma accion se comporta diferente segun el tipo de objeto. En este codigo:
• Solo hay UNA clase (Alumno), no hay jerarquia de clases
• No hay herencia (extends)
• No hay interfaces (implements)
• No hay metodos sobreescritos (override)
Un ejemplo de COMO SE AGREGARIA polimorfismo:
// Clase base
abstract class Persona {
abstract void mostrarInfo();
}
// Subclases con comportamiento diferente
class Alumno extends Persona {
double[] calificaciones;
@Override
void mostrarInfo() { /* muestra promedio */ }
}
class Profesor extends Persona {
String materia;
@Override
void mostrarInfo() { /* muestra materia */ }
}
PREGUNTAS ADICIONALES
Tiene polimorfismo este codigo?
NO. Como se explico en la pregunta 10, el polimorfismo requiere herencia o interfaces. Este
programa solo tiene una clase de modelo (Alumno) y no extiende ni implementa nada. Para
tener polimorfismo real necesitaria al menos dos clases relacionadas por herencia con metodos
sobreescritos.
Tiene abstraccion este codigo?
SI, tiene abstraccion CONCEPTUAL pero no abstraccion formal de POO (clases abstractas o
interfaces).
La abstraccion conceptual se ve en que:
• La clase Alumno ABSTRAE los datos relevantes de un estudiante real (nombre, carrera,
notas) e ignora lo que no importa para este sistema (estatura, edad, direccion, etc.)
• Los metodos como promedio() y mostrarInfo() ABSTRAEN la logica de calculo y
presentacion dentro del propio objeto
• El main solo llama metodos sin saber como estan implementados internamente
La abstraccion FORMAL de POO se ve al llamar a mostrarInfo() sin saber exactamente como lo
hace internamente. Se usa la interfaz del objeto, no sus detalles.
Para tener abstraccion formal Java se usaria:
abstract class Persona {
abstract void mostrarInfo(); // metodo abstracto
}
En que parte del codigo estan los constructores?
El constructor esta dentro de la clase interna Alumno, entre los atributos y los metodos:
static class Alumno {
// 1. ATRIBUTOS (campos de datos)
String nombreCompleto;
String correo;
String telefono;
String codigo;
String carrera;
double[] calificaciones;
// 2. CONSTRUCTOR (aqui empieza)
public Alumno(String nombreCompleto, String correo, String telefono,
String codigo, String carrera, double[] calificaciones) {
[Link] = nombreCompleto;
[Link] = correo;
[Link] = telefono;
[Link] = codigo;
[Link] = carrera;
[Link] = calificaciones;
} // aqui termina el constructor
// 3. METODOS (van despues del constructor)
double promedio() { ... }
void mostrarInfo() { ... }
}
El orden correcto en una clase Java es: atributos -> constructores -> metodos. Este codigo lo
sigue correctamente.
Por que se hizo sin getters ni setters?
El programador decidio no usar getters ni setters por las siguientes razones practicas:
• SIMPLICIDAD: Al ser un programa de consola basico, los getters/setters agregarian
mucho codigo sin aportar beneficio visible para el usuario final
• CLASE INTERNA: La clase Alumno es interna (dentro de ControlAcademico). En ese
contexto, el acceso directo a sus atributos es comun porque es una clase auxiliar
privada al programa
• PROYECTO ACADEMICO: En programas de aprendizaje, a veces se simplifica para
enfocarse en los conceptos principales (Scanner, listas, flujo del programa)
SIN EMBARGO, en un proyecto PROFESIONAL o en buenas practicas de POO los atributos
SIEMPRE deberian ser privados con getters y setters, porque:
• Permite validar los datos antes de asignarlos (por ejemplo, verificar que el correo tenga
@)
• Permite cambiar la implementacion interna sin afectar el resto del codigo
• Es la base del encapsulamiento real
• Facilita el mantenimiento y la depuracion del codigo
Documento generado automaticamente - Analisis de Codigo Java POO