Ejercicios

8.2 Explique la noción del acceso a nivel de paquete en Java. Explique los aspectos negativos del
acceso a nivel de paquete.

EL acceso a nivel de paquete permite que todas las clases dentro de el mismo
paquete puedan ser visibles entre ellas mismas sin necesidad de hacer una
importación de la clase de forma explícita, dado que pertenecen al mismo paquete,
pueden acceder a las clases que se encuentran al mismo nivel (a menos claro, que
se definan como privadas)y por supuesto a sus atributos públicos, en realidad no
hay desventajas en este modelo, es normal en Java, solamente encontraras
desventajas en un análisis y diseño mal hecho, donde no se definen atributos
públicos, privados o protegidos(heredables), por ejemplo:
Clase1.java
------------------------------------
package mipaquete;
public class Clase1{
public atributo1;
public Clase1(){
System.out.println("Hola");
}
}
--------------------------------------
Accedemos a la Clase1 desde la Clase2
package mipaquete;
public class Clase2{
public atributo2;
public Clase2(){
new Clase1();
}
---------------------------
La salida de instanciar la Clase2 sería Hola

Si por ejemplo Clase1 estuviera en mipaquete2, hubiera sido necesario un:

import mipaquete2.Clase1;

8.3 ¿Que ocurre cuando un tipo de valor de retorno, incluso void, se especifica para un
constructor?

Se trata como un método y no se considera un constructor.

8.4 (Clase Rectángulo) Cree una clase llamada Rectángulo. La clase debe tener los atributos longitud y

anchura, cada uno con un valor predeterminado de 1. Debe tener métodos para calcular el perímetro y

el área del rectángulo. Debe tener métodos establecer y obtener para longitud y anchura. Los métodos
establecer deben verificar que longitud y anchura sean números de punto flotante mayores de 0.0, y
menores de 20.0. Escriba un programa para probar la clase Rectángulo.

public class Rectangle

{
private double length;
private double width;

public Rectangle()
{
setLength( 1.0 );
setWidth( 1.0 );
}

public Rectangle( double theLength, double theWidth )

{
setLength( theLength );
setWidth( theWidth );
}

public void setLength( double theLength )

{
length = ( theLength > 0.0 && theLength < 20.0 ? theLength : 1.0 );
}

public void setWidth( double theWidth )

{
width = ( theWidth > 0 && theWidth < 20.0 ? theWidth : 1.0 );
}

public double getLength()

{
return length;
}

public double getWidth()

{
return width;
Student Solution Exercises 3
}

public double perimeter()

{
return 2 * length + 2 * width;
}

public double area()

{
return length * width;
}

public String toString()

{
return String.format( "%s: %f\n%s: %f\n%s: %f\n%s: %f",
"Length", length, "Width", width,
"Perimeter", perimeter(), "Area", area() );
}
}

import java.util.Scanner;

public class RectangleTest

{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

Rectangle rectangle = new Rectangle();

int choice = getMenuChoice();

while ( choice != 3 )
{
switch ( choice )
{
case 1:
System.out.print( "Enter length: " );
rectangle.setLength( input.nextDouble() );
break;

case 2:
System.out.print ( "Enter width: " );
rectangle.setWidth( input.nextDouble() );
break;
}

System.out.println ( rectangle.toString() );

choice = getMenuChoice();

}
}

private static int getMenuChoice()

{
Scanner input = new Scanner( System.in );

System.out.println( "1. Set Length" );

System.out.println( "2. Set Width" );
System.out.println( "3. Exit" );
System.out.print( "Choice: " );

return input.nextInt();
}
}
8.5 (Modifi cación de la representación de datos interna de una clase) Seria perfectamente razonable
para la clase Tiempo2 de la fi gura 8.5 representar la hora internamente como el número de
segundos transcurridos desde medianoche, en vez de usar los tres valores enteros hora, minuto y

segundo. Los clientes podrían usar los mismos métodos public y obtener los mismos resultados.
Modifique la clase Tiempo2 de la fi gura 8.5 para implementar un objeto Tiempo2 como el número de
segundos transcurridos desde medianoche, y mostrar que no hay cambios visibles para los
clientes de la clase.

8.6 (Clase cuenta de ahorros) Cree una clase llamada CuentaDeAhorros. Use una variable static llamada
tasa-InteresAnual para almacenar la tasa de interés anual para todos los cuentahabientes. Cada
objeto de la clase debe contener una variable de instancia private llamada saldoAhorros, que indique
la cantidad que el ahorrador tiene actualmente en depósito. Proporcione el metodo
calcularInteresMensual para calcular el interés mensual, multiplicando el saldoAhorros por la tasaInteresAnual
dividida entre 12; este interes debe sumarse al saldoAhorros. Proporcione un método static llamado
modificarTasaInteres para establecer la tasaInteresAnual en un nuevo valor. Escriba un programa para
probar la clase CuentaDeAhorros. Cree dos instancias de objetos CuentaDeAhorros, ahorrador1 y ahorrador2, con
saldos de $2000.00 y $3000.00, respectivamente. Establezca la tasaInteresAnual en 4%, después
calcule el interés mensual e imprima los nuevos saldos para ambos ahorradores. Luego
establezca la tasaInteresAnual en 5%, calcule el interés del siguiente mes e imprima los nuevos saldos
para ambos ahorradores.

public class SavingAccount

{

private static double annualInterestRate = 0;

private double savingsBalance;

public SavingAccount( double balance )
{
savingsBalance = balance;
}

public void calculateMonthlyInterest()

{
savingsBalance += savingsBalance * ( annualInterestRate / 12.0 );
}

public static void modifyInterestRate( double newRate )

{
annualInterestRate =
( newRate >= 0 && newRate <= 1.0 ) ? newRate : 0.04;
}

public String toString()

{
return String.format( "$%.2f", savingsBalance );
}
}
public class SavingAccountTest
{
public static void main( String args[] )
{
SavingAccount saver1 = new SavingAccount( 2000 );
SavingAccount saver2 = new SavingAccount( 3000 );
SavingAccount.modifyInterestRate( 0.04 );

System.out.println( "Monthly balances for one year at .04" );

System.out.println( "Balances:" );

System.out.printf( "%20s%10s\n", "Saver 1", "Saver 2" );

System.out.printf( "%-10s%10s%10s\n", "Base",
saver1.toString(), saver2.toString() );

for ( int month = 1; month <= 12; month++ )

{
String monthLabel = String.format( "Month %d:", month );
saver1.calculateMonthlyInterest();
saver2.calculateMonthlyInterest();

System.out.printf( "%-10s%10s%10s\n", monthLabel,

saver1.toString(), saver2.toString() );
}

SavingAccount.modifyInterestRate( .05 );
saver1.calculateMonthlyInterest();
saver2.calculateMonthlyInterest();

System.out.println( "\nAfter setting interest rate to .05" );

System.out.println( "Balances:" );
System.out.printf( "%-10s%10s\n", "Saver 1", "Saver 2" );
System.out.printf( "%-10s%10s\n",
saver1.toString(), saver2.toString() );
}
}

8.7 (Mejora a la clase Tiempo2) Modifique la clase Tiempo2 de la fi gura 8.5 para incluir un método tictac,
que incremente el tiempo almacenado en un objeto Tiempo2 por un segundo. Proporcione el
método incrementarMinuto para incrementar el minuto, y el método incrementarHora para incrementar la
hora. El objeto Tiempo2 debe permanecer siempre en un estado consistente. Escriba un programa
para probar los métodos tictac, incrementarMinuto y incrementarHora, para asegurarse que funcionen
correctamente. Asegúrese de probar los siguientes casos:

a) Incrementar el minuto, de manera que cambie al siguiente minuto.

b) Incrementar la hora, de manera que cambie a la siguiente hora.
c) Incrementar el tiempo de manera que cambie al siguiente día (por ejemplo, de 11:59:59 PM a
12:00:00 AM).
8.8 (Mejora a la clase Fecha) Modifique la clase Fecha de la fi gura 8.7 para realizar la comprobación
de errores en los valores inicializadores para las variables de instancia mes, dia y anio (la versión
actual solo valida el mes y el día). Proporcione un método llamado siguienteDia para incrementar el
día en uno. El objeto Fecha siempre deberá permanecer en un estado consistente. Escriba un
programa que evalué el método siguienteDia en un ciclo que imprima la fecha durante cada iteración
del ciclo, para mostrar que el método siguienteDia funciona correctamente. Pruebe los siguientes
casos:
a) Incrementar la fecha de manera que cambie al siguiente mes.
b) Incrementar la fecha de manera que cambie al siguiente año.

public class Date

{
private int month;
private int day;
private int year;

public Date( int theMonth, int theDay, int theYear )

{
month = checkMonth( theMonth );
year = checkYear( theYear );
day = checkDay( theDay );

System.out.printf("Date object constructor for date %s\n", toString() );

}

private int checkYear( int testYear )

{
if ( testYear > 0 )
return testYear;
else
{
System.out.printf( "Invalid year (%d) set to 1.\n", testYear );
return 1;
}
}

private int checkMonth( int testMonth )

{
if ( testMonth > 0 && testMonth <= 12 )
return testMonth;
else
{
System.out.printf("Invalid month (%d) set to 1.\n", testMonth );
return 1;
}
}

private int checkDay( int testDay )

{
int daysPerMonth[] =
{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

if ( testDay > 0 && testDay <= daysPerMonth[ month ] )

return testDay;
if ( month == 2 && testDay == 29 && ( year % 400 == 0 ||
( year % 4 == 0 && year % 100 != 0 ) ) )
return testDay;

System.out.printf( "Invalid day (%d) set to 1.\n", testDay );

return 1;
}

public void nextDay()

{
int testDay = day + 1;

if ( checkDay( testDay ) == testDay )

day = testDay;
else
{
day = 1;
nextMonth();
}
}

public void nextMonth()

{
if ( 12 == month )
year++;

month = month % 12 + 1;
}

public String toString()

{
return String.format( "%d/%d/%d", month, day, year );
}
}

public class DateTest

{

public static void main( String args[] )

{
System.out.println( "Checking increment" );
Date testDate = new Date( 11, 27, 1988 );

for ( int counter = 0; counter < 40; counter++ )

{
testDate.nextDay();
System.out.printf( "Incremented Date: %s\n", testDate.toString() );
}
}
}

8.9 (Devolver indicadores de errores de los métodos) Modifique los métodos establecer en la clase Tiempo2
de la figura 8.5 para devolver valores de error apropiados si se hace un intento por establecer
una de las variables de instancia hora, minuto o segundo de un objeto de la clase Tiempo, en un valor
invalido. [Sugerencia: use tipos de valores de retorno boolean en cada método]. Escriba un programa
que pruebe estos nuevos métodos establecer y que imprima mensajes de error cuando se reciban
valores incorrectos.

public class Time2

{
private int hour;
private int minute;
private int second;

public Time2()
{
this( 0, 0, 0 );
}

public Time2( int h )

{
this( h, 0, 0 );
}

public Time2( int h, int m )

{
this( h, m, 0 );
}

public Time2( int h, int m, int s )

{
setTime( h, m, s );
}

public Time2( Time2 time )

{
this( time.getHour(), time.getMinute(), time.getSecond() );
}

public boolean setTime( int h, int m, int s )

{
boolean hourValid = setHour( h );
boolean minuteValid = setMinute( m );
boolean secondValid = setSecond( s );

return ( hourValid && minuteValid && secondValid );

}

public boolean setHour( int h )

{
if ( h >= 0 && h < 24 )
{
hour = h;
return true;
}
else
{
hour = 0;
return false;
}
}

public boolean setMinute( int m )

{
if ( m >= 0 && m < 60 )
{
minute = m;
return true;
}
else
{
minute = 0;
return false;
}
}

public boolean setSecond( int s )

{
if ( s >= 0 && s < 60 )
{
second = s;
return true;
}
else
{
second = 0;
return false;
}
}

public int getHour()

{
return hour;
}

public int getMinute()

{
return minute;
}

public int getSecond()

{
return second;
}

public void tick()

{
setSecond( second + 1 );

if ( second == 0 )
incrementMinute();
}

public void incrementMinute()

{
setMinute( minute + 1 );

if ( minute == 0 )
incrementHour();
}

public void incrementHour()

{
setHour( hour + 1 );
}

public String toUniversalString()

{
return String.format("%02d:%02d:%02d", getHour(), getMinute(), getSecond() );
}

public String toString()

{
return String.format( "%d:%02d:%02d %s",( (getHour() == 0 || getHour() == 12) ? 12 : getHour() % 12 ),
getMinute(), getSecond(), ( getHour() < 12 ? "AM" : "PM" ) );
}
}

import java.util.Scanner;

public class Time2Test

{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

Time2 time = new Time2();

int choice = getMenuChoice();

while ( choice != 5 )
{
switch ( choice )
{
case 1:
System.out.print( "Enter Hours: " );
int hours = input.nextInt();

if ( !time.setHour( hours ) )
System.out.println( "Invalid hours." );

break;

case 2:
System.out.print( "Enter Minutes: " );
int minutes = input.nextInt();

if ( !time.setMinute( minutes ) )
System.out.println( "Invalid minutes." );

break;

case 3:
System.out.print( "Enter Seconds: " );
int seconds = input.nextInt();

if ( !time.setSecond( seconds ) )
System.out.println( "Invalid seconds." );

break;

case 4:
time.tick();
break;
}

System.out.printf( "Hour: %d Minute: %d Second: %d\n",time.getHour(), time.getMinute(), time.getSecond()

);
System.out.printf( "Universal time: %s Standard time: %s\n",time.toUniversalString(), time.toString() );

choice = getMenuChoice();
}
}

private static int getMenuChoice()

{
Scanner input = new Scanner( System.in );
System.out.println( "1. Set Hour" );
System.out.println( "2. Set Minute" );
System.out.println( "3. Set Second" );
System.out.println( "4. Add 1 second" );
System.out.println( "5. Exit" );
System.out.print( "Choice: " );

return input.nextInt();
}
}

8.10 Vuelva a escribir la fi gura 8.14, de manera que utilice una declaración import separada para
cada miembro static de la clase Math que se utilice en el ejemplo.

8.11 Escriba un tipo enum llamado LuzSemaforo, cuyas constantes (ROJO, VERDE, AMARILLO) reciban un
parámetro: la duración de la luz. Escriba un programa para probar la enum LuzSemaforo, de manera
que muestre las constantes de la enum y sus duraciones.

public enum TrafficLight

{
RED( 50 ),
GREEN( 40 ),
YELLOW( 5 );

private final int duration;

TrafficLight( int durationSeconds )

{
duration = durationSeconds;
}
public int getDuration()
{
return duration;
}
}

public class EnumTest

{
public static void main( String args[] )
{
System.out.println( "Light\tDuration\n" );

for ( TrafficLight light : TrafficLight.values() )

System.out.printf( "%s\t%d\n", light, light.getDuration() );
}
}

8.12 (Números complejos) Cree una clase llamada Complejo para realizar operaciones aritméticas con
números complejos.
Estos números tienen la forma
parteReal + parteImaginaria * i
en donde i es
√-1
Escriba un programa para probar su clase. Use variables de punto flotante para representar los
datos private de la clase. Proporcione un constructor que permita que un objeto de esta clase se
inicialice al declararse. Proporcione un constructor sin argumentos con valores predeterminados,
en caso de que no se proporcionen inicializadores. Proporcione métodos public que realicen las
siguientes operaciones:

a) Sumar dos números Complejo: las partes reales se suman entre sí y las partes imaginarias
también.
b) Restar dos números Complejo: la parte real del operando derecho se resta de la parte real del
operando izquierdo, y la parte imaginaria del operando derecho se resta de la parte imaginaria
del operando izquierdo.
c) Imprimir números Complejo en la forma (a, b), en donde a es la parte real y b es la imaginaria.

8.13 (Clase Fecha y Tiempo) Cree una clase llamada FechaYTiempo, que combine la clase Tiempo2

modificada del ejercicio 8.7 y la clase Fecha modificada del ejercicio 8.8. Modifique el método
incrementarHora para llamar al método siguienteDia si el tiempo se incrementa hasta el siguiente día.
Modifique los métodos aStringEstandar y aStringUniversal para imprimir la fecha, junto con la hora. Escriba
un programa para evaluar la nueva clase Fecha-YTiempo. En específico, pruebe incrementando la
hora para que cambie al siguiente día.

8.14 (Clase Rectangulo mejorada) Cree una clase Rectangulo más sofisticada que la que creo en el
ejercicio 8.4. Esta clase debe guardar solamente las coordenadas Cartesianas de las cuatro
esquinas del rectángulo. El constructor debe llamar a un método establecer que acepte cuatro
conjuntos de coordenadas y verifique que cada una de estas se encuentre en el primer
cuadrante, en donde ninguna coordenada x o y debe ser mayor de 20.0. El método establecer debe
también verificar que las coordenadas proporcionadas especifiquen un rectángulo. Proporcione
métodos para calcular la longitud, anchura, perimetro y area. La longitud sera la mayor de las dos
dimensiones. Incluya un método predicado llamado esCuadrado, el cual determine si el rectángulo
es un cuadrado. Escriba un programa para probar la clase Rectangulo.

public class Rectangle

{

private double x1, y1;

private double x2, y2;
private double x3, y3;
private double x4, y4;

public Rectangle()
{
setCoordinates( 1, 1, 1, 1, 1, 1, 1, 1 );
}

public Rectangle( double x1, double y1, double x2,

double y2, double x3, double y3, double x4, double y4 )
{
setCoordinates( x1, y1, x2, y2, x3, y3, x4, y4 );
}

public void setCoordinates( double xInput1, double yInput1,

double xInput2, double yInput2, double xInput3,
double yInput3, double xInput4, double yInput4 )
{
x1 = ( xInput1 >= 0.0 && xInput1 <= 20.0 ? xInput1 : 1 );
x2 = ( xInput2 >= 0.0 && xInput2 <= 20.0 ? xInput2 : 1 );
x3 = ( xInput3 >= 0.0 && xInput3 <= 20.0 ? xInput3 : 1 );
x4 = ( xInput4 >= 0.0 && xInput4 <= 20.0 ? xInput4 : 1 );
y1 = ( yInput1 >= 0.0 && yInput1 <= 20.0 ? yInput1 : 1 );
y2 = ( yInput2 >= 0.0 && yInput2 <= 20.0 ? yInput2 : 1 );
y3 = ( yInput3 >= 0.0 && yInput3 <= 20.0 ? yInput3 : 1 );
y4 = ( yInput4 >= 0.0 && yInput4 <= 20.0 ? yInput4 : 1 );

if ( !isRectangle() )
System.out.println( "This is not a rectangle" );
}

public double distance( double x1, double y1, double x2, double y2 )
{
return Math.sqrt( ( Math.pow( x1 - x2, 2 )+ Math.pow( y1 - y2, 2 ) ) );
}

public boolean isRectangle()

{
double side1 = distance( x1, y1, x2, y2 );
double side2 = distance( x2, y2, x3, y3 );
double side3 = distance( x3, y3, x4, y4 );

if ( side1 * side1 + side2 * side2 == side2 * side2 + side3 * side3 )

return true;
else
return false;
}

public boolean isSquare()

{
return ( getLength() == getWidth() );
}

public double getLength()

{
double side1 = distance( x1, y1, x2, y2 );
double side2 = distance( x2, y2, x3, y3 );

return ( side1 > side2 ? side1 : side2 );

}

public double getWidth()

{
double side1 = distance( x1, y1, x2, y2 );
double side2 = distance( x2, y2, x3, y3 );

return ( side1 < side2 ? side1 : side2 );

}

public double perimeter()

{
return 2 * getLength() + 2 * getWidth();
}

public double area()

{
return getLength() * getWidth();
}

public String toString()

{
return String.format( "%s: %f\n%s: %f\n%s: %f\n%s: %f","Length", getLength(), "Width",
getWidth(),"Perimeter", perimeter(), Area", area() );
}
}

import java.util.Scanner;
public class RectangleTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.println( "Enter rectangle's coordinates" );

System.out.print( "x1: " );
double x1 = input.nextInt();
System.out.print( "y1: " );
double y1 = input.nextInt();
System.out.print( "x2: " );
double x2 = input.nextInt();
System.out.print( "y2: " );
double y2 = input.nextInt();
System.out.print( "x3: " );
double x3 = input.nextInt();
System.out.print( "y3: " );
double y3 = input.nextInt();
System.out.print( "x4: " );
double x4 = input.nextInt();
System.out.print( "y4: " );
double y4 = input.nextInt();

Rectangle rectangle =
new Rectangle( x1, y1, x2, y2, x3, y3, x4, y4 );

if ( rectangle.isRectangle() )
System.out.println( rectangle.toString() );

if ( rectangle.isSquare() )
System.out.println( "This is a square" );
}
}

8.15 (Conjunto de enteros) Cree la clase ConjuntoEnteros. Cada objeto ConjuntoEnteros puede almacenar
enteros en el rango de 0 a 100. El conjunto se representa mediante un arreglo de valores boolean.

El elemento del arreglo a[i] es true si el entero i se encuentra en el conjunto. El elemento del
arreglo a[j] es false si el entero j no se encuentra dentro del conjunto. El constructor sin argumentos
inicializa el arreglo de Java con el “conjunto vacío” (es decir, un conjunto cuya representación de
arreglo contiene solo valores false). Proporcione los siguientes métodos: el método union debe crear
un tercer conjunto que sea la unión teórica de conjuntos para los dos conjuntos existentes (es
decir, un elemento del tercer arreglo se establece en true si ese elemento es true en cualquiera o
en ambos de los conjuntos existentes; en caso contrario, el elemento del tercer conjunto se
establece en false). El método interseccion debe crear un tercer conjunto que sea la intersección
teórica de conjuntos para los dos conjuntos existentes (es decir, un elemento del arreglo del
tercer conjunto se establece en false si ese elemento es false en uno o ambos de los conjuntos
existentes; en caso contrario, el elemento del tercer conjunto se establece en true). El método
insertarElemento debe insertar un nuevo entero k en un conjunto (estableciendo a[k] en true). El método
eliminarElemento debe eliminar el entero m (estableciendo a[m] en false). El método aStringConjunto debe
devolver una cadena que contenga un conjunto como una lista de números separados por
espacios. Incluya solo aquellos elementos que estén presentes en el conjunto. Use - - - para

representar un conjunto vacío. El método esIgualA debe determinar si dos conjuntos son iguales.
Escriba un programa para probar la clase ConjuntoEnteros. Cree instancias de varios objetos
ConjuntoEnteros. Pruebe que todos sus métodos funcionen correctamente.

8.16 (Clase Fecha) Cree la clase Fecha con las siguientes capacidades:
a) Imprimir la fecha en varios formatos, como
MM/DD/AAAA
Junio 15, 1992
DDD AAAA
b) Usar constructores sobrecargados para crear objetos Fecha inicializados con fechas de los
formatos en la parte (a). En el primer caso, el constructor debe recibir tres valores enteros. En el
segundo caso, debe recibir un objeto String y dos valores enteros. En el tercer caso debe recibir
dos valores enteros, el primero de los cuales representa el número de día en el ano. [Sugerencia:
para convertir la representación de cadena del mes a un valor numérico, compare las cadenas
usando el método equals. Por ejemplo, si s1 y s2 son cadenas, la llamada al método s1.equals( s2 )
devuelve true si las cadenas son idénticas y devuelve false en cualquier otro caso].

8.17 (Números racionales) Cree una clase llamada Racional para realizar operaciones aritméticas con
fracciones. Escriba un programa para probar su clase. Use variables enteras para representar las
variables de instancia private de la clase: el numerador y el denominador. Proporcione un constructor que
permita a un objeto de esta clase inicializarse al ser declarado. El constructor debe almacenar la
fracción en forma reducida. La fracción 2/4 es equivalente a 1/2 y debe guardarse en el objeto
como 1 en el numerador y 2 en el denominador. Proporcione un constructor sin argumentos con valores
predeterminados, en caso de que no se proporcionen inicializadores. Proporcione métodos public
que realicen cada una de las siguientes operaciones:

a) Sumar dos números Racional: el resultado de la suma debe almacenarse en forma reducida.
b) Restar dos números Racional: el resultado de la resta debe almacenarse en forma reducida.
c) Multiplicar dos números Racional: el resultado de la multiplicación debe almacenarse en forma
reducida.
d) Dividir dos números Racional: el resultado de la división debe almacenarse en forma reducida.
e) Imprimir números Racional en la forma a/b, en donde a es el numerador y b es el denominador.
f) Imprimir números Racional en formato de punto flotante. (Considere proporcionar capacidades de
formato, que permitan al usuario de la clase especificar el número de dígitos de precisión a la
derecha del punto decimal).

public class Rational

{
private int numerator;
private int denominator;

public Rational()
{
numerator = 1;
denominator = 1;
}
public Rational( int theNumerator, int theDenominator )
{
numerator = theNumerator;
denominator = theDenominator;
reduce();
}

public Rational sum( Rational right )

{
int resultDenominator = denominator * right.denominator;
int resultNumerator = numerator * right.denominator +
right.numerator * denominator;

return new Rational( resultNumerator, resultDenominator );

}
public Rational subtract( Rational right )
{
int resultDenominator = denominator * right.denominator;
int resultNumerator = numerator * right.denominator -
right.numerator * denominator;

return new Rational( resultNumerator, resultDenominator );

}

public Rational multiply( Rational right )

{
return new Rational( numerator * right.numerator, denominator * right.denominator );
}

public Rational divide( Rational right )

{
return new Rational( numerator * right.denominator,
denominator * right.numerator );
}

private void reduce()

{
int gcd = 0;
int smaller;

if ( numerator < denominator )

smaller = numerator;
else
smaller = denominator;

for ( int divisor = smaller; divisor >= 2; divisor-- )

{
if ( numerator % divisor == 0 && denominator % divisor == 0 )
{
gcd = divisor;
break;
}
}

if ( gcd != 0 )
{
numerator /= gcd;
denominator /= gcd;
}
}

public String toString()

{
return numerator + "/" + denominator;
}

public String toFloatString( int digits )

{
double value = ( double ) numerator / denominator;
return String.format( "%." + digits + "f", value );
}
}

import java.util.Scanner;

public class RationalTest

{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

int numerator;
int denominator;
int digits;
Rational rational1;
Rational rational2;
Rational result;

System.out.print( "Enter numerator 1: " );

numerator = input.nextInt();
System.out.print( "Enter denominator 1: " );
denominator = input.nextInt();
rational1 = new Rational( numerator, denominator );

System.out.print( "Enter numerator 2: " );

numerator = input.nextInt();
System.out.print( "Enter denominator 2: " );
denominator = input.nextInt();
rational2 = new Rational( numerator, denominator );

System.out.print( "Enter precision: " );

digits = input.nextInt();

int choice = getMenuChoice();

while ( choice != 5 )
{
switch ( choice )
{
case 1:
result = rational1.sum( rational2 );
System.out.printf( "a + b = %s = %s\n",
result.toString(),
result.toFloatString( digits ) );
break;

case 2:
result = rational1.subtract( rational2 );
System.out.printf( "a - b = %s = %s\n",
result.toString(),
result.toFloatString( digits ) );
break;

case 3:
result = rational1.multiply( rational2 );
System.out.printf( "a * b = %s = %s\n",
result.toString(),
result.toFloatString( digits ) );
break;

case 4:
result = rational1.divide( rational2 );
System.out.printf( "a / b = %s = %s\n",
result.toString(),
result.toFloatString( digits ) );
break;
}

choice = getMenuChoice();
}
}

private static int getMenuChoice()

{
Scanner input = new Scanner( System.in );

System.out.println( "1. Add" );

System.out.println( "2. Subtract" );
System.out.println( "3. Multiply" );
System.out.println( "4. Divide" );
System.out.println( "5. Exit" );
System.out.print( "Choice: " );

return input.nextInt();
}
}

8.18 (Clase Entero Enorme) Cree una clase llamada EnteroEnorme que utilice un arreglo de 40
elementos de dígitos, para guardar enteros de hasta 40 dígitos de longitud cada uno.
Proporcione los métodos entrada, salida, sumar y restar. Para comparar objetos EnteroEnorme, proporcione
los siguientes métodos: esIgualA, noEsIgualA, esMayor-Que, esMenorQue, esMayorOIgualA, y esMenorOIgualA. Cada
uno de estos métodos deberá ser un método predicado que devuelva true si la relación se aplica
entre los dos objetos EnteroEnorme, y false si no se aplica. Proporcione un método predicado llamado
esCero. Si desea hacer algo más, proporcione también los métodos multiplicar, dividir y residuo. [Nota: los
valores boolean primitivos pueden imprimirse como la palabra “true” o la palabra “false”, con el
especificador de formato %b].

8.19 (Tres en raya) Cree una clase llamada TresEnRaya que le permita escribir un programa completo
para jugar al “tres en raya” (o tres en línea). La clase debe contener un arreglo privado
bidimensional de enteros, con un tamaño de 3 por 3. El constructor debe inicializar el tablero
vacío con ceros. Permita dos jugadores humanos. Siempre que el primer jugador realice un
movimiento, coloque un 1 en el cuadro especificado; coloque un 2 siempre que el segundo
jugador realice un movimiento. Cada movimiento debe hacerse en un cuadro vacío. Después de
cada movimiento, determine si el juego se ha ganado o si hay un empate. Si desea hacer algo
más, modifique su programa de manera que la computadora realice los movimientos para uno de
los jugadores. Además, permita que el jugador especifique si desea el primer o segundo turno. Si
se siente todavía más motivado, desarrolle un programa que reproduzca un juego de Tres en
raya tridimensional, en un tablero de 4 por 4 por 4 [Nota:! este es un proyecto retador que podría
requerir de muchas semanas de esfuerzo!].