ProgramacionOrientada A Objetos - Poo

PROGRAMACIÓN ORIENTADA A OBJETOS
APLICADA
Programa: ANÁLISIS Y DESARROLLO DE SISTEMAS DE

INFORMACIÓN
Duración estimada de estudio (horas): 60 hrs
Estructura de contenidos
Mapa Conceptual............................................................................2
Introducción..................................................................................3
1. APLICACIÓN DE EJEMPLO CON PROGRAMACIÓN ESTRUCTURADA.....4
1.1. Enunciado..........................................................................4
1.2. Código en Java con Programación Estructurada.......................5
2. APLICANDO EL PARADIGMA POO..................................................7
2.1. Definiendo las Clases...........................................................7
2.1.1. Los Atributos.............................................................8
2.1.2. Los Constructores......................................................9
2.1.3. Los Métodos............................................................ 10
2.1.4. La Encapsulación..................................................... 10
2.2. La Abstracción.................................................................. 12
2.3. Los Objetos...................................................................... 12
2.4. Ejecución de Métodos........................................................ 15
2.5. Desarrollo de la clase Aplicación.......................................... 16
3. EJEMPLO 2 DE PROGRAMACIÓN..................................................19
3.1. Enunciado ....................................................................... 19
3.2. Solución con Programación Estructurada.............................. 20
3.2.1. Ejecución de la aplicación Estructurada....................... 21
3.3. Solución con Programación Orientada a Objetos.................... 24
3.3.1. Ejecución de la aplicación Orientada a Objetos............. 27
3.4. Conclusiones.................................................................... 29
FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje

Programación orientada a objetos aplicada.
Mapa Conceptual
2
Introducción
En esta etapa de su proceso de formación ya ha oído o leído sobre la

programación orientada a objetos (POO) y sobre conceptos como Clase,
Objeto, Herencia, Polimorfismo, Abstracción, Encapsulación…. Pues
bien, el objetivo del presente objeto de aprendizaje es comprender los
fundamentos de la programación orientada a objetos de forma aplicada a
partir de un programa ya realizado mediante programación estructurada.
Lo primero que debemos saber es que la POO es un paradigma de

programación que surgió a principios de los años 90 y hoy día es el más
empleado en la industria de desarrollo de software. La palabra paradigma
indica una forma diferente de pensar o hacer algo, por lo tanto, es
necesario tener la mente abierta para realizar los programas aplicando
este nuevo paradigma de programación y así mejorar las competencias
técnicas como Analista y Desarrollador de Sistemas de Información.
PROGRAMACIÓN ORIENTADA
A OBJETOS APLICADA
Introducción.
PROGRAMACIÓN APLICANDO EL EJEMPLO 2 DE

ESTRUCTURADA PARADIGMA POO PROGRAMACIÓN
Enunciado. Definiendo las Clases. Enunciado.
Código en Java con La Abstracción. Solución con Programación

Programación Estructurada. Estructurada.
Los Objetos.
Solución con Programación
Ejecución de Métodos.
Orientada a Objetos.
Desarrollo de la clase
Aplicación. Conclusiones.
3
1. APLICACIÓN DE EJEMPLO CON PROGRAMACIÓN

ESTRUCTURADA
1.1. Enunciado
Se requiere una aplicación que lea el nombre de 3 estudiantes de un

curso, las 2 notas parciales de cada uno y presente un mensaje con sus
nombres y notas finales. Si la nota final es inferior a 3, presentar el mensaje
“REPROBADO”, en caso contrario presentar el mensaje “APROBADO” a
cada estudiante.
mport javax.swing.JOptionPane;
public class Programa1
{
public static void main(String[] args)
{
String nombre;
float nota1,nota2,notaFinal;
for(int est=1;est<=3;est++)
{
nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del estudiante”);
nota1=Float.parseFloat(JOptionPane.showInputDialog(null,”Ingrese la nota 1 del estudiante”));
notaFinal=(nota1+nota2)/2;
JOptionPane.showMessageDialog(null,”Información del Estudiante\nNOMBRE: “+nombre+” NOTA FINAL: “+notaFinal);
if(notaFinal < 3)
{
JOptionPane.showMessageDialog(null,”El estudiante Reprueba el curso”);
}
else
{
JOptionPane.showMessageDialog(null,”El estudiante Aprueba el curso”);
}
}
}
}
4
1.2. Código en Java con Programación Estructurada.
1 mport javax.swing.JOptionPane;
2 public class Programa1
3 {
4 public static void main(String[] args)
5 {
6 String nombre;
7 float nota1,nota2,notaFinal;
8
9 for(int est=1;est<=3;est++)
10 {
11 nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del estudiante”);
12 nota1=Float.parseFloat(JOptionPane.showInputDialog(null,”Ingrese la nota 1 del estudiante”));
13 nota2=Float.parseFloat(JOptionPane.showInputDialog(null,”Ingrese la nota 2 del estudiante”));
14 notaFinal=(nota1+nota2)/2;
15 JOptionPane.showMessageDialog(null,”Información del Estudiante\nNOMBRE: “+nombre+” NOTA FINAL: “+notaFinal);
16 if(notaFinal < 3)
17 {
18 JOptionPane.showMessageDialog(null,”El estudiante Reprueba el curso”);
19 }
20 else
21 {
22 JOptionPane.showMessageDialog(null,”El estudiante Aprueba el curso”);
23 }
24 }
25 }
26 }
Podemos observar en el código del programa que pese a ser JAVA un

lenguaje de programación orientado a objetos, la manera en que se
realiza el programa es totalmente estructurada con un inicio y un fin
predeterminado, empleando estructuras de control de flujo como for e if y
manteniendo siempre la misma ruta de ejecución del programa.
El resultado de ejecutar el programa es el siguiente:
Entrada
Ingrese el nombre del estudiante

Jaime Osorio
Aceptar Cancelar
5
Entrada
Ingrese la nota 1 del estudiante

3.2
Aceptar Cancelar
Entrada

2.5
Aceptar Cancelar
Mensaje
Información del Estudiante

NOMBRE: Jaime Osorio NOTA FINAL: 2.85
Aceptar
Mensaje
El estudiante Reprueba el curso
Aceptar
6
2. APLICANDO EL PARADIGMA POO (Programación

Orientada a Objetos)
Al momento de desarrollar una aplicación orientada a objetos, el foco

de la solución no debe ser crear un programa que cumpla con ciertas
funciones definido en un único archivo con un inicio y un fin. Para crear
una aplicación orientada a objetos, el programador debe enfocarse en
identificar los elementos que forman parte de la solución (clases), la
estructura o composición de cada elemento (atributos y métodos) y la
manera como debe interactuar con otros elementos para responder a los
requerimientos de la aplicación (relaciones).
2.1. Definiendo las Clases.
El primer paso para desarrollar una aplicación orientada a objetos es

identificar las clases que forman parte de la solución, estas pueden
obtenerse del enunciado o los requerimientos dados por el cliente, que en
el caso del programa solicitado es el siguiente:
“Se requiere una aplicación que lea el nombre de 3 estudiantes de un

curso, las 2 notas parciales de cada uno y presente un mensaje con sus
nombres y notas finales. Si la nota final es inferior a 3, presentar el mensaje
“REPROBADO”, en caso contrario presentar el mensaje “APROBADO” a
cada estudiante.”
aplicación Clase
nombre Atributo
estudiantes Clase
de un Relación (No tenida en cuenta por el alcance del
programa)
curso Clase (No tenida e n cuenta por el a lcance d el

programa)
2 notas parciales Atributos

notas finales Atributo calculado por método
presentar el mensaje Método
tabla 1. importancia en el programa
7
A partir del enunciado, es posible identificar clases como:
• Aplicación: Clase que contiene el método main y donde se puede

establecer el flujo del programa.
• Estudiante: Clase a partir de la cual se pueden crear Estudiantes,

asignarles notas, calcular sus notas finales.
• Curso: Clase que contiene estudiantes y por lo tanto permite realizar

operaciones sobre ellos. Esta clase es importante para permitir que
la aplicación crezca y manejar diferentes cursos. Por ahora para
responder a los requerimientos de la aplicación, no es necesaria
su utilización.
Imagen 1. Clases necesarias para responder al enunciado del

programa
2.1.1. Los Atributos.
Del mismo enunciado se pueden extraer los atributos de las clases, es

decir, la información necesaria que se debe mantener de una clase. En
el caso de la clase Aplicación, esta no requiere atributos, debido a que no
8
necesita mantener información almacenada, es decir, no requiere estado.

Caso contrario ocurre con la clase Estudiante, de la cual sí se requiere
mantener su información como su nombre y sus notas, esto significa que
sí requiere estado.
Estudiante { nombre, notaParcial1, notaParcial2, notaFinal }
public class Estudiante

{
string nombre;
Atributos float notaParcial1, notaParcial2,notaFinal;
}
2.1.2. Los Constructores.
A partir de los atributos identificados, es el momento de definir cuáles de

ellos deben ser solicitados al momento de crear un nuevo estudiante. Se
pueden definir varios constructores (sobrecarga de constructores), que
permitan crear Estudiantes de diferentes maneras.

{
String nombre;
float notaParcial1, notaParcial2,notaFinal;
Public Estudiante(String nombre)

{
this.nombre=nombre;
}
Constructores Public Estudiante(String nombre, float np1. float np2)
{
this.nombre=nombre;
notaParcial1=np1;
notaParcial2=np2;
}
}
El atributo notaFinal no debe solicitarse en el constructor porque la idea

del programa es calcularlo a partir de las notas parciales.
9
2.1.3. Los Métodos.
Ahora, se deben definir las funcionalidades que tendrá cada clase, estas
funcionalidades se establecen a través de sus métodos. Los métodos de
una clase tienen una alta relación con los atributos de la misma, por esa
razón a la hora de definir un método, se debe verificar si este es posible
de lograr con los atributos definidos.
2.1.4. La Encapsulación.
La encapsulación en un programa se da cuando se definen los atributos

de una clase con el nivel de acceso más restrictivo para que el acceso o
la modificación de los atributos de esa clase solo sea posible a través de
sus métodos.
10

{
Encapsulación private String nombre;
private float notaParcial1;
private float notaParcial2;
private float notaFinal;
public Estudiante(String nombre)

{
this.nombre=nombre;
}
public Estudiante(String nombre, float np1, float np2)
{
this.nombre=nombre;
notaParcial1=np1;
notaParcial2=np2;
}
public void asignarNotaParcial1(float np1)

{
notaParcial1=np1;
}
public void asignarNotaParcial2(float np2)
{
notaParcial2=np2;
}
public float obtenerNotaParcial1()
{
Métodos return notaParcial1;
}
public float obtenerNotaParcial2()
{
return notaParcial2;
}
public void calcularNotaFinal()
{
notaFinal=(notaParcial1+notaParcial2)/2;
}
public float obtenerNotaFinal()
{
return notaFinal;
}
public String obtenerMensaje()
{
if(notaFinal<3)
return “Reprobado”;
else
return “Aprobado”;
}
}
11
2.2. La Abstracción.
Un estudiante, además de nombre y notas puede poseer otra información

como su identificación, teléfono, dirección, edad, correo, tipo de sangre,
color favorito, etc. La acción de determinar cuáles son las características
esenciales de un objeto para responder a un determinado problema
se denomina Abstracción. En la presente aplicación, este concepto se
evidencia cuando se seleccionan únicamente los atributos y métodos
requeridos para cumplir con el objetivo del programa.
ESTUDIANTE SENA
Nombre.
Teléfono.
Dirección.
Edad.
Tipo de sangre.
Color favorito.
2.3. Los Objetos.
Con la clase Estudiante codificada, es posible crear objetos a partir de

ella. Este concepto también se conoce como instanciar la clase. Para
crear un objeto, es necesario emplear alguno de los constructores de la
clase, definidos a través del código de la misma.
La herramienta BlueJ, permite crear objetos a partir de una clase, haciendo

click derecho sobre la misma e ingresando los argumentos solicitados en
alguno de sus constructores:
12
Estudiante
new Estudiante (tring nombre)
Open Editor
Compile
Inspect
Remove
public Estudiante(String nombre)

{
this.nombre=nombre;
}
public Estudiante(String nombre, float np1, float np2)
{
this.nombre=nombre;
notaParcial1=np1;
notaParcial2=np2;
}
BlueJ: Create Object
Estudiante(String nombre)
Name of Instance: estudian1
new Estudiante () “Juan Valencia”
Ok Cancel
De la misma manera, es posible crear objetos de la clase Estudiante,

empleando el constructor, que recibe como argumentos el nombre del
estudiante, su nota parcial 1 y su nota parcial 2. De la misma manera,
13
Estudiante
BlueJ: Create Object
Name of Instance: estudian2

new Estudiante ( “Aura Ruiz” , String nombre
“3.2f”
“4.1f”
Ok Cancel
Ahora, la aplicación cuenta con dos objetos, a partir de los cuales

puede interactuar e invocar sus respectivos métodos. Cada objeto es
independiente y es posible crear todos los objetos que sean requeridos a
partir de una determinada clase.
Estudiante
estudian1: estudian2:
Estudiante Estudiante
Cada objeto tiene su propio estado, es decir, cuenta con sus propios
valores para sus atributos.
estudian2: Estudiante
Inspect
String nombre “Aura Ruiz”
Get
3.2
4.1
0.0
Close
14
2.4. Ejecución de Métodos.
Después de crear los objetos, es posible interactuar con todos sus

métodos, establecidos en el código de la clase.
inheritad from Object
estudian1: Inspect
Estudiante Remove
BlueJ: Method Result
estudian2.obtenerNota() Inspect
returned: Get
3.65
Close
Ejecución del método obtenerNota
15
BlueJ: Method Result

String obtenerNotaMensaje()
estudian2.obtenerMensaje() Inspect
returned: Get
String “Aprobado”
Close
Ejecución del método obtenerMensaje
2.5. Desarrollo de la clase Aplicación.
La clase Aplicación, es la clase que contiene el método main() y es la

encargada por código de crear los objetos necesarios de la clase Estudiante
e invocar sus respectivos métodos, controlando el flujo de ejecución del
programa.
16
Desarrollo de la clase Aplicación.
17
import javax.swing.JOptionPane;
public class Aplicacion
{
public static void main(String args[])
{
Estudiante est;
for(int i=1;i<=3;i++)
FAVA - Formación en Ambientes Virtuales de Aprendizaje
{
String nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del estudiante”);
float nota1=Float.parseFloat(JOptionPane.showInputDialog(null,”Ingrese la nota 1 del estudiante”));
float nota2=Float.parseFloat(JOptionPane.showInputDialog(null,”Ingrese la nota 2 del estudiante”));
est=new Estudiante(nombre);
est.asignarNotaParcial1(nota1);

est.asignarNotaParcial2(nota2);
est.calcularNotaFinal();
JOptionPane.showMessageDialog(null,”El estudiante “+est.nombre+”\nObtuvo una nota final de “+est.obtenerNotaFinal()+”\n”+est.obtenerMensaje());
}
}
}
SENA - Servicio Nacional de Aprendizaje
Estudiante
Aplicacion
new Aplicacion()
Open Editor
Compile
Inspect
Remove
El resultado de ejecutar la aplicación es el siguiente:
Entrada
Ingrese el nombre del estudiante

Andres Julian Valencia
Aceptar Cancelar
Entrada

3.8
Aceptar Cancelar
Entrada

4.7
Aceptar Cancelar
18
Mensaje
El estudiante Andres Julian Valencia
Obtuvo una nota final de 4.25
Aprobado
Aceptar
3. EJEMPLO 2 DE PROGRAMACIÓN
3.1. Enunciado
Una empresa requiere una aplicación que le permita obtener la siguiente

información:
• Número total de empleados
• Nombre y Salario de cada uno de sus empleados.
• Total de dinero pagado por los salarios de todos los empleados.
• Nombre, Cargo y Salario del empleado que más dinero gana.
• Nombre, Cargo y Salario del empleado que menos dinero gana.
mport javax.swing.JOptionPane;
public class Programa1
{
public static void main(String[] args)
{
String nombre;
float nota1,nota2,notaFinal;
for(int est=1;est<=3;est++)
{
nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del estudiante”);
notaFinal=(nota1+nota2)/2;
JOptionPane.showMessageDialog(null,”Información del Estudiante\nNOMBRE: “+nombre+” NOTA FINAL: “+notaFinal);
if(notaFinal < 3)
{
JOptionPane.showMessageDialog(null,”El estudiante Reprueba el curso”);
}
else
{
JOptionPane.showMessageDialog(null,”El estudiante Aprueba el curso”);
}
}
}
}
19
3.2. Solución con Programación Estructurada.
1 import javax.swing.JOptionPane;
2 import java.util.ArrayList;
3 public class ProgramaEstructurado
4 {
5 public static void main(String[] args)
6 {
7 String nombre, cargo;
8 double salario, total=0,mayorSalario,menorSalario;
9 int posicion=0;
10 //Definición de las estructuras de almacenamiento
11 ArrayList<String> nombres = new ArrayList<String>();
12 ArrayList<Double> salarios = new ArrayList<Double>();
13 ArrayList<String> cargos = new ArrayList<String>();
14
15 int cantidad=Integer.parseInt(JOptionPane.showInputDialog(null,”Ingrese la cantidad de empleados”));
16
17 for(int emp=1;emp<=cantidad;emp++)
18 {
19 //lectura de los datos de cada empleado
20 nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del empleado”);
21 salario=Double.parseDouble(JOptionPane.showInputDialog(null,”Ingrese el salario del empleado”));
22 cargo=JOptionPane.showInputDialog(null,”Ingrese el cargo del empleado”);
23 //almacenamiento de los datos
24 nombres.add(nombre);
25 salarios.add(salario);
26 cargos.add(cargo);
27 }
28 //número de empleados
29 System.out.println(“El numero total de empleados es:”+cantidad);
30 //nombre y salario de cada empleado
31 System.out.println(“Los nombres y salarios de los empleados son:”);
32 for(int emp=0;emp<cantidad;emp++)
33 {
34 System.out.println(“Nombre:”+nombres.get(emp)+” Salario:”+salarios.get(emp));
35 }
36 //total de dinero pagado por los salarios de todos los empleados
38 {
39 total=total+salarios.get(emp);
40 }
41 System.out.println(“Total de dinero pagado a todos los empleados:”+total);
42 //nombre, cargo y salario del empleado que mas dinero gana
43 System.out.println(“El empleado que mas dinero gana es:”);
44 mayorSalario=salarios.get(0);
46 {
47 if(salarios.get(emp)>mayorSalario)
48 {
49 mayorSalario=salarios.get(emp);
50 posicion=emp;
51 }
52 }
53 System.out.println(“Nombre:”+nombres.get(posicion)+” Cargo:”+cargos.get(posicion)+” Salario:”+salarios.get(posicion));
54 //nombre, cargo y salario del empleado que menos dinero gana
55 System.out.println(“El empleado que menos dinero gana es:”);
56 menorSalario=salarios.get(0);
57 posicion=0;
58 for(intt emp=1;emp<cantidad;emp++)
20
59 {
60 if(salarios.get(emp)<menorSalario)
61 {
62 menorSalario=salarios.get(emp);
63 posicion=emp;
64 }
65 }
66 System.out.println(“Nombre:”+nombres.get(posicion)+” Cargo:”+cargos.get(posicion)+” Salario:”+salarios.get(posicion));
67 }
68 }
Con la programación estructurada todas las funciones se realizan sobre

el mismo archivo, el mantenimiento de la aplicación es más complejo y la
adaptación a cambios es más difícil.
3.2.1. Ejecución de la aplicación Estructurada
Entrada
Ingrese la cantidad de empelados

3
Aceptar Cancelar
Empleado1
Entrada
Ingrese el nombre del empleado

Luis Urueta
Aceptar Cancelar
Entrada
Ingrese el salario del empleado

1200000
Aceptar Cancelar
21
Entrada
Ingrese el cargo del empleado

Asistente
Aceptar Cancelar
Empleado 2
Entrada

Kelly Mejia
Aceptar Cancelar
Entrada

2100000
Aceptar Cancelar
Entrada

Administrador
Aceptar Cancelar
Empleado 3
Entrada

Mayra Yanquen
Aceptar Cancelar
22
Entrada

2000000
Aceptar Cancelar
Entrada

Ingeniero
Aceptar Cancelar
El numero total de empleados es: 3
Los nombre y salarios de los empleados son:

Nombre: Luis Urueta Salario: 1200000.0
Nombre: Kelly Mejia Salario: 2100000.0
Nombre: Mayra Yanquen Salario: 2000000.0
Total de dinero pagado a todos los empleados: 5300000.0

El empleado que ma dinero gana es
El empleado que menos dinero gana es
Press any key to continue...
23
3.3. Solución con Programación Orientada a Objetos.
La clase Empleado: Esta clase es responsable de gestionar la información

de cada Empleado.
1 public class Empleado

2 {
3 //Atributos
4 private String nombre;
5 private double salario;
6 private String cargo;
7 //constructor
8 public Empleado(String nombre,double salario,String cargo)
9 {
10 this.nombre=nombre;
11 this.salario=salario;
12 this.cargo=cargo;
13 }
14 //métodos getters
15 public String getNombre()
16 {
17 return nombre;
18 }
19 public double getSalario()
20 {
21 return salario;
22 }
23 public String getCargo()
24 {
25 return cargo;
26 }
26 //métodos setters
27 public void setCargo(String cargo)
28 {
29 this.cargo=cargo;
30 }
31 public void setSalario(double salario)
32 {
33 this.salario=salario;
34 }
35 }
La clase Empresa: Esta clase contiene un conjunto de Empleados

almacenados dentro de un ArrayList y gestiona todas las funciones
aplicables a todos los empleados de la empresa.
24
1 import java.util.ArrayList;
2 public class Empresa
3 {
4 //Atributos
5 private ArrayList<Empleado> empleados;
6 //constructor
7 public Empresa()
8 {
9 empleados= new ArrayList<Empleado>();
10 }
11 //método que agrega empleados a la empresa
12 public void contratarEmpleado(Empleado e)
13 {
14 empleados.add(e);
15 }
16 //método que obtiene el total de empleados
17 public int getTotalEmpleados()
18 {
19 return empleados.size();
20 }
21 //método que muestra el nombre y salario de todos los empleados
22 public void nombreSalario()
23 {
24 for(Empleado e:empleados)
25 {
26 System.out.println(“Nombre: “+e.getNombre()+” Salario: “+e.getSalario());
27 }
28 }
29 //método que retorna el total de dinero pagado a todos los empleados
30 public double getTotalSalarios()
31 {
32 double total=0;
34 {
35 total=total+e.getSalario();
36 }
37 return total;
38 }
39 //método que muestra el nombre, cargo y salario del empleado que más dinero gana
40 public void empleadoMayorSalario()
41 {
42 Empleado empMayorSalario=empleados.get(0);
43 double maxSalario=empleados.get(0).getSalario();
44
46 {
47 if(e.getSalario()>maxSalario)
48 {
49 maxSalario=e.getSalario();
50 empMayorSalario=e;
51 }
52 }
53 System.out.println(“El empleado que mas dinero gana es “);
54 System.out.print(“Nombre:”+empMayorSalario.getNombre());
55 System.out.print(“ Cargo:”+empMayorSalario.getCargo());
56 System.out.println(“ Salario:”+empMayorSalario.getSalario());
57 }
58 //método que muestra el nombre, cargo y salario del empleado que menos dinero gana
59 public void empleadoMenorSalario()
60 {
61 Empleado empMenorSalario=empleados.get(0);
62 double menSalario=empleados.get(0).getSalario();
63
25
65 {
66 if(e.getSalario()<menSalario)
67 {
68 menSalario=e.getSalario();
69 empMenorSalario=e;
70 }
71 }
72 System.out.println(“El empleado que menos dinero gana es “);
73 System.out.print(“Nombre:”+empMenorSalario.getNombre());
74 System.out.print(“ Cargo:”+empMenorSalario.getCargo());
75 System.out.println(“ Salario:”+empMenorSalario.getSalario());
76 }
77 }
La clase Principal: Esta clase es la encargada de crear los empleados

requeridos, agregarlos a la empresa y acceder a las diferentes
funcionalidades controlando el flujo de ejecución de la aplicación.
1 import javax.swing.JOptionPane;
2 public class Principal
3 {
4 public static void main(String arg[])
5 {
6 int cantidad=Integer.parseInt(JOptionPane.showInputDialog(null,”Ingrese la cantidad de empleados”));
7 Empresa empresa= new Empresa();//instancia de la clase Empresa
8
9 for(int emp=1;emp<=cantidad;emp++)
10 {
11 //lectura de los datos de cada empleado
12 String nombre=JOptionPane.showInputDialog(null,”Ingrese el nombre del empleado”);
13 double salario=Double.parseDouble(JOptionPane.showInputDialog(null,”Ingrese el salario del empleado”));
14 String cargo=JOptionPane.showInputDialog(nulll,”Ingrese el cargo del empleado”);
15 //adición del nuevo empleado a la empresa
16 empresa.contratarEmpleado(new Empleado(nombre,salario,cargo));
17 }
18 //número de empleados
19 System.out.println(“\nEl numero total de empleados es:”+empresa.getTotalEmpleados());
20 //nombre y salario de cada empleado
21 System.out.println(“\nLos nombres y salarios de los empleados son:”);
22 empresa.nombreSalario();
23 //Total de dinero pagado a todos los empleados
24 System.out.println(“\nTotal de dinero pagado a todos los empleados:”+empresa.getTotalSalarios());
25 //nombre, cargo y salario del empleado que más dinero gana
26 empresa.empleadoMayorSalario();
26 //nombre, cargo y salario del empleado que menos dinero gana
27 empresa.empleadoMenorSalario();
28 }
29 }
26
3.3.1. Ejecución de la aplicación Orientada a Objetos
Entrada
Ingrese la cantidad de empelados

3
Aceptar Cancelar
Empleado1
Entrada

Luis Urueta
Aceptar Cancelar
Entrada

1200000
Aceptar Cancelar
Entrada

Asistente
Aceptar Cancelar
Empleado 2
Entrada

Kelly Mejia
Aceptar Cancelar
27
Entrada

2100000
Aceptar Cancelar
Entrada

Administrador
Aceptar Cancelar
Empleado 3
Entrada

Mayra Yanquen
Aceptar Cancelar
Entrada

2000000
Aceptar Cancelar
Entrada

Ingeniero
Aceptar Cancelar
28
El numero total de empleados es: 3
Los nombre y salarios de los empleados son:

Nombre: Mayra Yanquen Salario: 2000000.0
Total de dinero pagado a todos los empleados: 5300000.0

El empleado que ma dinero gana es
El empleado que menos dinero gana es
Press any key to continue...
3.4. Conclusiones
• El uso de un lenguaje de programación orientada a objetos como

Java, no significa que todas las aplicaciones desarrolladas con el sean
orientadas a objetos.
• La ejecución de una aplicación estructurada u orientada a objetos

es transparente para el usuario final, las ventajas de un estilo de
programación u otro son para el programador.
• La Programación Orientada a Objetos es un paradigma o estilo de

programación que se centra en identificar y programar los objetos que
forman parte del mundo real y crear sus respectivas interrelaciones
para solucionar un determinado problema.
• La Programación Orientada a Objetos permite desarrollar un programa

de una manera más ordenada, reutilizable y fácil de mantener.
29
Programación orientada a objetos

OBJETO DE APRENDIZAJE aplicada
Desarrollador de contenido
Andrés Julián Valencia Osorio
Experto temático
Rafael Neftalí Lizcano Reyes

Asesor Pedagógico Claudia Milena Hernández Naranjo
Luis Gabriel Urueta Alvarez

Productor Multimedia Johana Alejandra Gelvez Jaimes
Programadores Daniel Eduardo Martínez Díaz
Líder expertos temáticos Ana Yaqueline Chavarro Parra
Líder línea de producción Santiago Lozada Garcés
30

ProgramacionOrientada A Objetos - Poo

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

ProgramacionOrientada A Objetos - Poo

Загружено:

Авторское право:

Доступные форматы

PROGRAMACIÓN ORIENTADA A OBJETOS

Programa: ANÁLISIS Y DESARROLLO DE SISTEMAS DE

Duración estimada de estudio (horas): 60 hrs

FAVA - Formación en Ambientes Virtuales de Aprendizaje SENA - Servicio Nacional de Aprendizaje

En esta etapa de su proceso de formación ya ha oído o leído sobre la

Lo primero que debemos saber es que la POO es un paradigma de

PROGRAMACIÓN APLICANDO EL EJEMPLO 2 DE

Código en Java con La Abstracción. Solución con Programación

1. APLICACIÓN DE EJEMPLO CON PROGRAMACIÓN

Se requiere una aplicación que lea el nombre de 3 estudiantes de un

1.2. Código en Java con Programación Estructurada.

Podemos observar en el código del programa que pese a ser JAVA un

El resultado de ejecutar el programa es el siguiente:

Ingrese el nombre del estudiante

Ingrese la nota 1 del estudiante

Ingrese la nota 2 del estudiante

Información del Estudiante

El estudiante Reprueba el curso

2. APLICANDO EL PARADIGMA POO (Programación

Al momento de desarrollar una aplicación orientada a objetos, el foco

2.1. Definiendo las Clases.

El primer paso para desarrollar una aplicación orientada a objetos es

“Se requiere una aplicación que lea el nombre de 3 estudiantes de un

curso Clase (No tenida e n cuenta por el a lcance d el

2 notas parciales Atributos

tabla 1. importancia en el programa

A partir del enunciado, es posible identificar clases como:

• Aplicación: Clase que contiene el método main y donde se puede

• Estudiante: Clase a partir de la cual se pueden crear Estudiantes,

• Curso: Clase que contiene estudiantes y por lo tanto permite realizar

Imagen 1. Clases necesarias para responder al enunciado del

2.1.1. Los Atributos.

Del mismo enunciado se pueden extraer los atributos de las clases, es

necesita mantener información almacenada, es decir, no requiere estado.

Estudiante { nombre, notaParcial1, notaParcial2, notaFinal }

public class Estudiante

2.1.2. Los Constructores.

A partir de los atributos identificados, es el momento de definir cuáles de

public class Estudiante

Public Estudiante(String nombre)

El atributo notaFinal no debe solicitarse en el constructor porque la idea

2.1.3. Los Métodos.

La encapsulación en un programa se da cuando se definen los atributos

public class Estudiante

public Estudiante(String nombre)

public void asignarNotaParcial1(float np1)

Un estudiante, además de nombre y notas puede poseer otra información

2.3. Los Objetos.

Con la clase Estudiante codificada, es posible crear objetos a partir de

La herramienta BlueJ, permite crear objetos a partir de una clase, haciendo

new Estudiante (tring nombre)

public Estudiante(String nombre)

BlueJ: Create Object

Name of Instance: estudian1

new Estudiante () “Juan Valencia”

De la misma manera, es posible crear objetos de la clase Estudiante,

BlueJ: Create Object

Name of Instance: estudian2

Ahora, la aplicación cuenta con dos objetos, a partir de los cuales

2.4. Ejecución de Métodos.

Después de crear los objetos, es posible interactuar con todos sus

inheritad from Object

BlueJ: Method Result