EJEMPLO DE DESARROLLO - PSEUDOCODIGO

Ejemplo 1.
En una empresa que brinda mantenimiento a PC’s se han clasificado a las maquinas de
acuerdo al numero de desperfectos que estas presentan. Si la PC no tiene ninguna falla
es tipo A, si la PC tiene 3 fallas se le considera tipo B y si la PC tiene más de 3 fallas es
tipo C.
Escribir un algoritmo para implementar este proceso, No se sabe cuantas PC’s se
evaluaran en un día, el algoritmo debe preguntar si se desea continuar y terminar el
ingreso “N”. Asimismo al finalizar se debe mostrar por pantalla las estadísticas
porcentuales correspondientes a la evaluación de ese día.

Ejemplo del reporte a mostrar:

TIPO TOTAL DE COMPUTADORAS PORCENTAJE

A 33 52.33%
B 24 38.71%
C 5 8.06%

Análisis Del Problema:

 En este problema se utilizara el método LeeProcesaNumFallas() , el cual lee el

numero de fallas de cada computadora y simultáneamente procesa este dato,
realiza la clasificación correspondiente al numero de fallas, calcula las
estadísticas solicitadas y finalmente muestra el mensaje correspondiente.

 Asimismo se utiliza el método MuestraEstadisticas().

 Los contadores ContA, ContB y ContC deben ser inicializados en cero.

Clase Solución Del Problema:

Clase Inspector

Atributos:
NumFallas

Métodos:
LeeProcesaNumFallas()
MuestraEstadisticas()

1
Implementación en Pseudocodigo:

CLASE INSPECTOR {
// Atributos
entero NumFallas
entero TipoA
entero TipoB
entero TipoC

//Métodos
Publico Inspector() {
NumFallas = 0
TipoA = 0 , TipoB = 0 , TipoC = 0
}

Publico vacio LeeProcesoNumFallas( ) {

caracter Rpta = “ ”
Mientras (Rpta < > ‘N’ y Rpta < > ‘n’)

Escribe (“Ingrese el numero de fallas”)

Leer ( NumFallas)
Si ( NumFallas = 0) TipoA <- TipoA + 1
Sino
Si ( NumFallas <= 3) TipoB  TipoB + 1
Sino
TipoC TipoC + 1
FinSi
FinSi
Escribe ( “¿ Desea Continuar S/N? ”)
Leer (Rpta)

Fin_Mientras
}

Publico vacio MuestraEstadisticas( ) {

entero Total.
Total  TipoA + TipoB +TipoC
Escribir ( “ ESTADISTICAS “)
Escribir (“ TIPO TOTAL DE COMPUTADORAS PORCENTAJE
“)
Escribir
(“-----------------------------------------------------------------------------------“)
Escribir ( “ A “ , TipoA , TipoA * 100 / Total )
Escribir ( “ B “ , TipoB , TipoB * 100 / Total )
Escribir ( “ C “ , TipoC , TipoC * 100 / Total )
}

Método Principal ( ){

Inspector Oscar ← nuevo Inspector()

2
 Oscar. LeeProcesaNumFallas()
Oscar.MuestraEstadisticas()
}
} // Fin de la clase

Ejemplo 2.
Una financiera tiene 3000 clientes, ha decidido premiar a su staff de 30 vendedores.
Escribir una solución que permita, saber quien es el ejecutivo con el mayor número de
contratos conseguidos pues recibirá un Bono especial de $ 500 dólares como premio.
Además se otorgara otros premios al resto del personal según la siguiente tabla:

Numero de contratos conseguidos Bono ($)

Mas de 100 200
Menos de 50 pero mas de 10 50
Menores de 100 y mayores o iguales a 50 100

Determinar el Monto total en dólares que desembolsara la financiera en concepto de

bonos.
Análisis Del Problema:

 En este problema se utilizara el método ProcesaDatos() , para leer el nombre de

los vendedores de la Financiera y el numero de contratos que han colocado,
determinando al ejecutivo que obtendra el premio, tambien se procesara todos
los casos por los cuales la financiera otorgara por bonos, obteniendo el total del
importe en bonos.
 Asimismo se utiliza el método MuestraResultados().

Clase Solución Del Problema:

Clase BonosFinanciera

Atributos:
NomVendedorGanador
NumContratosGanador
TotalEnBonos

Métodos:
ProcesaDatos()
MuestraResultados()

Implementación en Pseudocodigo:
CLASE BonosFinanciera {
// Atributos
Cadena NomVendedorGanador
Entero NumContratosGanador
Real TotalEnBonos

//Métodos

3
 Publico BonosFinanciera( ) {
NumContratosGanador ← 0
TotalEnBonos ← 0

Publico vacio ProcesoDatos( ) {

cadena Nombre
Entero NumContrato
entero i
Para i desde 1 hasta 30
Escribe (“Ingrese el nombre del vendedor: ” , i )
Leer (Nombre)
Escribe (“Ingrese numero de contratos ” )
Leer ( NumContrato)
Si ( NumContratos > NumContratosGanador)
NumContratosGanador <- NumContratos
NomVendedorGanador <- Nombre
FinSi.
Si ( NumContratos > 10 y NumContratos < 50 )
TotalEnBonos = TotalEnBonos + 50
FinSi
Si ( NumContratos > = 50 y NumContratos < 100 )
TotalEnBonos = TotalEnBonos + 100
FinSi
Si ( NumContratos >= 100 )
TotalEnBonos = TotalEnBonos + 200
FinSi
FinPara

Publico vacio MuestraResultados( ) {

Cadena NomVendedorGanador
Entero NumContratosGanador
Real TotalEnBonos
Escribir ( “ EL EJECUTIVO GANADOR ES : “ , NomVendedorGanador )
Escribir (“EL TOTAL DE CONTRAROS SON:” ,NumContratosGanador )
Escribir (“EL TOTAL A DESEMBOLSAR POR LA FINANCIERA ES: “)
Escribir ( TotalEnBonos )
}

Método Principal ( ) {
BonosFinanciera Financiera ← nuevo BonosFinanciera ()
Financiera.ProcesaDatos()
Financiera .MuestraResultados()
}

} //Fin de la clase.

4
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 1: Lectura de datos

Ejemplo 1

//Clase Leer: Leer un dato entero

import java.io.*;
public class Leer {
public static void main(java.lang.String[] args) {
// Inserte aquí código para iniciar la aplicación.
int dato_int=0;
System.out.print("Ingrese un dato entero : ");
dato_int=Leer.datoInt();
System.out.println("El numero ingresado fue : "+dato_int);
}

//Método datoInt :
public static int datoInt() {
return Integer.parseInt(dato());
}

//Método dato:
public static String dato() {
String sdato="";
try
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);
sdato=flujoE.readLine();
}
catch (IOException e)
{
System.err.println("ERROR:"+e.getMessage());
}
return sdato;
}
}

Ejemplo 2: Sumar dos enteros

import java.util.Scanner;
public class Lectura_suma_cScanner {

public static void main(String[] args) {

Scanner entrada=new Scanner(System.in);
int n1,n2,suma;
System.out.println("Numeros enteros para sumar");
System.out.print("Primer numero: ");
n1=entrada.nextInt();

5
 System.out.print("Segundo numero: ");
n2=entrada.nextInt();
suma=n1+n2;
System.out.printf("La suma es %d \n",suma);
}

**********************************************************************

//import java.util.Scanner;
import javax.swing.JOptionPane;
public class lectura_suma_iG {
//private static String String;

public static void main(String[] args) {

//lectura_suma_iG entrada1=new lectura_suma_iG();
int n1,n2,suma;
String sn1,sn2,mensaje;
sn1=JOptionPane.showInputDialog("Dar dos enteros para sumar, primer numero:
");
n1=Integer.parseInt(sn1);
sn2=JOptionPane.showInputDialog("segundo numero: ");
n2=Integer.parseInt(sn2);
suma=n1+n2;
mensaje=String.format("La suma de los numeros es: %d",suma);
JOptionPane.showMessageDialog(null,mensaje);
}
}

Ejemplo 3
Construir una clase llamada Luz que simule una luz de semáforo. El atributo color de la
clase debe cambiar de Verde a Amarillo y a Rojo y de nuevo regresar a Verde mediante
la función Cambio. Cuando se crea un objeto Luz, su color inicial será Rojo.

import java.io.*;
public class cLuz {
//Atributo
String color;

//Métodos
cLuz(){
color="Rojo";
}
public void Cambio(){
color="Verde";
System.out.println(color);
color="Amarillo";
System.out.println(color);
color="Rojo";

6
 System.out.println(color);
}
public static void main(String[] args) {
char rpta='s';
cLuz oLuz=new cLuz();
while(rpta=='s'){
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader flujoE=new BufferedReader(isr);
PrintStream flujoS=System.out;
try{
oLuz.Cambio();
flujoS.print("Desea continuar<s/n>: ");
rpta=(char)flujoE.read();
}
catch(IOException e){
System.out.println("Error:"+e.getMessage());
}
}
}
}

7
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 2: Objetos, Clases, Métodos

import javax.swing.JOptionPane;
import java.util.*;
public class cPersona {

//privados:
String nombre;
int edad;
private int dia,mes,año;

//publicos:
public void AsignarNombre(String nom){
nombre=nom;
}
public void AsignarEdad(int e){
edad=e;
}

public String ObtenerNombre(){

return nombre;
}

public int ObtenerEdad(){

return edad;
}
public void asignarFecha()
{
GregorianCalendar fechaActual= new GregorianCalendar();
dia=fechaActual.get(Calendar.DAY_OF_MONTH);
mes=fechaActual.get(Calendar.MONTH)+1;
año=fechaActual.get(Calendar.YEAR);
}
public void asignarFecha(int dd){
asignarFecha();
dia=dd;
}
public void asignarFecha(int dd, int mm){
asignarFecha();
dia=dd; mes=mm;
}
public void asignarFecha(int dd, int mm, int aaaa){
dia=dd; mes=mm; año=aaaa;
}

8
 public static void main(String[] args) {

cPersona alumno=new cPersona();

cPersona profesor=new cPersona();
String tnom_a,tedad_a_s,tnom_p,tedad_p_s,mensaje_n_a,mensaje_e_a;
int tedad_a,tedad_p;

tnom_a=JOptionPane.showInputDialog("Nombre del alumno: ");

tedad_a_s=JOptionPane.showInputDialog("edad del alumno: ");
tedad_a=Integer.parseInt(tedad_a_s);
alumno.AsignarNombre(tnom_a);
alumno.AsignarEdad(tedad_a);
mensaje_n_a=String.format("Alumno: %s",alumno.ObtenerNombre());
mensaje_e_a = String.format("\n tiene: %d años",alumno.ObtenerEdad());
JOptionPane.showMessageDialog(null,mensaje_n_a);
JOptionPane.showMessageDialog(null,mensaje_e_a);

tnom_p=JOptionPane.showInputDialog("Nombre del profesor: ");

tedad_p_s=JOptionPane.showInputDialog("edad del profesor: ");
tedad_p=Integer.parseInt(tedad_p_s);
profesor.AsignarNombre(tnom_p);
profesor.AsignarEdad(tedad_p);
mensaje_n_a=String.format("Profesor: %s",profesor.ObtenerNombre());
mensaje_e_a = String.format("\n tiene: %d años", profesor.ObtenerEdad());
JOptionPane.showMessageDialog(null,mensaje_n_a);
JOptionPane.showMessageDialog(null,mensaje_e_a);
}
}

9
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 3: Arreglo de Objetos

Dada la clase Alumno, con los datos: código, nombre, promedio final; definir un arreglo
de alumnos, para permitir: ingresar y agregar por código cuando éste no existe, luego
mostrar los alumnos ingresados. Al ingresar se debe buscar si el código del alumno
existe o no en el arreglo, para poder agregar o no al arreglo. Al añadir un elemento, se
actualiza la longitud del arreglo de objetos, y luego se añade el objeto al final.
Pedir el número de alumnos para procesar.

Análisis:
Existen métodos para ingresar, agregar por código, mostrar, buscar alumno por código,
actualizar longitud del arreglo, añadir un objeto.

Clase(s) solución:

Clase Alumno Clase ArregloAlumnos

Atributos: Atributos:
codigo Alumno[] ca
nombre nElementos
promediofinal Métodos:
ArregloAlumnos( )
Métodos: ingresar( )
Alumno(….) buscarAlumno(codigo)
AsignarNombre(….) agregarporcodigo(Alumno ….)
ObtenerNombre(…) unElementoMas(Alumno[] …)
…………………… ponerValorEn(índicex, Alumno …)
mostrar()

Método Principal:

// Crear objeto Arreglo de alumnos vacío (con cero elementos)

Para el objeto definido llamar a ingresar();
Para el objeto definido llamar a mostrar();

************************************************************

public class Alumno {

String codigo;
String nombre;
int promediofinal;
public Alumno(){}

10
 public Alumno(String cod,String nom,int pf){
codigo=cod;
nombre=nom;
promediofinal=pf;
}
public void setCodigo(String cod){
codigo=cod;
}
public void setNombre(String nom){
nombre=nom;
}
public void setPromediofinal(int pf){
promediofinal=pf;
}
public String getCodigo() {
return codigo;
}
public String getNombre() {
return nombre;
}
public int getPromediofinal() {
return promediofinal;
}
}

public class ArregloAlumnos {

private Alumno[] ca; //Arreglo de objetos de la clase Alumno
private int nElementos ; // No. de elementos del arreglo
public ArregloAlumnos(){
nElementos =0;
ca=new Alumno[nElementos]; // Crea arreglo Alumno vacío con
} // cero elementos
public boolean buscarAlumno(String cod) {
for(int i=0;i< nElementos;i++){
if(cod.equals(ca[i].getCodigo()))
{System.out.println("codigo encontrado");
return true;}
}
System.out.println("codigo no encontrado");
return false;
}
private void unElementoMas(Alumno[] listaActual){
nElementos =listaActual.length;
ca=new Alumno[nElementos +1];
for(int i=0;i< nElementos;i++)
ca[i]=listaActual[i];
nElementos ++;
}
public void ponerValorEn(int i,Alumno objeto){
if(i>=0 && i< nElementos)

11
 ca[i]=objeto;
else
System.out.println("Indice fuera de limites");
}
public void agregarporcodigo(Alumno obj){
unElementoMas(ca);
ponerValorEn(nElementos -1,obj);

}
public void ingresar() {
String codigo_i,nombre_i;
int promediofinal_i;
Alumno at=new Alumno();
System.out.print("Codigo: ");
codigo_i=PromedioAlumnos.dato();
System.out.println("codigo ingresado: "+codigo_i);
if(!buscarAlumno(codigo_i)){
at.setCodigo(codigo_i);
System.out.print("Nombre: ");
nombre_i=PromedioAlumnos.dato();
at.setNombre(nombre_i);
System.out.print("Promedio final(entero): ");
promediofinal_i=PromedioAlumnos.datoInt();
agregarporcodigo(new Alumno(codigo_i,nombre_i,promediofinal_i));
}
}
public void visualizar(){
System.out.println("DATOS INGRESADOS");
for(int i=0;i< nElementos;i++){
System.out.print(ca[i].getCodigo()+" "+ca[i].getNombre()+"
"+ca[i].getPromediofinal());
System.out.println();
}
}
}

import java.io.*;
public class PromedioAlumnos {
public static int datoInt(){
return Integer.parseInt(dato());
}
public static String dato(){
String sdato="";
try{
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader flujoE=new BufferedReader(isr);
sdato=flujoE.readLine();
}
catch(IOException e){
System.err.println("ERROR"+e.getMessage());

12
 }
return sdato;
}

public static void main(String[] args) {

int na;
ArregloAlumnos oa=new ArregloAlumnos();
System.out.print("Numero de alumnos: ");
na=PromedioAlumnos.datoInt();
for(int i=0;i<na;i++)
oa.ingresar();
oa.visualizar();

}
}

EJERCICIO

1. Generar una lista de teléfonos. La lista debe ser un objeto que encapsula la matriz de
objetos persona, la clase CPersona define los atributos privados nombre, dirección,
teléfono relativos a una persona, métodos respectivos que en un menú de opciones
permita: añadir, eliminar y buscar en una lista.

13
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 4: Agregación

Dadas la clase Banco, con los atributos nombre, dirección, lista de clientes; y los
métodos para asignar y mostrar los atributos respectivos. La clase Clientes con los
atributos nombre, dni, fecha de nacimiento, los métodos para asignar y mostrar atributos
de la clase. Permitir añadir clientes a la clase Banco, considerando que un cliente puede
serlo de un banco o más de un banco; además si un objeto banco deja de existir, los
clientes persisten.
Mostrar los clientes asignados.

import java.util.GregorianCalendar;
public class Cliente {
String nombre=null;
String dni=null;
GregorianCalendar fechaNacimiento=null;
public Cliente(String nom, String doc_i, GregorianCalendar fn){
nombre=nom;
dni=doc_i;
fechaNacimiento=fn;
}
public String getNombre(){
return nombre;
}
public void setNombre(String nombre){
this.nombre=nombre;
}
public String getDni(){
return dni;
}
public void setDni(String dni){
this.dni=dni;
}
public GregorianCalendar getFechaNacimiento(){
return fechaNacimiento;
}
public void setFechaNacimiento(GregorianCalendar fechaNacimiento){
this.fechaNacimiento=fechaNacimiento;
}
@Override
public String toString(){
return this.getNombre()+"\t"+this.getDni()
+"\t"+this.getFechaNacimiento().getTime();
}
}

14
import java.util.ArrayList;
public class Banco {
String nombre=null;
String direccion=null;
ArrayList<Cliente> clientes= null;//Objeto clientes del tipo Cliente
// ArrayList: clase que contendra
// lista de objetos Cliente
public Banco(String nom, String direc){
nombre=nom;
direccion=direc;
this.clientes=new ArrayList<Cliente>();
}
public String getNombre(){
return nombre;
}
public void setNombre(String nombre){
this.nombre=nombre;
}
public void agregarCliente(Cliente cliente){
this.clientes.add(cliente);
}
public ArrayList<Cliente> ObtenerClientes(){
return this.clientes;
}
}

import java.util.GregorianCalendar;
import java.util.Iterator;
public class Prueba {

public static void main(String[] args) {

Banco banco1=new Banco("HSBC", "China");
Banco banco2=new Banco("Credito", "Peru");
Cliente clie1=new Cliente("Miguel","01020304",new GregorianCalendar(1970,3,6));
Cliente clie2=new Cliente("Rosa","11020304",new GregorianCalendar(1980,7,16));
Cliente clie3=new Cliente("sergio","07020304",new GregorianCalendar(1990,2,1));

//Agregando clientes al Banco

banco1.agregarCliente(clie1);
banco1.agregarCliente(clie2);
banco2.agregarCliente(clie1);
banco2.agregarCliente(clie3);

//Imprimir los clientes

System.out.println("Banco: "+banco1.getNombre());
Iterator it=banco1.ObtenerClientes().iterator();
while(it.hasNext()){ // seguidamente uno/otro del mismo iterador(it)
Cliente obj= (Cliente) it.next();
System.out.println(obj.toString());

15
 }

System.out.println("Banco: "+banco2.getNombre());
it=banco2.ObtenerClientes().iterator();
while(it.hasNext()){ // seguidamente uno/otro del mismo iterador(it)
Cliente obj= (Cliente) it.next();
System.out.println(obj.toString());
}
}
}

16
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 6: Generalización y Especialización (Herencia – Ejemplo 1)

Sea la clase CalculadoraBase una clase base con los métodos suma y resta para dos
números enteros y reales, además la clase Calculadora1 subclase o clase derivada que
hereda los métodos de CalculadoraBase. Calculadora1 implementa los métodos
factorial y esPrimo. Considerar métodos sobrecargados.
Para una instancia de la clase Calculadora1, hallar la suma dados dos números enteros,
la resta, factorial de cada uno de ellos, y decir si cada uno de los números dados es
primo o no.

CalculadoraBase

public int suma(int n1, int n2)

public float suma(float n1, float n2)
public int resta(int n1, int n2)
public float resta(float n1, float n2)

Calculadora1

public int factorial(int n)

public long factorial(long n)
public boolean esPrimo(int n)
public boolean esPrimo(long n)

public class CalculadoraBase {

public int suma(int n1,int n2){
int rpta=n1+n2;
return rpta;
}
public float suma(float n1,float n2){
float rpta=n1+n2;
return rpta;
}
public int resta(int n1,int n2){

17
 int rpta=n1-n2;
return rpta;
}
public float resta(float n1,float n2){
float rpta=n1-n2;
return rpta;
}
}

public class Calculadora1 extends CalculadoraBase {

public int factorial(int n){
int f=1;
while(n>1){
f=f*n;n=n-1;
}
return f;
}
public long factorial(long n){
long f=1;
while(n>1){
f=f*n--;
}
return f;
}
public boolean esPrimo(int n){
boolean primo=true;
int k=1;
while(++k<n){
if(n%k==0){
primo=false;
break;
}
}
return primo;
}
public boolean esPrimo(long n){
boolean primo=true;
int k=1;
while(++k<n){
if(n%k==0){
primo=false;
break;
}
}
return primo;
}
}

18
public class Pruebacalculadora {

public static void main(String[] args) {

int n1=7, n2=12;
boolean r;
Calculadora1 obj=new Calculadora1();
int suma=obj.suma(n1,n2);
int resta=obj.resta(n1,n2);
int f1=obj.factorial(n1);
int f2=obj.factorial(n2);

System.out.println("La suma es:"+suma);

System.out.println("La resta es:"+resta);
System.out.println("Factorial de: "+n1+" es :"+f1);
System.out.println("Factorial de: "+n2+" es :"+f2);
r=obj.esPrimo(n1);
if(r==true)
System.out.println(n1+" es primo");
else
System.out.println(n1+" no es primo");
r=obj.esPrimo(n2);
if(r==true)
System.out.println(n2+" es primo");
else
System.out.println(n2+" no es primo");
}

19
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 6: Herencia (Ejemplo 2)

EmpleadoPorComision
nombre
ventasBrutas
tarifaporComision

EmpleadoBaseMasComision
salarioBase

public class EmpleadoPorComision {

protected String nombre;
protected double ventasBrutas;
protected double tarifaporComision;

public EmpleadoPorComision(String nom,double ventas, double tarifa){

nombre=nom;
ventasBrutas=ventas;
tarifaporComision=tarifa;
}
protected String obtenerNombre(){
return nombre;

}
protected double obtenerVentasBrutas(){
return ventasBrutas;
}
protected double obtenerTarifaPorComision(){
return tarifaporComision;
}
}

public class EmpleadoBaseMasComision extends EmpleadoPorComision {

private double salariobase;
public EmpleadoBaseMasComision(String nombre, double ventas, double tarifa,
double salario){
super(nombre, ventas, tarifa);

20
 salariobase=salario;
}
public double obtenerSalarioBase(){
return salariobase;
}
}

public class PruebaEmpleadoBaseMasComision {

public static void main(String[] args) {
EmpleadoBaseMasComision empleado=new EmpleadoBaseMasComision("Denisse
Fajardo",1000,3,500);
System.out.println("\n Informacion del empleaco: \n");
System.out.println("\n Nombre: "+empleado.obtenerNombre());
System.out.println("\n Ventas brutas: "+empleado.obtenerVentasBrutas());
System.out.println("\n Tarifa por comision:
"+empleado.obtenerTarifaPorComision());
System.out.println("\n Salario base: "+empleado.obtenerSalarioBase()); }
}

21
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 7: Clase abstracta

Dada la clase Figura con atributos: x, y, referente a un punto, y, las clases Círculo,
Rectángulo, hallar la figura de mayor área, independiente de su forma, y los valores de
sus parámetros.
Crear un arreglo de la clase figura para cuatro elementos, y guardar en sus elementos los
valores devueltos por new al crear objetos de las clases derivadas.

Figura
int x iFigura
int y
main()
abstract double area()
figuraMayor()

Rectangulo
Circulo
double largo
double radio
double ancho
double area()
double area()

public abstract class Figura {

protected int x,y;
public Figura(int x,int y){
this.x=x;
this.y=y;
}
public abstract double area();
}

public class Circulo extends Figura{

protected double radio;
public Circulo(int x, int y, double radio){
super(x,y);
this.radio=radio;
}
public double area(){
return Math.PI*radio*radio;
}
}

22
public class Rectangulo extends Figura{
protected double largo,ancho;
public Rectangulo(int x,int y, double largo, double ancho){
super(x,y);
this.largo=largo;
this.ancho=ancho;
}
public double area(){
return largo*ancho;
}
}

public class iFigura {

public static void main(String[] args) {
Figura[] fig=new Figura[4];
fig[0]=new Circulo(0,0,5.0);
fig[1]=new Circulo(0,0,7.0);
fig[2]=new Rectangulo(0,0,5.0,7.0);
fig[3]=new Rectangulo(0,0,4.0,6.0);
Figura fMayor=figuraMayor(fig,4);
System.out.println("\n La figura de mayor area es: "+fMayor.area());
}
public static Figura figuraMayor(Figura fig[],int n){
Figura mFigura=null;
double areaMayor=0.0;
for(int i=0;i<n;i++){
if(fig[i].area()>areaMayor){
areaMayor=fig[i].area();
mFigura=fig[i];
}
}
return mFigura;
}
}

23
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 8: Polimorfismo
Dada una clase base Empleado, y sus clases derivadas: EmpleadoPorComision,
EmpleadopoHoras, donde cada subclase proporciona implementación del método:
calcularPago().
EmpleadoPorHora, calcula multiplicando las horas trabajadas por el precio por hora.
EmpleadoPorComision, se calcula, con un salario base más un bono por cada unidad
vendida.
Cada subclase agrega algunos métodos propios.

public abstract class Empleado {

private String nombre;
private String apellido;
private double salario;

public Empleado(String nombre, String apellido, double salario){

this.nombre=nombre;
this.apellido=apellido;
this.salario=salario;
}
public double getSalario(){
return salario;
}
public String getNombre(){
return nombre;
}
public String getApellido(){
return apellido;
}
public abstract double calcularPago();
public void imprimirRecibo(){
System.out.println("Pago: "+apellido+", "+nombre+" S/."+calcularPago());
}
}

public class EmpleadoPorComision extends Empleado{

private double comision; // bono por unidad vendida
private int unidades; // # de unidades vendidas

public EmpleadoPorComision(String nombre, String apellido, double salario, double

comision){
super(nombre,apellido,salario);
this.comision=comision;
}
public void sumarventas(int unidades){

24
 //this.unidades=unidades;
this.unidades=this.unidades+unidades;
}
public int getVentas(){
return unidades;
}
public double calcularPago(){
return getSalario()+(comision*unidades);
}
}

public class EmpleadoPorHoras extends Empleado{

private int horas; // # de horas trabajadas
public EmpleadoPorHoras(String nombre, String apellido, double salario){
super(nombre,apellido,salario);
}
public void sumarHoras(int horas){
this.horas=this.horas+horas;
}
public int getHoras(){
return horas;
}
public double calcularPago(){
return getSalario()*horas;
}
}

public class Nomina {

private int horas_totales;
private int ventas_totales;
private double pago_total;
public void registrarInfoEmpleado(EmpleadoPorComision emp){
ventas_totales=ventas_totales+emp.getVentas();
}
public void registrarInfoEmpleado(EmpleadoPorHoras emp){
horas_totales=horas_totales+emp.getHoras();
}
public void pagarEmpleados(Empleado[] emps){
for(int i=0;i<emps.length;i++){
Empleado emp=emps[i];
pago_total=pago_total+emp.calcularPago();
emp.imprimirRecibo();
}
}
}

public class ControladorNomina {

public static void main(String[] args) {

25
 // Crear un sistema de nomina
Nomina nomina=new Nomina();

// Crear y actualizar algunos empleados

EmpleadoPorComision emp1=new EmpleadoPorComision("Urias","Sotelo",500.00,10);
EmpleadoPorComision emp2=new EmpleadoPorComision("Betsabe","Gamarra",400.00,5);
emp1.sumarventas(7);
emp2.sumarventas(5);
EmpleadoPorHoras emp3=new EmpleadoPorHoras("Joab","Grados",2.50);
EmpleadoPorHoras emp4=new EmpleadoPorHoras("Elvira","Romero",2.00);
emp3.sumarHoras(40);
emp4.sumarHoras(45);

// Utilizar metodos sobrecargados

nomina.registrarInfoEmpleado(emp1);
nomina.registrarInfoEmpleado(emp2);
nomina.registrarInfoEmpleado(emp3);
nomina.registrarInfoEmpleado(emp4);

// Juntar los empleados en un arreglo

Empleado[] emps=new Empleado[4];
emps[0]=emp1; emps[1]=emp2;
emps[2]=emp3; emps[3]=emp4;
nomina.pagarEmpleados(emps);
}
}

Al considerar el método pagarEmpleados(Empleado[] emps), es un ejemplo de

polimorfismo de inclusión, el método funciona para cualquier empleado: por comisión,
o, empleado por horas.

Los métodos:
registrarInfoEmpleado(EmpleadoPorComision emp)
registrarInfoEmpleado(EmpleadoPorHoras emp)

son ejemplos de sobrecarga o polimorfismo ad-hoc.

**********************************************************
EJERCICIO

Polimorfismo – Clase abstracta – Intefaz

Dada un clase Banco que define una matriz de referencias a objetos de tipo cuenta bancaria
(clase Cuenta). Cuenta una clase abstracta con los atributos: nombre, cuenta, saldo, tipo de
interés; y los métodos: estado, que devuelve el saldo de la cuenta, comisiones, método abstracto
sin parámetros que será redefinido en las subclases, que incluye a dos clases derivadas:
CCuentaAhorro con el atributo cuota de mantenimiento; y la clase CCuentaCorriente con los

26
atributos: transacciones, importe por transacciones, transacciones exentas; y, a la vez
CCuentaCorriente es clase base de CCuentaCorrienteConIn (Cuenta corriente con
intereses).
En una clase Test definir un menú de opciones que permita:

1. Saldo
2. Buscar siguiente
3. Ingreso
4. Reintegro // Ingreso
5. Añadir
6. Eliminar
7. Mantenimiento
8. Salir
Seleccione opción:

27
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 8: Clases Genéricas

Clases con variables o parámetros que representan tipos.

Por ejemplo, dada una clase genérica Par que permita establecer un tipo T, para manejar enteros
y caracteres, y luego a través de un método intercambiar los valores, para luego presentar
intercambiado los valores en el programa principal.

public class Par <T>{

private T a, b;
public Par(T a, T b){
this.a = a;
this.b = b;
}
public void setA(T a){this.a=a;}
public T getA(){return a;}
public void setB(T b){this.b=b;}
public T getB(){return b;}
public Par<T> swap(){
return new Par<T>(b, a);
}
}

import java.io.*;
import javax.swing.JOptionPane;
public class Prueba {

public static void main(String[] args) {

int n1,n2;
char ca=' ',cb=' ';
System.out.println("Numeros para intercambiar usando clase generica");
n1=Integer.parseInt(JOptionPane.showInputDialog("Primer numero:"));
n2=Integer.parseInt(JOptionPane.showInputDialog("Segundo numero:"));

// Instanciación de la clase genérica para Integer(Enteros)

// No se puede usar int porque no es una clase
Par<Integer> p = new Par<Integer>(n1,n2);
System.out.println("Par de enteros, antes del cambio: n1="+p.getA()+" n2="+p.getB());
p = p.swap();
System.out.println("Par de enteros, despues del cambio: n1="+p.getA()+" n2="+p.getB());

System.out.println("Caracteres para intercambiar usando clase generica");

InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader flujoE=new BufferedReader(isr);
PrintStream flujoS=System.out;

28
 try{
flujoS.print("Primer caracter<letra>: ");
ca=(char)flujoE.read();
flujoE.readLine(); //Limpiar caracteres: \r\n
flujoS.print("Segundo caracter<letra>: ");
cb=(char)flujoE.read();
flujoE.readLine(); //Limpiar caracteres: \r\n
}
catch(IOException e){
System.out.println("Error:"+e.getMessage());
}

// Instanciación de la clase genérica para Character(Caracteres)

//Par<Character> p1 = new Par<Character>('a','b');
Par<Character> p1 = new Par<Character>(ca,cb);
System.out.println("Par de aracteres, antes del cambio: ca="+p1.getA()+" cb="+p1.getB());
p1=p1.swap();
System.out.println("Par de caracteres, despues del cambio: ca="+p1.getA()+" cb="+p1.getB());

}
}

Ejercicios:
1. Programa utilizando clase genérica, para hallar el menor, intermedio y mayor de tres
números enteros, a su vez de tres letras.
2. Programa utilizando clase genérica para ordenar cinco números y ordenar cinco
letras, ascendente y/o descendente.

29
 UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS
E.A.P. INGENIERIA DE SISTEMAS

ALGORITMICA II

PRACTICA 9: Excepciones tipo ArithmeticException e InputMismatchException

Dados dos números enteros , hallar el cociente de dichos números. De ocurrir algún error
aritmético, como por ejemplo división por cero, o, que las entradas no sean del mismo tipo es
decir no sean números los datos de entrada, se debe en ambos casos atrapar y manejar la
excepción, y permitir que el usuario ingrese los datos otra vez.

import java.util.InputMismatchException;
import java.util.Scanner;
public class DivEntreCeroConME {

public static int cociente(int numerador, int denominador) throws ArithmeticException,

InputMismatchException
{
return numerador/denominador;
}

public static void main(String[] args) {

Scanner numero=new Scanner(System.in);
boolean continuar=true;
do{
try{
System.out.println("Dos enteros para hallar cociente");
System.out.print("Numerador entero: ");
int numerador=numero.nextInt();
System.out.print("Denominador entero: ");
int denominador=numero.nextInt();
int resultado=cociente(numerador,denominador);
System.out.printf("\n Cociente: %d/%d = %d\n",numerador,denominador,resultado);
continuar=false;
}
catch(ArithmeticException arithmeticException){
System.err.printf("\n Excepcion: %s\n", arithmeticException);
System.out.println("Cero es un denominador invalido. Intente de nuevo");
}
catch(InputMismatchException inputMismatchException){
System.err.printf("\n Excepcion: %s\n",inputMismatchException);
numero.nextLine();//descartar entrada para ingresar de nuevo
System.out.println("Debe ingresar enteros. Intente de nuevo\n");
}
}while(continuar);
}
}

30
Excepciones propias – Ejemplo

Se conoce la longitud de los tres lados enteros de un triángulo, el área puede calcularse
de la siguiente manera:

area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
donde: s=(a+b+c)/2

En un programa elabore un método para calcular y devolver el área; permita que lance
una excepción cuando las tres longitudes no puedan formar un triángulo. Desarrolle un
método invocador que atrape la excepción.

import java.util.InputMismatchException;
import java.util.Scanner;
class Cuando3LnofT extends Exception{}
public class ExcepcionCuando3LnofT {
public static double area(double l1,double l2, double l3) throws Exception,
InputMismatchException{
double s,carea;
if(l1<l2+l3 && l2<l1+l3 && l3<l1+l2){
s=(l1+l2+l3)/2;
carea=Math.sqrt(s*(s-l1)*(s-l2)*(s-l3));
return carea;
}
else
throw new Cuando3LnofT();
}
public static void main(String[] args) throws Exception{
Scanner lado=new Scanner(System.in);
double resultado=0;
try{
System.out.println("Tres lados enteros de un triangulo para hallar area:");
System.out.println("\n 1er lado: ");
double lado1=lado.nextDouble();
System.out.println("\n 2do lado: ");
double lado2=lado.nextDouble();
System.out.println("\n 3er lado: ");
double lado3=lado.nextDouble();
resultado = area(lado1, lado2, lado3);
System.out.println("El area es:"+resultado);
}
catch(Cuando3LnofT e){
System.err.println("ERROR: los tres lados no forman un triangulo");
}
catch(InputMismatchException inputMismatchException){
System.err.printf("\n Excepcion: %s\n",inputMismatchException);
System.out.println("Debe ingresar numeros enteros. Intente de nuevo\n");
}
}
}

31
Ejercicios:

1. Programa que permita el ingreso de una cadena mediante un campo de texto,

representando una fecha de la forma DD/MM/AA (Ej. xx/yy/zz). Usar la clase
StringTokenizer para dividirla y producir un mensaje de error si un elemento no es
numérico, si no se encuentra o si se especifica una fecha no correcta. Considerar los
años bisiestos.

2. Usar herencia para crear una superclase de excepción (lamada ExcepcionA) y las
subclases de excepción ExcepcionB y ExcepcionC, en donde ExcepcionB hereda de
ExcepcionA y ExcepcionC hereda de ExcepcionB. Programa para demostrar que el
bloque catch para el tipo ExcepcionA atrapa excepciones de los tipos ExcepcionB y
ExcepcionC.

32
PRACTICA 10: Interfaz Gráfica de Usuario (Graphical User Interface - GUI)

Ejemplo:
Vaca, cerdo son animales que tienen peso y no hablan pero si dicen algo o rumian es el
caso de la vaca (muu), o gruñe, caso del cerdo (oinc). Crear una instancia de vaca por
ejemplo daisy, una instancia de cerdo por ejemplo porky. Usando polimorfismo
redefinir un método para que al seleccionar un animal de los indicados se diga algo de
uno de ellos

package paquete1;
public abstract class Animal {
public abstract String dice();
}

package paquete1;
public class Vaca {
public String dice(){
return "Vaca dice: Muu";
}
}

import paquete1.Vaca;

public class polimorfismouGUI extends javax.swing.JFrame {

33
 public polimorfismouGUI() {
initComponents();
}

private void jComboBox1ItemStateChanged(java.awt.event.ItemEvent evt) {

// Obtener el index del item seleccionado
int orden=jComboBox1.getSelectedIndex();
switch(orden){
case 1: Vaca daisy=new Vaca();
jLabeldice.setText(daisy.dice());
break;
case 2: break;
}
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// Seleccionar el item de index 0 del combobox
jComboBox1.setSelectedIndex(0);

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new polimorfismouGUI().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JComboBox jComboBox1;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabeldice;
// End of variables declaration

**********************************************************************

Construir una clase llamada Luz que simule una luz de semáforo. El atributo color de la
clase debe cambiar de Verde a Amarillo y a Rojo y de nuevo regresar a Verde mediante
la función Cambio. Cuando se crea un objeto Luz, su color inicial será Rojo.

import java.io.*;
public class cLuz {

34
 //Atributo
String color;

//Métodos
cLuz(){
color="Rojo";
}
public void Cambio(){
color="Verde";
System.out.println(color);
color="Amarillo";
System.out.println(color);
color="Rojo";
System.out.println(color);
}
public static void main(String[] args) {
char rpta='s';
cLuz oLuz=new cLuz();
while(rpta=='s'){
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader flujoE=new BufferedReader(isr);
PrintStream flujoS=System.out;
try{
oLuz.Cambio();
flujoS.print("Desea continuar<s/n>: ");
rpta=(char)flujoE.read();
}
catch(IOException e){
System.out.println("Error:"+e.getMessage());
}
}
}
}

35
UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

FACULTAD DE INGENIERIA DE SISTEMAS

E.A.P INGENIERIA DE SISTEMAS

Guía Práctica de Algorítmica II

Pseudocódigo - Programas en Java

Figura
int x iFigura
int y
main()
abstract double area()
figuraMayor()

Rectangulo
Circulo
double largo
double radio
double ancho
double area()
double area()

Luis Guerra Grados

Lima, Marzo 2018

36
 INDICE

Pág.

1. Ejemplos de desarrollo. Pseudo código ………................................................ 1

2. Lectura de datos ………...……….………………………………………….. 5

3. Objetos, clases, métodos ……... .…………………………………………… 8

4. Arreglo de objetos …………………….………………………………………. 10

5. Agregación …………...……………………………………………………. 14

6. Generalización y Especialización …….…………………………….………. 17

7. Clase abstracta ………………………………………………………………. 22

8. Polimorfismo …………………..…………………………………….……… 24

9. Clases Genéricas ………………………………………………………….…. 28

10. Excepciones ……..……………………………………………………..…….. 30

11. GUI ……………...……………………………………………………..…….. 33

37
REFERENCIAS

1. Joyanes, Luis; Zahonero, Luis. Programación en C, C++, Java y UML. 2010.

Edit. Mc Graw Hill. México.

2. Deitel & Deitel. Java como programar. 2008. Edit. Pearson Prentice Hall.
México.

3. Francisco, Javier Ceballos. Java 2. Curso de Programación. 2000 . Edit. Alfa

Omega Ra-ma. España.

4. Douglas Bell, Mike Parr. Java para estudiantes. 2003. Edit. Pearson.

5. Jhon Zukowski. Java 2. 2003. Edit. Anaya Multimedia.

6. Marco Trejo Lemus. Comunidad Java México. http://www.comunidadjava.org/?

q=node/43. 17-6-2008.

7. García-Bermejo, José Rafael. Java SE6 & Swing. 2007. Edit. Pearson. España.

8. Coronel Castillo, Eric. Java y MySql. 2009. Editora Macro. Perú.

9. Vásquez Paragulla, Julio. Java SE for Windows with NetBeans IDE. 2008.
Lima.

10. Vera, Virginia. Guía de Prácticas – Pseudo código.

11. Fain, Yakov. Programación Java. 2011. Edit. Anaya. España.

38