Programacion Orientada a Objetos
Necesito hacer un programa que lea el nombre, edad y tres calificaciones de tres alumnos y el programa nos muestre el siguiente resultado:
Juan 19 años cal1 9 cal2 9 cal3 9 promedio 9
Alcia 21 años cal1 8 cal2 8 cal3 8 promedio 8
Nadia 17 años cal1 7 cal2 7 cal3 7 promedio 7
Promedio del grupo 8
- Inicie sesión o regístrese para enviar comentarios
Puedes aplicar lo que
Puedes aplicar lo que describó acá: http://bit.ly/DelProblemaAlCodigoEn4Pasos
Voy a aprovechar este post para poner en práctica lo que escribí ( a ver si es cierto :P )
Los pasos son:
Veamos
paso 1 entender el problema:
- Hay que leer nombre, edad y tres calificaciones de tres alumnos.
- Sacar un promedio por alumno ( como se saca un promedio??? ahh si, sumamos todo y lo dividimos no? )
- Y sacar un promedio del grupo.
Ok problema entendido.
No hay requerimientos especiales como usar una GUI o una pagina web etc. así que queda libre.
Paso 2. Identificar variables y funciones.
- variables:
El nombre, la edad, y las calificaciones 1 , 2 y 3 el promedio del alumno y el promedio del grupo.
- Lás reglas o funciones sería como sacar el promedio del alumno y como sacar el promedio del grupo.
- El promedio es la suma de las partes entre las partes.
Ya están las reglas.
Paso 3 Como se resuelve esto, este es mi pseudo-codigo y/o algoritmo, como tu título es OOP supongo que conceptos como objeto y clases ya son familiares así que voy a inclurlas en la solución.
Pasos para resolver mi problema
alumno_A esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
// Y lo repetimos para los otros dos alumnos por que son 3 en total.
alumno_B esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
alumno_C esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
nota mis funciones auxiliares ( que no forman parte el problema principal ) son
leer_calificacion_A(),
leer_calificacion_B()
y
leer_calificacion_C()
En mi pseudocódigo, estas funciones son mágicas, no tienen reglas, siempre funcionan, son perfectas. Poner una función mágica como esta ayuda a no "detenerme a pensar" como resolver algo que no es parte del problema principal. Pongo una magi-funcion y sigo adelante.
Ok, antes de hacer la definición del promedio, voy a hacer la del promedio por grupo:
// Entonces el promedio del grupo es igual al promedio de los alumnos entre el numero de alumnos
promedio_del_grupo = ( alumno_A.promedio() + alumno_B.promedio() + alumno_C.promedio() ) / 3 // facil no?
Como se ve, este calculo utilizó una función de la clase alumno llamada
promedio()Vamos a definir esa funcion dentro de la clase Alumno y vamos a definir el resto de la clase de una vez.:
Alumno
// Attributos
nombre
calificacion_A
calificacion_B
calificacion_C
// metodos u operaciones:
// promedio:
funcion promedio( ) regresa un numero
return ( calificacion_A + calificacion_B + calificacion_C ) / 3
Listo paso 3 terminado, ya tenemos el pseudo-codigo. Que es este:
Alumno
// Attributos
nombre
calificacion_A
calificacion_B
calificacion_C
// metodos u operaciones:
// promedio:
funcion promedio( ) regresa un numero
return ( calificacion_A + calificacion_B + calificacion_C ) / 3
ProgramaPrincipal
// leer nombre, edad y tres calificaciones para un alumno
alumno_A esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
alumno_B esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
alumno_C esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
promedio_del_grupo = ( alumno_A.promedio() + alumno_B.promedio() + alumno_C.promedio() ) / 3
mostrarInformacion() // otra funcion auxiliar
Listo, pseudo-código o algoritmo terminado.
Esto debe de resolver nuestro problema y nos ayudará para crear el programa.
Lo revisamos varias veces.. parece bien.
Parece que va a correr, quizá haya dudas de como hacer alguna lectura o algo, pero vamos a resolverlo en el código
Finalmente y lo más fácil
Paso 4 Hacer el código.
Una vez que: Sabemos lo que queremos ( paso 1 ) , sabemos que cosa varia y cuales son las reglas ( paso 2 ) y sabemos como lo vamos a resolver ( paso 3 ) tenemos que pasar este pensamiento a un programa en Java, es mucho más fácil programar, sabiendo a donde nos dirigimos:
Lo que voy a hacer es transcribir mi pseudo-codigo:
// Clase Alumno tomada de:
//http://www.javamexico.org/foros/java_standard_edition/programacion_orientada_objetos
// Clase Alumno
Alumno
// Attributos
nombre
calificacion_A
calificacion_B
calificacion_C
// metodos u operaciones:
// promedio:
funcion promedio( ) regresa un numero
return ( calificacion_A + calificacion_B + calificacion_C ) / 3
ProgramaPrincipal
// leer nombre, edad y tres calificaciones para un alumno
alumno_A esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
alumno_B esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
alumno_C esUn Alumno = Nuevo_Alumno_Con( leer_nombre(), leer_calificacion_A(), leer_calificacion_B(), leer_calificacion_C() )
promedio_del_grupo = ( alumno_A.promedio() + alumno_B.promedio() + alumno_C.promedio() ) / 3
mostrarInformacion() // otra funcion auxiliar
*/
class Alumno { // En Java los nombres de las clases empiezan en mayúsculas por convención ( ahora si lo escribí bien )
private String name;
private int calificacionA;
private int calificacionB;
private int calificacionC;
// En mi pseudo-codigo puse: Nuevo_Alumno_Con.. esto se puede reemplazar por un constructor:
public Alumno( String someName , int califA, int califB, int califC ) {
this.name = someName;
this.calificacionA = califA;
this.calificacionB = califB;
this.calificacionC = califC;
}
// Pongo mi funcion promedio
public double promedio() {
return ( calificacionA + calificacionB + calificacionC ) / 3.0; // Por que 3.0 y no 3??... ahh verdad...
}
// Y finalmente mi programa principal
public static void main( String [] args ) {
Alumno a = new Alumno( leerNombre(), leerCalificacion(), leerCalificacion(), leerCalificacion() );
Alumno b = new Alumno( leerNombre(), leerCalificacion(), leerCalificacion(), leerCalificacion() );
Alumno c = new Alumno( leerNombre(), leerCalificacion(), leerCalificacion(), leerCalificacion() );
double promedioDelGrupo = ( a.promedio() + b.promedio() + c.promedio() ) / 3;
mostrar( a,b,c, promedioDelGrupo );
}
//Las funciones auxiliares de resumen en esto:
private static String leerNombre() {
return "oscar";
}
private static int leerCalificacion() {
return 0;
}
private static void mostrar( Alumno a, Alumno b, Alumno c, double promedioDelGrupo ) {
// sale pues
}
}
Listo!!! programa terminado.
Hay que notar en en Java se utiliza camelCase para los nombres, por lo que en mi pseudo-codigo se llamaba "leer_calificacion_A" en Java le puse "leerCalificacion()"
Además no tiene caso tener 3 funciones diferentes que hacen lo mismo.
Le falta implementar las funciones auxiliares, pero eso debe de ser fácil. Es importante revisar como mi el pseudo-codigo prácticamente le dio forma al programa final.
Hay por ahí otras mejoras que se pueden hacer, como hacer los atributos inmutables, obviamente crear las funciones auxiliares ( que pueden vivir en su propia clase ) y varias más.
Con esto debe de ser suficiente.
Como yo soy partidiario de: "screenshot o nunca pasó" Aquí les va un pantallazo del programa corriendo.
Lo unico que hay que modificar son esas 3 funciona auxiliares, en total 2 linea de código más ( y cambiar las 3 existentes )
esotoy algo loco con eso
hola Oscar es mi parecer o estas trabajando Pseudo_codigo con POO yo tenia entendido que el pseudocodigo era para programacion estructurada y que para POO era mejor UML un saludo
pseucódigo
Sí se puede hacer OOP con pseucódigo, por qué no? ni modo que no compile... es pseudocódigo, nomás es dar la idea de cómo hacer algo, sin que realmente lo haga.
UML es para hacer los
cómicsdiagramas de especificación que le presentan a gerencia y al cliente.El pseudo-codigo también
El pseudo-codigo también sirve para la POO, por supuesto. Y cuando se está aprendiendo a programar, sirve muchísimo. La idea es poder expresar por escrito lo que quieres hacer. Esto ayuda a aclarar tu mente. Cuando tienes más experiencia, este paso lo puedes omitir, pues tus procesos mentales ya están estructurados para programar.
El UML es más bien para comunicar análisis y diseño de una forma un poco más formal. La mejor forma de usar UML es con lápiz y papel o en el pizarron y sacarle una foto. Así se logra el objetivo de comunicarse rápido. Si notas que hacer un diagrama UML te toma más tiempo que hacer un programa sencillo mejor déjalo y dibújalo en el cuaderno.
La desventaja de usar UML cuando aprendes a programar, es que ahora vas a tener dos problemas; ¿como diagramar lo que quieres programar? ( por que el probable que quién no sepa programar, tampoco sepa UML ) y luego el mismo desafío de ¿como pasar eso a código?
Con el pseudo-codigo, te aclaras el camino.
Por cierto, el UML también se usa para la programación estructurada.
La desventaja de usar UML
Una forma de hacerlo podria ser parecida al siguiente ejemplo:
a) piensas en las tareas que son necesarias hacer para resolver tu problema.
b) asignas tareas a clases.
c) creas la grafica de UML.
d) creas los metodos de las clases en donde implementaras el comportamiento que hara la tarea asignada a la clase(aqui pones todo tu pseudo-codigo ).
Observacion: Algunos puntos se pueden hacer al mismo tiempo (sobre todo el b y c).
El cambio mental de paradigma (procedural - oop) cuesta mucho trabajo, pero vale la pena, que lastima que en las escuelas no comiencen con OOP y que generalmente estemos acostumbrados a no hacer analisis y diseño al iniciar el proyecto.
Eiffel: "OOP: Tan facil como escribir pseudocodigo"
incluso hay lenguages orientados a objetos como Eiffel que presumen (un ejemplo es este libro) de que, si el ingles es tu lengua nativa, su codigo es "tan facil de escribir" que "escribirlo es tan facil como escribir pseudocodigo"
No hay desventaja alguna al usar UML
No creo que haya desventaja al usar UML cuando estás aprendiendo a programar, como tampoco hay desventaja al usar diagramas de bloques o diagramas de flujo, ni tampoco hay desventaja al usar pseudo código.
Todas esas notaciones extras pueden usarse para complementar el aprendizaje.
Lo importante con UML es enseñarlo bien y aprenderlo bien, introduciendo cada elemento de modelación en su momento y usando una herramienta adecuada, que por cierto varias de ellas están free en la red.
Casi de acuerdo
Como dijo @luxspes cuando respondió a uno de mis aportes "casi de acuerdo", pero esta vez total acuerdo. Los lenguajes de programación son tan expresivos en la actualidad que permiten sustituir en algunos casos el pseudo código que quieras inventar con sentencias del propio lenguaje. Unos cuantos comentarios adicionales al código y completas la explicación. En mis años mozos no era así, aunque casi nunca uso pseudo código, pero sí UML o cosas similares.
Pero eso no significa que un lenguaje de modelación no te sea útil. En ocasiones uso UML sin tan siquiera decirles a los estudiantes que se trata de UML. De esa forma, con algo de vaselina también los voy introduciendo a algo de modelación
pregunta
buenas, estoy estudiando programacion, empece recien este año, en la facultad me piden que diseñe una clase que permita administrar objetos que contengan el nombre y las 3 calificaciones obtenidas por un alumno en una materia y que informe el promedio, mi pregunta es, el codigo de OscarRyz me sirve como ejemplo, porque estoy media perdida, pego el codigo de lo que yo hice, lo que no se es si se considera como clase que administra objetos, gracias
package promedios;
import javax.swing.JOptionPane;
import static java.lang.System.out;
import static java.lang.Math.*;
import javafx.application.Application;
/**
*
* @author Flavia Montiel
*/
class Promedios {
private static double p;
private static double nota1;
private static double nota2;
private static double nota3;
private static double d;
private static String nom;
public static void main(String[] args) {
Promedio P = new Promedio();
String salida="";
nom = JOptionPane.showInputDialog("Ingrese Nombre");
nota1 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese Primera Nota"));
nota2 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese Segunda Nota"));
nota3 = Double.parseDouble(JOptionPane.showInputDialog("Ingrese Tercera Nota"));
d=(nota1+nota2+nota3);
p = (d / 3);{
salida= "Promedio" + nom + p;
}
JOptionPane.showMessageDialog (null, salida );
}
}