LenProg F02
LenProg F02
LenProg F02
Lenguaje de
Programación
Semestre 2
Lenguaje de programación
Lenguaje de
programación Semestre 2
Lenguaje de programación
Introducción 1
Conceptos previos 1
Mapa conceptual Fascículo 2 3
Logros 4
Análisis de las soluciones 4
Metodología para la solución de problemas con el enfoque
de objetos 10
Ejemplos de problemas resueltos con objetos 17
Desarrollo de métodos para los objetos 21
Tipos de datos 26
Uso de funciones predefinidas 26
Ejemplos de conversión de algoritmos a métodos de clases
en Java 26
Resumen 31
Bibliografía recomendada 32
Nexo 32
Seguimiento al autoaprendizaje 33
Anexo 1 35
Anexo 2 37
Anexo 3 45
Créditos: 3
Tipo de asignatura: Teórica – Práctico
Semestre 2
Lenguaje de programación
Lenguaje de
programación Semestre 2
Lenguaje de programación 1
Introducción
La programación requiere tener unos principios, que como se vio en el
fascículo 1 están fundamentados en un correcto análisis algorítmico de los
problemas. Ningún Software de computadora funciona apropiadamente si
no se establece un correcto algoritmo que defina de forma sucinta y clara
la satisfacción de los requerimientos del usuario y que explore de forma
detallada las funcionalidades que deben ser implementadas.
Conceptos previos
Recuerde que es importante tener claras las principales sentencias básicas
de la notación en pseudocódigo, la cual permite establecer las sentencias
lineales de ejecución de un procedimiento algorítmico. Es también impor-
tante recordar que en la programación debemos ajustarnos mucho al
entorno definido por el lenguaje. Finalmente, se propone el desarrollo de
la siguiente actividad como un repaso de lo abordado anteriormente,
Fascículo No. 2
Lenguaje de
programación
2 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 3 Lenguaje de
programación
Lenguaje de programación
Logros
Fascículo No. 2
Lenguaje de
programación
4 Semestre 2
Lenguaje de programación
Se busca ahora, por tanto, que el Sistema permita agilizar ese proceso, de
manera que no tenga que hacerse en una herramienta externa (procesador
de palabras), sino que sea el mismo Sistema quien al final produzca el
documento de manera automática sin tener que intervenir mucho el
usuario en su construcción, por medio, por ejemplo, de una plantilla
estandarizada que genere el documento y lo almacene en la base de datos
del sistema.
Fascículo No. 2
Semestre 2 5 Lenguaje de
programación
Lenguaje de programación
En el Lenguaje de Modela- artefactos documentales, conocidos como Casos de Uso. Estos son
do Unificado, un diagrama
de casos de uso es una elementos que permiten capturar los requisitos de forma detallada,
especie de diagrama de
comportamiento del Sis- indicando las fronteras de operación del Sistema Software, los usuarios
tema. El Lenguaje de Mo-
delado Unificado define que interactúan con las funcionalidades y finalmente los resultados
una notación gráfica para
representar casos de uso generados por el procesamiento de las mismas, a partir del proceso de
llamada modelo de casos
de uso. interacción usuario-sistema. Dichos artefactos, se acompañan a su vez de
una serie de diagramas que permiten entender mejor la interacción del
usuario con el Sistema y de la responsabilidad que cada actor tiene en el
proceso. Dichos diagramas son conocidos igualmente como Diagramas
de Casos de Uso.
Figura 2.1
Ejemplo de diagramas de Casos de Uso de las
funcionalidades descritas en el problema de la
Universidad.
Fascículo No. 2
Lenguaje de
programación
6 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 7 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 2
Lenguaje de
programación
8 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 9 Lenguaje de
programación
Lenguaje de programación
comportan tanto la aplicación como los datos, una vez han finalizado el
caso de uso, a través de su flujo básico de eventos o sus flujos
alternativos. Por ejemplo, si hablásemos de una aplicación de registro
de clientes en un hotel, la postcondición del caso de uso Reservar
Habitación, sería la de un registro de habitación separada, que fue
asignada a un usuario en particular (cliente del Hotel) y que ya no puede
ser dada a ningún otro cliente.
10. Reglas de Negocio: Define el conjunto de reglas matemáticas,
lógicas, de relaciones humanas y sociales que influyen en el desarrollo
de la lógica algorítmica del requerimiento funcional. Estas reglas son
muy importantes, precisamente porque establecen las bases del mundo
del problema que deben ser tenidas en cuenta para la posterior
implementación programática de las interacciones del usuario con el
sistema, a través de los objetos y las interfaces gráficas de usuario.
Fascículo No. 2
Lenguaje de
programación
10 Semestre 2
Lenguaje de programación
Figura 2.2
Objeto Cuenta Bancaria.
Fascículo No. 2
Semestre 2 11 Lenguaje de
programación
Lenguaje de programación
20553335
Jaime Pérez
$0.00
Cuenta Bancaria
Número de Cuenta
Titular
Saldo
Cuenta de Martha
20553343
Martha Suárez
$1000.000.000.00
Figura 2.3
Concepto de la Cuenta Bancaria y ejemplos de la
cuenta en el mundo real.
¿Qué garantiza que cada cuenta sea individual? Muchas cosas. En primer
lugar que cuando se ejecute una transacción se haga hacia una cuenta
específica y que no afecte el saldo de los demás usuarios diferentes al del
interesado sobre el que se desea aplicar la transacción. También que sea
posible consultar el estado de cada uno o generar un reporte general del
estado de todos los usuarios en el sistema independientemente de que
sean 20 o 10000. ¿Pero, cómo llegamos a esto? Pues precisamente, a
través de la definición de una plantilla que permita especificar de forma
Fascículo No. 2
Lenguaje de
programación
12 Semestre 2
Lenguaje de programación
genérica, datos que sean comunes a todos los usuarios, y ahí es cuando
aparece el concepto de la Clase.
Fascículo No. 2
Semestre 2 13 Lenguaje de
programación
Lenguaje de programación
Cuenta de Jaime
20553335
Jaime Pérez
$0.00
Cuenta Bancaria
Número de Cuenta
Titular
Saldo Cuenta de Martha
20553343
Martha Suárez
$1000.000.000.00
Figura 2.4
Clase Objetos
Representación de una Clase y de sus correspondientes objetos.
Fascículo No. 2
Lenguaje de
programación
14 Semestre 2
Lenguaje de programación
Figura 2.5
Ejemplo de un Diagrama de Clases.
Figura 2.6
Diagrama de Clases para el Objeto CuentaBancaria
Fascículo No. 2
Semestre 2 15 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 2
Lenguaje de
programación
16 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 17 Lenguaje de
programación
Lenguaje de programación
Figura 2.7
Diagrama de Casos de Uso del Caso
de la Cuenta Bancaria.
Fascículo No. 2
Lenguaje de
programación
18 Semestre 2
Lenguaje de programación
Una vez establecidos los casos de uso (para el ejemplo sólo se establece
el caso de uso: Consignar monto de cuenta) se procede al análisis
gramatical de los mismos, para identificar los objetos candidatos, los
nombres de las operaciones potenciales (métodos) y los datos críticos
para el diseño de los objetos (atributos):
Caso de Uso: Consignar monto en cuenta
1. Descripción breve: Este caso de uso hace alusión a la capacidad del sistema de
poder ingresar un valor específico de dinero a la cuenta bancaria y con ello
incrementar el valor actual del saldo consignado en dicha cuenta. Para ello el
usuario debe ingresar el código de la cuenta y el valor total que desea consignar.
2. Actor: Cuentahabiente o usuario
3. Precondición: Contar con una cuenta habilitada en el Sistema y tener un saldo y
un titular asignado a la misma.
4. Flujo Básico de Eventos
1. El usuario ingresa el código de la cuenta
2. El sistema solicita el valor total que va a ser consignado
3. El usuario ingresa el valor del total a depositar
4. El sistema incrementa el valor del saldo de la cuenta
5. El sistema informa al usuario que el valor ha sido consignado
6. El usuario recibe el desprendible de confirmación del monto consignado.
5. Flujos Excepcionales
5.1 Primer flujo excepcional: Si en el paso 1 el usuario ingresa mal el código, el
Sistema genera un mensaje de error informándole que dicha cuenta no existe. El
Sistema regresa a pedir nuevamente el código.
5.2 Segundo flujo excepcional: Si en el paso 2, el usuario presiona el botón
Cancelar, el Sistema genera un mensaje de error indicando que la operación de
consignación ha sido cancelada. El sistema se cierra por seguridad.
6. Postcondición: Una vez finalizado el ingreso del nuevo monto, el Sistema
actualiza el saldo del cuentahabiente.
7. Lógica de Negocio: Cuando se realiza una consignación mayor a $10.000.00, el
Banco genera un bono de contribución para el cuentahabiente del 20% del valor
depositado.
Fascículo No. 2
Semestre 2 19 Lenguaje de
programación
Lenguaje de programación
Figura 2.8
Diagrama de Clases para la solución del Banco.
Figura 2.9
Secuencia de eventos del caso de Uso
Consignar monto en cuenta.
Fascículo No. 2
Lenguaje de
programación
20 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 21 Lenguaje de
programación
Lenguaje de programación
//Algoritmo de cálculo
resultado = n1 + n2;
Fascículo No. 2
Lenguaje de
programación
22 Semestre 2
Lenguaje de programación
switch (numeroMes)
{
case 1:
nombreMes = "Enero";
break;
case 2:
nombreMes = "Febrero";
break;
case 3:
nombreMes = "Marzo";
Fascículo No. 2
Semestre 2 23 Lenguaje de
programación
Lenguaje de programación
break;
case 4:
nombreMes = "Abril";
break;
case 5:
nombreMes = "Mayo";
break;
case 6:
nombreMes = "Junio";
break;
case 7:
nombreMes = "Julio";
break;
case 8:
nombreMes = "Agosto";
break;
case 9:
nombreMes = "Septiembre";
break;
case 10:
nombreMes = "Octubre";
break;
case 11:
nombreMes = "Noviembre";
break;
case 12:
nombreMes = "Diciembre";
break;
}//Fin del switch
return (nombreMes);
}
Retorno de un valor de tipo Objeto (En el ejemplo, existe una clase llamada
Empleado, que es el objeto que el método va a retornar) – (VER ANEXO 3 –
IMPLEMENTACIÓN DE LA CLASE EMPLEADO):
Método de retorno:
public Empleado obtenerDatosEmpleado (String codigo,
String nombre, String apellido, int edad, double salario)
{
Empleado datosEmpleado = null;
//Instanciamos el objeto a retornar
datosEmpleado = new Empleado();
Fascículo No. 2
Lenguaje de
programación
24 Semestre 2
Lenguaje de programación
datosEmpleado.setCodigo(codigo);
datosEmpleado.setNombre(nombre);
datosEmpleado.setApellido(apellido);
datosEmpleado.setEdad(edad);
datosEmpleado.setSalario(salario);
return (datosEmpleado);
}
Por lo tanto, cuando se crea una nueva clase en Java, se puede especificar
el nivel de acceso que se quiere para las variables de instancia y los
métodos definidos en la clase:
Fascículo No. 2
Semestre 2 25 Lenguaje de
programación
Lenguaje de programación
Tipos de datos.
Uso de funciones predefinidas.
Ejemplos de conversión de algoritmos a métodos de clases en Java
Los datos en Java son el punto de partida fundamental para la
construcción de los algoritmos. Gracia a ellos, es posible caracterizar la
Fascículo No. 2
Lenguaje de
programación
26 Semestre 2
Lenguaje de programación
Fascículo No. 2
Semestre 2 27 Lenguaje de
programación
Lenguaje de programación
return (resultado);
}
/*
Fascículo No. 2
Lenguaje de
programación
28 Semestre 2
Lenguaje de programación
Ejemplo
Desarrollar un algoritmo para ingresar una cadena de caracteres y obtener
su equivalente inverso (la cadena al revés). Obramos de igual forma:
Retorno Una cadena de caracteres (en este caso, la cadena al revés).
Esto nos lleva a declarar un retorno de tipo String.
Nombre del método Vamos a realizar la conversión de una cadena para obtener su
equivalente inverso. Por lo tanto, el mejor nombre para el
método sería invertirCadenaCaracteres()
Parámetros Tenemos como insumo para este problema, la cadena original,
por lo tanto, nuestro parámetro de ingreso al método sería String
cadenaOriginal
Fascículo No. 2
Semestre 2 29 Lenguaje de
programación
Lenguaje de programación
2.1
Fascículo No. 2
Lenguaje de
programación
30 Semestre 2
Lenguaje de programación
X = (2 * Suma)/5;
Y = (Suma^3) + 1/3 * (Suma*sqrt(Suma))
Z = 1/2 * (Suma) + sqrt(LN(Suma+1/Suma))
1 + 2 + 3 + 4 + 5 + 6 = 21
21 – 20 = 1
Fascículo No. 2
Semestre 2 31 Lenguaje de
programación
Lenguaje de programación
Fascículo No. 2
Lenguaje de
programación
32 Semestre 2
Lenguaje de programación
Seguimientoal autoaprendizaje
2. Siguiendo las premisas del punto 1, desarrolle una aplicación Java que calcule
el promedio de notas de un estudiante (máximo 5 notas) con base en la
siguiente lógica de negocio:
Toda facturación debe tener una lectura de medición de gas del mes anterior y
del mes actual y de la diferencia se obtiene el consumo en el mes. Por ejemplo,
si el período es febrero-marzo, entonces si la lectura anterior fue de 200 m3 de
gas y la del mes actual 450, entonces eso quiere decir que vamos a facturar el
mes de febrero con un consumo de 250 m3.
Fascículo No. 2
Semestre 2 33 Lenguaje de
programación
Lenguaje de programación
Finalmente, cada metro cúbico de gas consumido, tiene un valor también que
depende del estrato
Estrato Valor del metro cúbico
1 $500.00
2 $650.00
3 $800.00
4 $1000.00
5 $2500.00
El programa debe mostrar el nombre del cliente, el consumo, las lecturas de los
meses, el período facturado, el valor del metro cúbico, el cargo fijo, el cargo
variable y el total de la factura para ese usuario del SPD (Servicio Público
Domiciliario).
Fascículo No. 2
Lenguaje de
programación
34 Semestre 2
Lenguaje de programación
Anexo 1
Definición de la clase para el problema del cajero
bancario
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Espacio Académico: Lenguaje de Programación
* Fascículo II: UNIDAD II: CARACTERIZACIÓN DEL LENGUAJE DE
PROGRAMACIÓN
*
* Ejemplo de una Clase Java implementada a partir del Diagrama
* de Clases en UML
* Objeto Cuenta Bancaria
*
* Define una serie de operaciones y atributos relacionados
* con el manejo de la cuenta bancaria de un usuario de un banco
*/
/**********************************************/
/**********************************************/
/**********************************************/
//Método Constructor
public CuentaBancaria()
{
super();
// TODO Auto-generated constructor stub
}
/**********************************************/
/**********************************************/
/**********************************************/
/*
* Operaciones o métodos que operan la lógica de comportamiento
* de la clase
* */
Fascículo No. 2
Semestre 2 35 Lenguaje de
programación
Lenguaje de programación
/*
* Método para consignar un monto de dinero contra el saldo
* de la cuenta bancaria
*
* Recibe como argumentos, el código de la cuenta y el total
* que va a ser consignado. Una vez se ha ejecutado la
* consignación
* devuelve un valor booleano (verdadero si se pudo consignar o
* false si se generó un error.
* */
public boolean consignarDinero (String numeroCuenta,
double montoConsignar)
{
boolean seConsigno = false;
return (seConsigno);
}
/*
* Método para retirar un monto de dinero del saldo
* de la cuenta bancaria
*
* Recibe como argumentos, el código de la cuenta, una variable
* booleana de confirmación o aceptación sobre el retiro y por
* supuesto el monto total a retirar
*
* Cuando el método se ejecuta, devuelve como resultado
* el monto retirado
* */
public double retirarDinero (String codigoCuenta,
boolean aceptaRetirar, double montoRetirar)
{
double valorRetirado = 0.0;
return (valorRetirado);
}
/*
* Método para consultar el valor del saldo que actualmente está
* cuenta bancaria
*
* Recibe como argumento el código de la cuenta para poder
* consultar un saldo en particular del usuario
* */
public double consultarSaldo (String codigoCuenta)
{
double valorSaldo = 0.0;
return (valorSaldo);
}
Fascículo No. 2
Lenguaje de
programación
36 Semestre 2
Lenguaje de programación
/*
* Método para hacer el cierre de la cuenta bancaria
*
* Recibe como argumentos el código de identificación de
* la cuenta y una marca boolean que confirma por parte del
* usuario la disponibilidad de cerrarla
* */
public boolean cerrarCuenta (String codigoCuenta,
boolean aceptaCierre)
{
boolean seCerroCuenta = false;
return (seCerroCuenta);
}
/**********************************************/
/**********************************************/
/**********************************************/
}//Fin de la clase
Anexo 2
Implementación del problema del cajero bancario
import javax.swing.JOptionPane;
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Espacio Académico: Lenguaje de Programación
* Fascículo II: UNIDAD II: CARACTERIZACIÓN DEL LENGUAJE
DE PROGRAMACIÓN
*
* Considerando nuestro anterior análisis de la cuenta bancaria,
* imaginemos que se nos solicita como ingenieros de desarrollo
* realizar la siguiente implementación: Generar una
* aplicación que desarrolle un cajero electrónico que
* permita ingresar dinero y retirar del mismo un valor
* determinado por el usuario. El sistema debe tener en
* cuenta las siguientes características:
*
* a) Cuando se realiza una consignación mayor a $10.000.00,
* el Banco genera un bono de contribución para el cuentahabiente
* del 20% del valor depositado.
*
* b) Cuando el usuario retira cualquier cantidad de dinero
* mayor a $500.000.00, se genera una retención del 5%
* sobre el monto retirado.
Fascículo No. 2
Semestre 2 37 Lenguaje de
programación
Lenguaje de programación
*
* c) El Sistema debe generar un mensaje de error que no permite
* retirar si el saldo actual del cuentahabiente es menor o igual a
* $5000.00.
*/
/*
* Método para consignar un monto de dinero contra el
* saldo
* de la cuenta bancaria
*
* Recibe como argumentos, el código de la cuenta y el total
* que va a ser consignado. Una vez se ha ejecutado la consignación
* devuelve un valor booleano (verdadero si se pudo
* consignar o
* false si se generó un error.
* */
public boolean consignarDinero (String codigoCuenta,
double montoConsignar)
{
//Variables locales del método
boolean seConsigno = false;
boolean existeCuenta = false;
Fascículo No. 2
Lenguaje de
programación
38 Semestre 2
Lenguaje de programación
JOptionPane.showMessageDialog(null,
"Se otorgará un bono del 20% del valor a
consignar en la cuenta");
}
//Incrementamos el saldo
saldo = saldo + montoConsignar;
Fascículo No. 2
Semestre 2 39 Lenguaje de
programación
Lenguaje de programación
return (seConsigno);
}
/*
* Método para retirar un monto de dinero del saldo
* de la cuenta bancaria
*
* Recibe como argumentos, el código de la cuenta, una
* variable
* booleana de confirmación o aceptación sobre el retiro y por
* supuesto el monto total a retirar
*
* Cuando el método se ejecuta, devuelve como resultado
* el monto retirado
* */
public double retirarDinero (String codigoCuenta,
boolean aceptaRetirar, double montoRetirar)
{
//Variables locales al método
double valorRetirado = 0.0;
double retencionFuente = 0.0;
double totalRetirado = 0.0;
boolean existeCuenta = false;
int i = 0;
String confirmarRetiro = "";
Fascículo No. 2
Lenguaje de
programación
40 Semestre 2
Lenguaje de programación
confirmarRetiro =
JOptionPane.showInputDialog(null,
"Digite Si para confirmar el retiro o no
para cancelar la operación: ");
if (confirmarRetiro.equals("Si"))
{
//Verificamos el monto a retirar para
aplicar la //retención
if (montoRetirar > 500000)
{
retencionFuente =
montoRetirar * 0.05;
JOptionPane.showMessag
eDialog(null,"Se hará una
retención sobre el retiro del
5%");
}
//Decrementamos el saldo en el
//monto solicitado
//y la retención si fue mayor a cero. Si no
hubo //retención
//no hay problema alguno
totalRetirado = montoRetirar +
retencionFuente;
saldo = saldo - totalRetirado;
//Informamos cuanto se retiró
valorRetirado = totalRetirado;
}
else
{
//El usuario canceló la operación
JOptionPane.showMessageDialog
(null,"La operación
ha sido cancelada por el usuario");
}
}
else
{
//No se puede retirar nada, porque los
//fondos son insuficientes
Fascículo No. 2
Semestre 2 41 Lenguaje de
programación
Lenguaje de programación
JOptionPane.showMessageDialog(null,"
No se puede retirar:
Fondos insuficientes");
valorRetirado = 0.0;
}
}
else
{
//La cuenta no existe, por lo que el retiro se
//cancela
JOptionPane.showMessageDialog(null,"La
//cuenta no existe en el Sistema");
valorRetirado = 0.0;
}
return (valorRetirado);
}
/*
* Método para consultar el valor del saldo que actualmente
* está
* cuenta bancaria
*
* Recibe como argumento el código de la cuenta para poder
* consultar un saldo en particular del usuario
* */
public double consultarSaldo (String codigoCuenta)
{
double valorSaldo = 0.0;
boolean existeCuenta = false;
int i = 0;
if (existeCuenta == true)
{
valorSaldo = saldo;
}
else
Fascículo No. 2
Lenguaje de
programación
42 Semestre 2
Lenguaje de programación
{
JOptionPane.showMessageDialog(null,"La cuenta no
existe en el Sistema");
}
return (valorSaldo);
}
/**********************************************/
/**********************************************/
/**********************************************/
/*
* Método principal de la aplicación
* */
public static void main(String[] args)
{
/**********************************************/
/**********************************************/
/**********************************************/
//Instanciación del objeto de tipo Cuenta. El objeto
//se denomina nuevaCuentaBancaria
Cuenta nuevaCuentaBancaria = new Cuenta();
/*********************************************/
/*********************************************/
/*********************************************/
//Caso de uso Consignar Monto en Cuenta
seConsigno =
nuevaCuentaBancaria.consignarDinero
(codigoCuenta,valor);
if (seConsigno == true)
{
JOptionPane.showMessageDialog(null,"El dinero se
Fascículo No. 2
Semestre 2 43 Lenguaje de
programación
Lenguaje de programación
consignó satisfactoriamente");
}
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
//Caso de uso Retirar monto de cuenta
//Luego realizamos un retiro
valorRetirar =
Double.parseDouble(JOptionPane.showInputDialog(null,"Ingr
es el valor a retirar de la cuenta: "));
saldo =
nuevaCuentaBancaria.retirarDinero
(codigoCuenta,true,valorRetirar);
JOptionPane.showMessageDialog(null,"El valor
retirado fue de " + saldo);
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
/*********************************************/
//Caso de uso Consultar Saldo de Cuenta
saldo =
nuevaCuentaBancaria.consultarSaldo
(codigoCuenta);
JOptionPane.showMessageDialog(null,"El saldo actual en la
cuenta es de: " + saldo);
/**********************************************/
/**********************************************/
/**********************************************/
}
/**********************************************/
/**********************************************/
/**********************************************/
}//Fin de la clase
Fascículo No. 2
Lenguaje de
programación
44 Semestre 2
Lenguaje de programación
Anexo 3
Implementación de la clase empleado
Clase Empleado:
/**
* @author Ingeniero Jaime Alberto Gutiérrez Mejía
* Fundación Universitaria San Martín
* Espacio Académico: Lenguaje de Programación
* Fascículo II: UNIDAD II: CARACTERIZACIÓN DEL LENGUAJE
* DE PROGRAMACIÓN
*
* Ejemplos de un objeto de valores (value object)
* para representar la entidad Empleado
*/
/******************************************/
/******************************************/
/******************************************/
public Empleado() {
super();
// TODO Auto-generated constructor stub
}
/******************************************/
/******************************************/
/******************************************/
//Métodos de Encapsulamiento
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
public int getEdad() {
return edad;
Fascículo No. 2
Semestre 2 45 Lenguaje de
programación
Lenguaje de programación
}
public void setEdad(int edad) {
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getSalario() {
return salario;
}
public void setSalario(double salario) {
this.salario = salario;
}
public String getCodigo() {
return codigo;
}
Fascículo No. 2
Lenguaje de
programación
46 Semestre 2