Java

EJERCICIO DE JAVA RESUELTO

1. Escribir una clase llamada Pila, en el fichero Pila.java, que implemente las
estructuras de datos y métodos necesarios para manejar una estructura LIFO
(una pila) de números enteros, cuya capacidad puede definir el usuario.
Debe incluir los siguientes métodos: apilar(elem), desapilar(), verCima(),
vaciar(), estaLlena(), estaVacia() y mostrar().

Además se deben gestionar las excepciones causadas por encontrarse la pila

llena o vacía.
2. Escribir un programa Java orientado a objetos, llamado MainPila.java, que
realice las siguientes operaciones:
• Crear una pila de tamaño 10.
• Comprobar que está vacía.
• Apilar los números 23, -45, -12, 67, 1, 0, -43, 89.
• Desapilar tres elementos.
• Consultar la cima de la pila
• Apilar los números 564, -987, -10, 56, 1111.
• Comprobar que está llena.
• Mostrar su contenido.
• Apilar el número 666.

SOLUCIÓN
Empezamos declarando las dos clases que se utilizarán para gestionar las excepciones
que se lanzarán cuando la pila esté llena y cuando esté vacía, ambas heredan de la clase
Exception.

La clase PilaVaciaException tiene un único constructor que se encarga de llamar al

constructor de su superclase para que se gestione la excepción.

public class PilaVaciaException extends Exception

{
public PilaVaciaException ( )
{
super ( ) ;
}
}

1
 Java

La clase PilaLlenaException tiene un atributo que almacenará el valor del elemento

que provoca la excepción, un método para recuperar el valor del dato que almacena y el
constructor.

public class PilaLlenaException extends Exception

{
private int dato ;

public PilaLlenaException ( int d )

{
super ( ) ;
dato = d ;
}

public int getDato ( )

{
return dato ;
}
}

La clase Pila tiene 3 atributos: datos, que es un array para almacenar todos los
elementos de la pila; capacidad, para guardar el tamaño máximo de la estructura de
datos; indice, que indicará la posición en el array del siguiente elemento que hay que
guardar.

public class Pila

{
// ATRIBUTOS
private int capacidad ;
private int indice ;
private int[] datos ;

// CONSTRUCTORES
// Constructor sin parámetros que define un array de tamaño 10.
public Pila ( )
{
capacidad = 10 ;
indice = 0 ;
datos = new int [capacidad] ;
}

// Constructor que toma como parámetro el tamaño del array.

public Pila ( int cap )
{
capacidad = cap ;
indice = 0 ;
datos = new int [capacidad] ;
}

2
 Java

// MÉTODOS
// apilar(): apila un elemento en la pila.
// Si está llena, lanza la excepción PilaLlenaException.
public void apilar ( int elem ) throws PilaLlenaException
{
if ( !estaLlena() )
{
datos[indice++] = elem ;
}
else
{
throw new PilaLlenaException ( elem ) ;
}
}

// Desapilar(): desapila el elemento de la cima de la pila.

// Si está vacía, lanza la excepción PilaVaciaException.
public int desapilar ( ) throws PilaVaciaException
{
if ( !estaVacia() )
{
return datos[--indice] ;
}
else
{
throw new PilaVaciaException ( ) ;
}
}

// verCima(): consulta sin desapilar la cima de la pila.

public int verCima ( ) throws PilaVaciaException
{
if ( !estaVacia() )
{
return datos[indice-1] ;
}
else
{
throw new PilaVaciaException ( ) ;
}
}

// vaciar(): vacía la pila.

public void vaciar ( )
{
indice = 0 ;
}

// estaLlena(): devuelve true si la pila está llena.

public boolean estaLlena ( )
{
return ( indice == capacidad ) ;
}

// estaVacia(): devuelve true si la pila está vacía.

public boolean estaVacia ( )
{
return ( indice == 0 ) ;
}

3
 Java

// mostrar(): recorre la pila desde la base mostrando su contenido.

public void mostrar ( ) throws PilaVaciaException
{
if ( !estaVacia() )
{
for ( int i = 0 ; i < indice ; i++ )
{
System.out.println("Elemento en posicion "+i+": "+datos[i] );
}
}
else
{
throw new PilaVaciaException ( ) ;
}
}
}

La clase UsoDePila implementa el método main en el cual se va a hacer uso de la

estructura Pila antes descrita.

public class UsoDePila

{
public static void main ( String args[] )
{
int aux ;
Pila pila = new Pila ( 10 ) ;

if ( pila.estaVacia() )
{
System.out.println ( "\nLa pila esta vacia\n" ) ;
}

try
{
aux = 23 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = -45 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = -12 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 67 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 1 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 0 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = -43 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 89 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;

System.out.println ( ) ;

aux = pila.desapilar() ;
System.out.println ( "Desapilando elemento: " + aux ) ;
aux = pila.desapilar() ;
System.out.println ( "Desapilando elemento: " + aux ) ;
aux = pila.desapilar() ;
System.out.println ( "Desapilando elemento: " + aux ) ;

4
 Java

System.out.println ( "\nCima: " + pila.verCima() + "\n" ) ;

aux = 564 ; System.out.println ( "Apilando elemento: " + aux ) ;

pila.apilar ( aux ) ;
aux = -987; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = -10 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 56 ; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;
aux = 1111; System.out.println ( "Apilando elemento: " + aux ) ;
pila.apilar ( aux ) ;

if ( pila.estaLlena() )
{
System.out.println ( "\nLa pila esta llena\n" ) ;
}

System.out.println ( "Mostrando contenido de la pila..." ) ;

pila.mostrar() ;

System.out.println ( ) ;

aux = 666 ; System.out.println ( "Apilando elemento: " + aux ) ;

pila.apilar ( aux ) ;

System.out.println ( "Esta linea no se debe mostrar" ) ;

}
catch ( PilaLlenaException e )
{
System.out.println ( "Imposible apilar el elemento " +
e.getDato() + ". Pila llena" ) ;
}
catch ( PilaVaciaException e )
{
System.out.println ( "ERROR. Imposible desapilar. Pila vacia") ;
}
}
}

La salida resultante de la ejecución del código de la clase UsoDePila es la siguiente:

> javac *.java
(se generan PilaVaciaException.class, PilaLlenaException.class, Pila.class
y UsoDePila.class)
> java UsoDePila

La pila esta vacia

Apilando elemento: 23
Apilando elemento: -45
Apilando elemento: -12
Apilando elemento: 67
Apilando elemento: 1
Apilando elemento: 0
Apilando elemento: -43
Apilando elemento: 89

Desapilando elemento: 89
Desapilando elemento: -43
Desapilando elemento: 0

5
 Java

Cima: 1

Apilando elemento: 564

Apilando elemento: -987
Apilando elemento: -10
Apilando elemento: 56
Apilando elemento: 1111

La pila esta llena

Mostrando contenido de la pila...

Elemento en posicion 0: 23
Elemento en posicion 1: -45
Elemento en posicion 2: -12
Elemento en posicion 3: 67
Elemento en posicion 4: 1
Elemento en posicion 5: 564
Elemento en posicion 6: -987
Elemento en posicion 7: -10
Elemento en posicion 8: 56
Elemento en posicion 9: 1111

Apilando elemento: 666

ERROR. Imposible apilar el elemento 666. Pila llena