GUIA DE TRABAJOS

PRACTICOS:
Fundamentos de Java
Estructura de Datos III

Autores:
Ing. Daniel Monferran
Lic. Oscar Malone
GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

GUIA DE TRABAJOS PRACTICOS (CON EJERCICIOS RESUELTOS)

ESTRUCTURA DE DATOS III

Fundamentos de JAVA

Autores: Ing. Daniel Monferrán – Lic. Oscar Malone

Ejercicio 1. Crear una clase pública de nombre “Numeros01” que sólo contenga al método
main(...) y que permita imprimir por pantalla los números del 1 al 6.

Ejercicio 2. Crear una clase pública de nombre “Numeros01” que sólo contenga al método
main(...) y que permita imprimir 12 veces la palabra “hola”. Nota: en el código fuente que usted
escriba debe figurar solamente una vez la palabra “hola”.

Ejercicio 3. Crear una clase pública de nombre “Numeros01” que sólo contenga al método
main(...) y que permita imprimir por pantalla los cuadrados de los 10 primeros números
naturales.

Ejercicio 4. Crear una clase pública de nombre “Codigos01” que sólo contenga al método
main(...) y que permita cargar el código de un producto (Ej.: 124), tal como se puede apreciar
en el ejemplo, el código del producto debe ser numérico, razón por la cual se debe verificar que
el código contenga sólo números.

Como ayuda se recuerda que existen los métodos:

isDigit(char c), substring(int inicio, int fin)

Ejercicio 5. Crear una clase pública de nombre “Codigos02” que sólo contenga al método
main(...) y que permita cargar el código de un producto (Ej.: Sae12al), tal como se puede
apreciar en el ejemplo, el código del producto debe ser alfanumérico, razón por la cual se debe
verificar que el código ingresado comience con al menos una letra y que contenga al menos un
número.

Como ayuda se recuerda que existen los métodos:

length(), isLetter(char c), isDigit(char c), substring(int inicio, int fin)

Ejercicio 6. Crear una clase pública de nombre “Codigos02” que sólo contenga al método
main(...) y que permita crear “n” códigos de productos (Ej.: Cod121, Cod203,...), donde el
código del producto se genera de la siguiente manera:

La cadena “Cod” se concatena con números aleatorios que el sistema generará.

Sólo se espera que el código se muestre por consola en la medida en que se crea mediante un
bucle.

Como ayuda se recuerda que existen los métodos: Random(), nextInt()

Ejercicio 7. Crear una clase pública de nombre “Inicio” que sólo contenga al método
main(...) y al menos una segunda clase de nombre “Numeros” que permita realizar operaciones
sobre dos números. La misma debe tener dos atributos que son los números enteros con los
que se va a operar. Debe disponer de un único constructor que reciba ambos atributos y cinco
métodos, que son las operaciones que la clase podrá realizar.

Ing. Daniel Monferran – Lic. Oscar Malone Página 1

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

Dichos métodos serán: obtenerSuma(), obtenerResta(), obtenerProducto(), obtenerCociente(),

obtenerModulo()

Sugerencia: Esta es una buena oportunidad para plantearse cuales elementos de la clase
deben considerarse públicos, cuales privados y porqué.

Ejercicio 8. Crear una clase pública de nombre “Inicio” que sólo contenga al método
main(...) y al menos una segunda clase de nombre “Personal” con los atributos “nombre, legajo
(alfanumérico), documento de identidad y fecha de nacimiento (cadena de texto).

En la clase “Inicio” se crearán tres objetos de la clase “Personal” recurriendo para ello al
constructor ordinario (sin parámetros) y se invocarán los métodos “set...” y “get...” para poder
acceder a los atributos, modificarlos y ver el nuevo estado del objeto.

Sugerencia: Esta es una buena oportunidad para plantearse cuales elementos de la clase
deben considerarse públicos, cuales privados y porqué.

Es también importante prever que reciben y que devuelven los métodos que se definan,
recuerde que un método puede devolver un objeto.

Ejercicio 9. Crear una clase pública de nombre “Inicio” que sólo contenga al método
main(...) y al menos una segunda clase “Punto01” con los atributos “coordenadas y
coordenadaY” (siendo todos números reales).

En la clase “Inicio” se crearán tres objetos de la clase “Punto01” recurriendo para ello al
constructor parametrizado y se invocarán los métodos “... sumarPuntos (...), ... restarPuntos(...),
mostrarPunto()”, siento todos estos, métodos de la clase “Punto01”

Sugerencia: Esta es una buena oportunidad para plantearse cuáles elementos de la clase
deben considerarse públicos, cuales privados y porqué.

Es también importante prever que reciben y que devuelven los métodos que se definan,
recuerde que un método puede devolver un objeto.

Ejercicio 10. Diseñe e implemente al menos una clase para trabajar con triángulos
equiláteros. Proporcione métodos de consulta, métodos para calcular el perímetro y el área de
un triángulo.

Nota: Los datos de lados de cada triángulo se proporcionan por el teclado

Implemente un método que a partir de un vector de triángulos devuelva el área del triángulo de
mayor superficie.

Ejercicio 11. Diseñe e implemente al menos una clase de nombre “Cafetera” con las
siguientes características.

Atributos:
capacidadMaxima (la cantidad máxima de café que puede contener la cafetera)
cantidadActual (la cantidad actual de café que hay en la cafetera).

Constructor:
Defina la capacidad máxima y la cantidad actual de café en la cafetera que se acaba de crear.
Nota: Se debe verificar que la cantidad actual incorporada no supere la cantidad máxima.

Ing. Daniel Monferran – Lic. Oscar Malone Página 2

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

Métodos:
llenarCafetera(): pues eso, hace que la cantidad actual sea igual a la capacidad.
servirTaza(int): simula la acción de servir una taza con la capacidad indicada.
Nota: Si la cantidad actual de café “no alcanza” para llenar la taza, se sirve lo que quede.
vaciarCafetera(): pone la cantidad de café actual en cero.
agregarCafe(int): añade a la cafetera la cantidad de café indicada

Ejercicio 12. Diseñe e implemente al menos una clase de nombre “Vehículo” con el
siguiente objetivo:

Que el programa sea capaz de incorporar por teclado los datos de “n” vehículos (con “n” a
definir antes de crear los vehículos) y los liste a continuación por pantalla.

La idea es simular el control de un Ferry recurriendo para ello a la creación de la clase

Vehículo. Incluya aspectos comunes a todos los vehículos como número de pasajeros,
presencia o ausencia de tripulación, número de ruedas, fecha de matriculación, medio por el
que se desplaza, etc. Incluya los métodos que considere oportunos.

Herencia

Ejercicio 13. A partir de la clase anterior (ejercicio 12), y mediante herencia cree nuevas
clases que permitan diferenciar si el objeto es un coche, una moto, un camión, una bicicleta,
una lancha. Incluya en cada clase algún atributo específico que la diferencie de las demás. Por
ejemplo, para el coche un booleano que determine si es de tres o cinco puertas, para el camión
la altura (indiferente en los otros vehículos), etc. Realice un programa como el del ejercicio
anterior capaz de trabajar con los distintos tipos de vehículos.

Ejercicio 14. Diseñe e implemente una clase abstracta “Figura” , a partir de esta clase y
mediante herencia cree otras dos clases llamadas “Triangulo” y “Cuadrado”. Proporcione
métodos de consulta, métodos para calcular el perímetro y el área del triángulo y el cuadrado.

Polimorfismo

Ejercicio 15. Crear una clase pública de nombre “Inicio” que sólo contenga al método
main(...) e incluya en esta clase la creación de un vector de figuras. A partir de las clases del
ejercicio anterior (ejercicio 14) y mediante el concepto de polimorfismo utilice le vector de
figuras para acceder a cada una de ellas, modificar sus atributos y visualizar por pantalla los
atributos de cada figura.

Ejercicio 16. Diseñe e implemente una clase abstracta “Instrumento” , a partir de esta clase
y mediante herencia cree otras dos clases llamadas “Piano” y “Guitarra”. Proporcione métodos
de consulta que permitan conocer atributos característicos de cada instrumento (Ej.
VeoInstrumento() ). Cree una clase pública de nombre “Inicio” que sólo contenga al método
main(...) e incluya en esta clase la creación de un vector “Instrumento”. Mediante el concepto

Ing. Daniel Monferran – Lic. Oscar Malone Página 3

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

de polimorfismo utilice le vector de instrumentos para acceder a cada una de ellos, modificar
sus atributos y visualizar por pantalla los atributos de cada instrumento.

/-----------------------------------------------------------------------------

Ejemplo de polimorfismo aplicado a figuras2D:

public class mainFigurasGenericas{

public static void main(String [] args){

Figura2D miFiguraTriangulo = new Triangulo();

Figura2D miFiguraRectangulo = new Rectangulo();

Figura2D [] vectorFiguras = new Figura2D[2];

System.out.println("Se creo el vector de referencias a Figuras \n");

vectorFiguras[0] = new Triangulo(2.00d,2.00d);

vectorFiguras[1] = new Rectangulo(2.00d,2.00d);

System.out.println("Area del Triangulo :" + vectorFiguras[0].getArea());

System.out.println("Area del Rectangulo :" + vectorFiguras[1].getArea());

System.out.println("Lado1 del Rectangulo :" +

((Rectangulo)vectorFiguras[1]).getLado1());

public class Figura2D{

protected double [] magnitud = new double[2];

Figura2D(){
setFigura(0.0d, 0.0d);
System.out.println("Me llamaron ?? dice Figura2D\n");
}

Figura2D(double mg1, double mg2){

setFigura(mg1, mg2);
System.out.println("Me llamaron ?? dice Figura2D\n");

public void setFigura(double mg1, double mg2){

magnitud[0] = mg1;
magnitud[1] = mg2;
}

public double getArea(){

return 0.00;
}

}
public class Rectangulo extends Figura2D{

Rectangulo(){
super();

Ing. Daniel Monferran – Lic. Oscar Malone Página 4

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

System.out.println("Me llamaron ?? dice Rectangulo\n");

Rectangulo(double lado1, double lado2){

super(lado1, lado2);
System.out.println("Me llamaron ?? dice Rectangulo\n");

public double getLado1(){

return magnitud[0];
}

//public double getArea(){

// return magnitud[0]*magnitud[1];
//}

public class Triangulo extends Figura2D{

Triangulo(){
super(0.0d, 0.0d);
System.out.println("Me llamaron ?? dice Triangulo\n");

Triangulo(double baseT, double alturaT){

super(baseT, alturaT);
System.out.println("Me llamaron ?? dice Triangulo\n");
}

public double getArea(){

return magnitud[0]*magnitud[1]/2;
}

//----------------------------------------------------------------------------

Interfaces

Ejercicio 17. Construir una clase “ArrayReales” que declare un atributo de tipo double[] y
que implemente una interfaz llamada “Estadisticas”. El contenido de esta interfaz es el
siguiente:

public interface Estadisticas {

double minimo();
double maximo();
double sumatorio();
}

//-------------------------------------------------------------------

Ing. Daniel Monferran – Lic. Oscar Malone Página 5

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

En este ejemplo se debe implementar la clase main(...) que invoque a un objeto de la clase
‘ArrayReales ’

/**
* Clase ArrayReales
*
* Aquí se ve como la interfaz oblige la implementación de los métodos declarados en ella
*/

public class ArrayReales implements Estadisticas {

double [] valor;
public void asignar() {
for (int i=0; i<valor.length; i++) {
valor[i] = Math.random();
}
}
public double minimo() {
double menor = valor[0];
for (int i=0; i<valor.length; i++) {
if (menor>valor[i]) { menor=valor[i]; }
}
return menor;
}
public double maximo() {
double mayor = valor[0];
for (int i=0; i<valor.length; i++) {
if (mayor<valor[i]) { mayor=valor[i]; }
}
return mayor;
}
public double sumatorio() {
double suma =0.0;
for (int i=0; i<valor.length; i++) {
suma+=valor[i];
}
return suma;
}
public void imprimir() {
for (int i=0; i<valor.length; i++) {
System.out.println("x["+i+"]="+valor[i]);
}
}
}

Ejemplo de uso de la clase ArrayReales:

/**
* Programa PruebaArrayReales
*/
public class PruebaArrayReales {
public static void main (String [] args) {
ArrayReales x = new ArrayReales();
x.valor = new double[5];
x.asignar();
x.imprimir();
System.out.println("Minimo : " + x.minimo());
System.out.println("Maximo : " + x.maximo());
System.out.println("Sumatorio: " + x.sumatorio());
}
}

Ejemplo de salida por pantalla de la ejecución del código anterior:

x[0]=0.6257870038198547
x[1]=0.6362298582780569

Ing. Daniel Monferran – Lic. Oscar Malone Página 6

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

x[2]=0.1032244210543346
x[3]=0.7885078556272651
x[4]=0.3466167914826589

Minimo : 0.1032244210543346
Maximo : 0.7885078556272651
Sumatorio: 2.5003659302621704

//-------------------------------------------------------------------

Ejercicio 18. Construir una clase final Math3 que amplíe las declaraciones de métodos
estáticos de la clase Math y que implemente una interfaz llamada Extremos compilada con el
siguiente código fuente:

public interface Extremos {

int min(int [] a);
int max(int [] a);
double min(double [] a);
double max(double [] a);
}

Ejercicio 19. Construir una interfaz Relaciones (y posteriormente una clase que la
implemente) que incluya los siguientes métodos:

// Devuelve verdadero si a es mayor que b

boolean esMayor(Object b) ;
// Devuelve verdadero si a es menor que b
boolean esMenor(Object b) ;
// Devuelve verdadero si a es igual que b
boolean esIgual(Object b) ;

Ejercicio 20.

Lo que se pide es que, basados en el ejemplo que a continuación se entrega como soporte o
ayuda, se realice lo siguiente
1.- cree una clase que implemente los métodos para leer y escribir en un archivo.
2.- cree un objeto de esa clase para implementar los métodos de escritura y lectura.

//-------------------------------------------------------------------
En este ejemplo se implementa en el mismo main(.......) la escritura en fichero a los efectos de
reducir las líneas de código.

import java.io.*;

public class EscribeFichero {

public static void main(String [] args){

final int TAMANIO_BUFFER = 64;
byte buffer[] = new byte[TAMANIO_BUFFER];
int numBytes;

Ing. Daniel Monferran – Lic. Oscar Malone Página 7

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

try{
FileOutputStream FicheroDestino = new FileOutputStream("Salida.txt");

try{

do{

numBytes = System.in.read(buffer);
FicheroDestino.write(buffer,0,numBytes);

}while (buffer[0] != 32);

FicheroDestino.close();

}catch(IOException e){
System.out.print("Error de Escritura");
}
}catch (FileNotFoundException e){
System.out.print("Error fichero no encontrado");
}

}
}

//-------------------

import java.io.*;

public class LeeFichero {

public static void main(String[] argumentos) {

final int TAMANIO_BUFFER = 64;
byte buffer[] = new byte[TAMANIO_BUFFER];
int NumBytes;

try {
FileInputStream FicheroOrigen = new FileInputStream("Salida.txt");

try {
do {
NumBytes = FicheroOrigen.read(buffer);
System.out.print(new String(buffer,0,NumBytes));
} while (NumBytes == TAMANIO_BUFFER);
FicheroOrigen.close();
} catch (IOException e){
System.out.println("Error leyendo los datos o cerrando el fichero");
}

} catch (FileNotFoundException e) {
System.out.println("Fichero no encontrado");
}

Ing. Daniel Monferran – Lic. Oscar Malone Página 8

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

//---------------------------------------------------------------------

En este otro ejemplo se utilizan otras clases para el acceso a archivo

import java.io.*;
import java.util.*;

public class EscrituraArchivo

{
public static void main(String []Args)
{
FileWriter arch;
BufferedWriter buf=null;
String str,str1,str2;
StringTokenizer stk;

try
{
arch=new FileWriter("Prueba.txt",true);
buf=new BufferedWriter(arch);
buf.write("hola");
buf.write("hola");
buf.newLine();

}
catch(Exception e)
{
System.out.println(e);
}
try
{
if (buf!=null)
buf.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}

import java.io.*;
import java.util.*;

public class LecturaArchivo

{
public static void main(String []Args)
{
FileReader arch;
BufferedReader buf=null;
String str;
StringTokenizer stk;

try
{
arch=new FileReader("Prueba.txt");

Ing. Daniel Monferran – Lic. Oscar Malone Página 9

GUIA DE TRABAJOS PRACTICOS: Fundamentos de Java

buf=new BufferedReader(arch);
while((str=buf.readLine())!=null)
{
stk=new StringTokenizer(str);
System.out.println(stk.nextElement());
System.out.println(stk.nextElement());
}
}
catch(Exception e)
{
System.out.println(e);
}
try
{
if (buf!=null)
buf.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}

//-------------------------------------------------------------------

Ing. Daniel Monferran – Lic. Oscar Malone Página 10