style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

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

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

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:

  • Paso 1.- Lee el problema y entiéndelo ( hasta que todo este claro )
  • Paso 2.- Identificar variables y funciones
  • Paso 3.- Escribir paso a paso como se resuelve el problema ( escribir el algoritmo o pseudo-código )
  • Paso 4. - Escribir el código!!

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

// 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() )

// 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_nombre(),
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:

// El promedio es la suma de las partes dividido entre la partes no?
// 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.:

// 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

Listo paso 3 terminado, ya tenemos el pseudo-codigo. Que es este:

// 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

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 )

screenshot

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

Imagen de ezamudio

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ómics diagramas 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.

Imagen de beto.bateria

La desventaja de usar UML

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?

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.

Imagen de luxspes

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"

Imagen de bferro

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.

Imagen de bferro

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 );
}

}

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">