Universidad Politécnica de

Tulancingo

Maestría en Ingeniería de Sistemas, especialidad en

software

Profesor: Carlos Enríquez Ramírez.

Materia: Programación Orientada a Objetos.

Alumno: Ricardo Raúl Delgadillo Avila.

Tema: Evidencias de la lectura de: “JAVA Cómo

Programar”, Capítulo 8.

Marzo del 2010.

Ejercicio de autoevaluación
8.1 Complete los siguientes enunciados:

a) Al compilar una clase en un paquete, la opción –d de línea de comandos de javac especifica en

dónde se debe almacenar el paquete, y hace que el compilador cree los directorios, en caso de que no existan.

b) El método static format de la clase String es similar al método System.out.printf, pero devuelve un objeto
String con formato en vez de mostrar un objeto String en una ventana de comandos.

c) Si un método contiene una variable local en el mismo nombre que uno de los campos de su clase, la
variable local oculta al campo en el alcance de ese método.

d) El recolector de basura llama al método finalize antes de reclamar la memoria de un objeto.

e) Una declaración import de tipo simple especifica una clase a importar.

f) Si una clase declara constructores, el compilador no creará un (a) constructor predeterminado.

g) El método to string de un objeto se llama en forma implícita cuando aparece un objeto en el código, en
donde se necesita un String.

h) A los métodos establecer se les llama comúnmente métodos de acceso o métodos de consulta.

i) Un método predicado evalúa si una condición es verdadera o falsa.

j) Para cada enum, el compilador genera un método static llamado values, que devuelve un arreglo de las
constantes de la enum en el orden en el que se declararon.

k) A la composición se le conoce algunas veces como relación tiene un.

l) Una declaración enum contiene una lista separada por comas de constantes.

m) Una variable static representa información a nivel de clase, que comparten todos los objetos de la clase.

n) Una declaración static import de tipo simple importa un miembro static.

o) El principio de menor privilegio establece que al código se le debe otorgar sólo el nivel de privilegio y de
acceso que necesita para realizar su tarea designada.

p) La palabra clave final especifica que una variable no se puede modificar.

q) Un (a) tipo de datos abstracto (ADT) consiste en una representación de datos y las operaciones que
pueden realizarse sobre esos datos.

r) Solo puede haber un (a) declaración pakage en un archivo de código fuente de java, y debe ir antes de
todas las demás declaraciones e instrucciones en el archivo.

s) Un (a) declaración import tipo sobre demanda sólo importa las clases que utiliza el programa de un
paquete específico.

t) El compilador utiliza un (a) cargador de clases para localizar las clases que necesita en la ruta de las
clases.

u) La ruta de las clases para el compilador y la JVM se puede especificar mediante la opción -classpath para
el comando javac o java, o estableciendo la variable de entorno CLASSPATH.
 v) A los métodos establecer se les conoce comúnmente como métodos mutadores, ya que, por lo general,
modifican un valor.

w) Un(a) declaración static import sobre demanda importa a todos los miembros static de una clase.

x) Los métodos public de una clase se conocen también como los servicios public o interfaz public de la
clase.

y) El método static gc de la clase System indica que el recolector de basura debe realizar su mejor esfuerzo
para tratar de reclamar los objetos que sean candidatos para la recolección de basura.

z) Un objeto que contiene datos consistentes tiene valores de datos que siempre se mantienen dentro del
rango.

Ejercicios
8.3 ¿ Qué ocurre cuando un tipo de valor de retornó, incluso void, se especifica para un constructor?.

Respuesta:

Marcaria un error, ya que solo podría devolver o nó un valor pero solo desde un método del constructor.

8.4 (Clase Rectángulo) Cree una clase Rectángulo. La clase debe tener atributos longitud y anchura, cada uno
con el valor predeterminado de 1. Debe tener métodos para calcular el perímetro y el área del rectángulo. Debe
tener métodos para establecer y obtener para longitud y altura. 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.

Respuesta:

package RECTANGULO;

import javax.swing.*;

//CREA LA CLASE PARA CALCULAR EL ÁREA Y EL PERIMETRO *******************************

public class OPERACIONES_RECTANGULO{

float VAR_ALTURA =1;

float VAR_ANCHO=1;

float VAR_RESULTADO;

// CREACION DE LOS METODOS PARA SU POSTERIOR LLAMADO **************************

public void CAPTURA_DATOS(){ //METODO QUE CAPTURA LOS DATOS NECESARIOS ********

String VAR_VALOR;

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la ancho: ");

 VAR_ANCHO=Integer.parseInt(VAR_VALOR);

if ((VAR_ANCHO<=0) || (VAR_ANCHO>=20))

JOptionPane.showMessageDialog(null,"El valor debe de ser menor mayor a cero y menor de 20");

else{

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la altura: ");

VAR_ALTURA=Integer.parseInt(VAR_VALOR);

if ((VAR_ALTURA<=0) || (VAR_ALTURA>=20))

JOptionPane.showMessageDialog(null,"El valor debe de ser menor mayor a cero y menor de 20");

//CREA METODO DONDE CALCULA EL AREA Y LA IMPRIME *****************************

public void CALCULAR_AREA()

VAR_RESULTADO = VAR_ANCHO*VAR_ALTURA;

System.out.println();

System.out.print("El área es: ");

System.out.print(VAR_RESULTADO);

System.out.println();

//CREA EL METODO DONDE CALCULA EL PERIMETRO Y LO IMPRIME **********************

public void CALCULAR_PERIMETRO(){

VAR_RESULTADO= (VAR_ANCHO*2)+(VAR_ALTURA*2);

System.out.println();

System.out.print("El perímetro es: ");

 System.out.print(VAR_RESULTADO);

System.out.println();

class CALCULO_OPERACIONES_RECTANGULO{

public static void main(String[] args) {

//CREA EL OBJETO PARA REALIZAR LAS AOPRACIONES DE ÁREA Y PERIMETOR

OPERACIONES_RECTANGULO OBJETO_RECTANGULO = new OPERACIONES_RECTANGULO();

//LLAMA A LOS METODOS DEL OBJETO CREADO ***************************

OBJETO_RECTANGULO.CAPTURA_DATOS();

OBJETO_RECTANGULO.CALCULAR_AREA();

OBJETO_RECTANGULO.CALCULAR_PERIMETRO();

8.5 (Modificación de la representación de datos interna de una clase) Sería perfectamente razonable para la clase
tiempo2, representar la hora internamente como el número de segundos transcurridos desde media noche, en vez
de usar los tres valores enteros hora, minuto y segundo. Los clientes podrán utilizar los mismos métodos public y
obtener los mismos resultados. Modifique la clase Tiempo2. Para implementar una clase Tiempo2 como el número
de segundos transcurridos desde media noche, y mostrar que no hay cambios visibles para los clientes de la
clase.

8.6 (Clase cuenta de ahorro) Cree una clase que se llame cuentaDeAhorros. Use una variable Static llamada
TazaDeInteresAnual para almacenar la taza de interés anual para todos los cuentahabientes. Cada objeto de la
clase debe de contener un variable de instancia prívate llamada SaldoAhorros, que indique la cantidad que al
ahorrador tiene actualmente en depósito. Proporcione el método CalcularInteresMensual para calcular el interés
mensual multiplicando el saldoAhorros por la tazaDeInteresMensual dividida entre 12; este interés 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.000 y $3000.000, respectivamente. Establezca
la tasaInteresAnual en 4%, después calcule el interés del siguiente mes e imprima los nuevos saldos para ambos
ahorradores.

8.7 (Mejora a la clase tiempo2) Modifique la clase tiempo2 de la figura 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 e incrementarHora, para asegurarse que funcionen correctamente, asegurarse 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 ejem. De 11:59:59 PM a 12:00:00 AM).

8.8 (Mejora la clase fecha) Modifiquen la clase Fecha de la figura 8.7 para realizar la comprobación de errores en
los valores inicializadores para las variables de instancia de mes, día y año (la versión actual sólo 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 evalúe el método siguienteDia en 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 siguiente año.

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 clase Tiempo, en un valor inválido. (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.

8.10 Vuelva a escribir la fig. 8.14, de manera que utilice una declaración import separada para cada miembro static
de la clase Math que se utiliza 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.

Respuesta:

package LUZ_SEMAFORO;

import java.lang.String;

public enum LUZSEMAFORO {

CONST_ROJO("Rojo","30"),

CONST_VERDE("Verde", "40"),

CONST_AMARILLO("Amarillo", "3");

private final String VAR_ENUM_COLOR;

 private final String VAR_ENUM_DURACION;

//CONSTRUCTOR DE LA CLASES ENUM ***********************************

LUZSEMAFORO(String VAR_COLOR,String VAR_DURACION)

VAR_ENUM_COLOR = VAR_COLOR;

VAR_ENUM_DURACION = VAR_DURACION;

public String VALOR_COLOR()

return VAR_ENUM_COLOR;

public String VALOR_DURACION()

return VAR_ENUM_DURACION;

class PRUEBA_ENUM_SEMAFORO

public static void main(String args[])

for(LUZSEMAFORO VAR_OBJETO_SEMAFORO : LUZSEMAFORO.values())

System.out.printf("Color: "+VAR_OBJETO_SEMAFORO.VALOR_COLOR()+", Duración: "+

VAR_OBJETO_SEMAFORO.VALOR_DURACION());

System.out.println();

}
 }

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

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 si 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.

Respuesta:

package NUMEROS_COMPLEJOS;

import javax.swing.*;

class COMPLEJO {

int VAR_REAL_A;

int VAR_REAL_B;

int VAR_IMAGINARIO_A;

int VAR_IMAGINARIO_B;

int VAR_SUMA_REAL;

int VAR_SUMA_IMAGINARIO;

int VAR_RESTA_REAL;

int VAR_RESTA_IMAGINARIO;

//SE DECLARA EL CONSTRUCTOR QUE INICIALIZE LAS VARIABLE *************

COMPLEJO()

VAR_REAL_A=0;
 VAR_REAL_B=0;

VAR_IMAGINARIO_A=0;

VAR_IMAGINARIO_B=0;

VAR_SUMA_REAL=0;

VAR_SUMA_IMAGINARIO=0;

VAR_RESTA_REAL=0;

VAR_RESTA_IMAGINARIO=0;

//METODO QUE SE UTILIZA PARA LA SUMA DE REALES **************************

public void SUMA_REALES(int VAR_REAL_A, int VAR_REAL_B)

VAR_SUMA_REAL=VAR_REAL_A+VAR_REAL_B;

//METODO QUE SE UTILIZA PARA LA SUMA DE IMAGINARIOS **********************

public void SUMA_IMAGINARIOS(int VAR_IMAGINARIO_A, int VAR_IMAGINARIO_B)

VAR_SUMA_IMAGINARIO=VAR_IMAGINARIO_A+VAR_IMAGINARIO_B;

//METODO QUE SE UTILIZA PARA LA SUMA DE REALES **************************

public void RESTA_REALES(int VAR_REAL_A, int VAR_REAL_B)

VAR_RESTA_REAL=VAR_REAL_A-VAR_REAL_B;

//METODO QUE SE UTILIZA PARA LA SUMA DE IMAGINARIOS **********************

public void RESTA_IMAGINARIOS(int VAR_IMAGINARIO_A, int VAR_IMAGINARIO_B)

{
 VAR_RESTA_IMAGINARIO=VAR_IMAGINARIO_A-VAR_IMAGINARIO_B;

public void IMPRIME_RESULTADO_SUMA()

System.out.println();

System.out.print("El resultado de la suma real es: "+VAR_SUMA_REAL+", la imaginaria es:

"+VAR_SUMA_IMAGINARIO+"i ");

System.out.println();

public void IMPRIME_RESULTADO_RESTA()

System.out.println();

System.out.print("El resultado de la resta real es: "+VAR_RESTA_REAL+", la imaginaria es:

"+VAR_RESTA_IMAGINARIO+"i ");

System.out.println();

class OperacionesMatrices

public static void main(String args[])

COMPLEJO VAR_OBJETO_COMPLEJO= new COMPLEJO();

String VAR_VALOR;

int VAR_CAPTURA_REAL_A=0;

int VAR_CAPTURA_IMAGINARIO_A=0;

int VAR_CAPTURA_REAL_B=0;

int VAR_CAPTURA_IMAGINARIO_B=0;
 System.out.print("*********OPERACIONES CON COMPLEJOS ************************");

System.out.println();

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la parte real R1: ");

VAR_CAPTURA_REAL_A=Integer.parseInt(VAR_VALOR);

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la parte imaginaria I1: ");

VAR_CAPTURA_IMAGINARIO_A=Integer.parseInt(VAR_VALOR);

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la parte real R2: ");

VAR_CAPTURA_REAL_B=Integer.parseInt(VAR_VALOR);

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de la parte imaginaria I2: ");

VAR_CAPTURA_IMAGINARIO_B=Integer.parseInt(VAR_VALOR);

VAR_OBJETO_COMPLEJO.SUMA_REALES(VAR_CAPTURA_REAL_A, VAR_CAPTURA_REAL_B);

VAR_OBJETO_COMPLEJO.SUMA_IMAGINARIOS(VAR_CAPTURA_IMAGINARIO_A,
VAR_CAPTURA_IMAGINARIO_B);

VAR_OBJETO_COMPLEJO.IMPRIME_RESULTADO_SUMA();

VAR_OBJETO_COMPLEJO.RESTA_REALES(VAR_CAPTURA_REAL_A, VAR_CAPTURA_REAL_B);

VAR_OBJETO_COMPLEJO.RESTA_IMAGINARIOS(VAR_CAPTURA_IMAGINARIO_A,
VAR_CAPTURA_IMAGINARIO_B);

VAR_OBJETO_COMPLEJO.IMPRIME_RESULTADO_RESTA();

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 a StringEstandar y a
StringUniversal para imprimir la fecha, junto con la hora. Escriba un programa para evaluar nueva clase
FechaYTiempo. En específico, pruebe incrementando la hora para que cambie al siguiente día.

8.14 (Clase Rectángulo mejorada) Cree una clase rectángulo más sofisticada que la que creó 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 éstas 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 especifiquen un rectángulo. Proporcione métodos
para calcular la longitud, anchura, perímetro y área. La longitud será 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 rectángulo.

Respuesta:

package RECTANGULO_MEJORADO;

import javax.swing.*;

//CREA LA CLASE PARA CALCULAR EL ÁREA Y EL PERIMETRO *******************************

public class RECTANGULO_CARTESIANO{

int VAR_SUP_IZQ_X =0;

int VAR_SUP_IZQ_Y =0;

int VAR_SUP_DER_X =0;

int VAR_SUP_DER_Y =0;

int VAR_INF_IZQ_X =0;

int VAR_INF_IZQ_Y =0;

int VAR_INF_DER_X =0;

int VAR_INF_DER_Y =0;

//ESTABLECE LOS LIMITES DE DONDE DEBE DE SER LAS COORDENAS DEL ERCTANGULO ******

int VAR_LIMITE_MINIMO=1;

int VAR_LIMITE_MAXIMO=20;

int VAR_ANCHO=0;

int VAR_ALTURA=0;

int VAR_RESULTADO=0;

boolean VAR_CERRAR_CICLO=false;

// CREACION DE LOS METODOS PARA SU POSTERIOR LLAMADO **************************

public void ESTABLECER(){ //METODO QUE CAPTURA LOS DATOS NECESARIOS ********
 String VAR_VALOR;

while (VAR_CERRAR_CICLO==false)

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de X de la esquina superior izquierda: ");

VAR_SUP_IZQ_X=Integer.parseInt(VAR_VALOR);

if ((VAR_SUP_IZQ_X<VAR_LIMITE_MAXIMO)&&(VAR_SUP_IZQ_X>VAR_LIMITE_MINIMO))

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de Y de la esquina superior izquierda:

");

VAR_SUP_IZQ_Y=Integer.parseInt(VAR_VALOR);

if ((VAR_SUP_IZQ_Y<VAR_LIMITE_MAXIMO)&&(VAR_SUP_IZQ_X>VAR_LIMITE_MINIMO))

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de X de la esquina inferior derecha,

debe ser mayor a: "+VAR_SUP_IZQ_X+" y menor que: "+VAR_LIMITE_MAXIMO);

VAR_INF_DER_X=Integer.parseInt(VAR_VALOR);

if ((VAR_INF_DER_X<VAR_LIMITE_MAXIMO)&&(VAR_SUP_IZQ_X>VAR_LIMITE_MINIMO))

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el valor de Y de la esquina inferior

derecha, debe ser mayor a: "+VAR_SUP_IZQ_Y+" y menor que: "+VAR_LIMITE_MAXIMO);

VAR_INF_DER_Y=Integer.parseInt(VAR_VALOR);

if ((VAR_INF_DER_Y<VAR_LIMITE_MAXIMO)&&(VAR_SUP_IZQ_X>VAR_LIMITE_MINIMO))

VAR_CERRAR_CICLO=true;

}else{

JOptionPane.showMessageDialog(null,"La coordenada Y ser mayor a cero y menor de 20");

VAR_CERRAR_CICLO=false;

}else{

JOptionPane.showMessageDialog(null,"La coordenada X ser mayor a cero y menor de 20");

VAR_CERRAR_CICLO=false;
 }

}else{

JOptionPane.showMessageDialog(null,"La coordenada Y ser mayor a cero y menor de 20");

VAR_CERRAR_CICLO=false;

}else{

JOptionPane.showMessageDialog(null,"La coordenada X ser mayor a cero y menor de 20");

VAR_CERRAR_CICLO=false;

//COMIENZA A EXTRAER LA LONGITUD Y LA ALTURA PARA PODER CALCULAR EL AREA Y LE

PERÍMETRO ****************

VAR_ALTURA=(VAR_SUP_IZQ_Y - VAR_INF_DER_Y);

VAR_ANCHO=(VAR_INF_DER_X- VAR_SUP_IZQ_X);

JOptionPane.showMessageDialog(null,VAR_ALTURA);

JOptionPane.showMessageDialog(null,VAR_ANCHO);

//CREA METODO DONDE CALCULA EL AREA Y LA IMPRIME *****************************

public void CALCULAR_AREA()

VAR_RESULTADO = VAR_ANCHO*VAR_ALTURA;

System.out.println();

System.out.print("El área es: ");

System.out.print(VAR_RESULTADO);

System.out.println();

//CREA EL METODO DONDE CALCULA EL PERIMETRO Y LO IMPRIME **********************

public void CALCULAR_PERIMETRO(){

 VAR_RESULTADO= (VAR_ANCHO*2)+(VAR_ALTURA*2);

System.out.println();

System.out.print("El perímetro es: ");

System.out.print(VAR_RESULTADO);

System.out.println();

class CALCULO_OPERACIONES_RECTANGULO{

public static void main(String[] args) {

//CREA EL OBJETO PARA REALIZAR LAS AOPRACIONES DE ÁREA Y PERIMETOR

RECTANGULO_CARTESIANO OBJETO_RECTANGULO = new RECTANGULO_CARTESIANO();

//LLAMA A LOS METODOS DEL OBJETO CREADO ***************************

OBJETO_RECTANGULO.ESTABLECER();

OBJETO_RECTANGULO.CALCULAR_AREA();

OBJETO_RECTANGULO.CALCULAR_PERIMETRO();

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
vacio” (es decir, un conjunto cuya representación de arreglo contiene solo valores false).

Proporcione los siguiente métodos: el método unión 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 intersección 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 elemento 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 sólo aquellos elementos que estén presentes en el
conjunto. Use - - - para representar un conjunto vacío. El método es IgualA 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/AAA

Junio 15, 1992

DDD AAA

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, en el primero de los cuales
representa el número de día en el año. (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).

RESPUESTA:

package FECHA_FORMATOS;

import javax.swing.*;

public class FECHA

private int VAR_DIA_A;

private int VAR_MES_A;

private int VAR_AÑO_A;

private String VAR_MES_B;

//FORMATO FECHA 2 *****************************************************

public FECHA(int VAR_DIA_A, int VAR_MES_A, int VAR_AÑO_A)

String VAR_MES_CADENA="";

switch (VAR_MES_A){

//CONVIERTE EL NUMERO DEL EMES EN EL MES QUE EQUIVALE **************

case 1:{
 VAR_MES_CADENA="ENERO";

case 2:{

VAR_MES_CADENA="FEBRERO";

case 3:{

VAR_MES_CADENA="MARZO";

case 4:{

VAR_MES_CADENA="ABRIL";

case 5:{

VAR_MES_CADENA="MAYO";

case 6:{

VAR_MES_CADENA="JUNIO";

case 7:{

VAR_MES_CADENA="JULIO";

case 8:{

VAR_MES_CADENA="AGOSTO";

case 9:{

VAR_MES_CADENA="SEPTIEMBRE";

case 10:{

VAR_MES_CADENA="OCTUBRE";

case 11:{
 VAR_MES_CADENA="NOVIEMBRE";

case 12:{

VAR_MES_CADENA="DICIEMBRE";

this.VAR_DIA_A=VAR_DIA_A;

this.VAR_MES_B=VAR_MES_CADENA;

this.VAR_MES_A=VAR_MES_A;

this.VAR_AÑO_A=VAR_AÑO_A;

//FORMATO FECHA 3 *****************************************************

public FECHA(int VAR_DIA_A,int VAR_AÑO_A)

this.VAR_DIA_A=VAR_DIA_A;

this.VAR_AÑO_A=VAR_AÑO_A;

//IMPRIME LOS FORMATOS *****************************************************

public void IMPRIME_FORMATO()

System.out.println();

System.out.print("Fecha 1: "+VAR_DIA_A+"/"+VAR_MES_A+"/"+VAR_AÑO_A);

System.out.println();

System.out.print("Fecha 2: "+VAR_DIA_A+"/"+VAR_MES_B+"/"+VAR_AÑO_A);

System.out.println();

System.out.print("Fecha 3: "+VAR_DIA_A+"/"+VAR_AÑO_A);

System.out.println();
 }

class IMPRESION_FORMATO_FECHA

public static void main(String args[])

String VAR_VALOR;

int VAR_DIA;

int VAR_MES;

int VAR_AÑO;

//COMIENZ ALA INTRODUCCIOND E LSO DATOS D ELA FECHA A IMPRIMIR ******

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el DIA: ");

VAR_DIA=Integer.parseInt(VAR_VALOR);

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el MES: ");

VAR_MES=Integer.parseInt(VAR_VALOR);

VAR_VALOR=JOptionPane.showInputDialog("Introduzca el AÑO: ");

VAR_AÑO=Integer.parseInt(VAR_VALOR);

//LLAMA A LA CLASE CONSTRUIDA PARA HACERLE EL PASOD EPARAMETROS

FECHA VAR_OBJETO_FECHA1 = new FECHA(VAR_DIA, VAR_MES, VAR_AÑO);

//LLAMA AL METODO ****************************************************

VAR_OBJETO_FECHA1.IMPRIME_FORMATO();
 }

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
prívate 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 ½ 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 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).

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: es IgualA, no EsIgualA,
es MayorQue, esMenorQue, esMayorOIgualA, y esMenorOIgualA. Cada uno de estos métodos deberá ser un
método predicado que devuelva true si la relación aplica entre los dos objetos EnteroEnorme, y false si no se
aplica. Proporcione un método predicado llamado esCero. Si desea hacer algo mas, 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.

8.19 (Tres en Raya) Cree una clase llamada TresEnRaya que le permita escribir un programa 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 e 3
por 3. El constructor debe inicializar el tablero vacio en 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 vacio. Después de cada
movimiento determine si el juego se ha ganado o si hay un empate. Si desea hacer algo mas, modifique su
programa de manera que su computadora realice los movimientos para uno de los jugadores. Además, permita
que el jugador especifique si desea el primero 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: ¡éste es un
proyecto retador que podría requerir de muchas semanas de esfuerzo!).

Respuesta:

package TRES_EN_LINEA;

import javax.swing.*;

public class JUEGO_TRES_EN_LINEA {

int VAR_MATRIZ_TABLERO[][];
//SE CRE AUN CONSTRUCTOR QUE SE DEBE DE LLMARA IGUAL QUE LA CLASE DEL TRABLERO

JUEGO_TRES_EN_LINEA()

VAR_MATRIZ_TABLERO = new int[3][3];

//INTRDUCE LOS DATOS DE LAS MATRICES PARA LLENAR SU CONETNIDO

public void CAPTURAR_DATOS()

String VAR_RESULTADO;

int VAR_FILA=0;

int VAR_COL=0;

int VAR_JUGADOR=1;

int VAR_CONTADOR_FILAS_UNO=0;

int VAR_CONTADOR_FILAS_DOS=0;

int VAR_CONTADOR_COL_UNO=0;

int VAR_CONTADOR_COL_DOS=0;

boolean VAR_FINALIZAR = false;

while (VAR_FINALIZAR == false){

JOptionPane.showMessageDialog(null,"El jugador; "+VAR_JUGADOR+", es el que va a tirar: ");

VAR_RESULTADO =JOptionPane.showInputDialog("Qué fila elige : ");

VAR_FILA=Integer.parseInt(VAR_RESULTADO);

VAR_RESULTADO =JOptionPane.showInputDialog("Qué columna elige : ");

VAR_COL=Integer.parseInt(VAR_RESULTADO);
 if ((VAR_MATRIZ_TABLERO[VAR_FILA-1][VAR_COL-1]!=1)||(VAR_MATRIZ_TABLERO[VAR_FILA-
1][VAR_COL-1]!=2)){

VAR_MATRIZ_TABLERO[VAR_FILA-1][VAR_COL-1]=VAR_JUGADOR;

IMPRIME_ESTADO(VAR_MATRIZ_TABLERO, VAR_JUGADOR);

//REVIZA QUE EL HAYA UN GANADOR ***************************************************

for(int VAR_RECORRE_FILA=0;
VAR_RECORRE_FILA<VAR_MATRIZ_TABLERO.length;VAR_RECORRE_FILA++)

VAR_CONTADOR_FILAS_UNO=0;

VAR_CONTADOR_FILAS_DOS=0;

VAR_CONTADOR_COL_UNO=0;

VAR_CONTADOR_COL_DOS=0;

for(int VAR_RECORRE_COL=0;
VAR_RECORRE_COL<VAR_MATRIZ_TABLERO.length;VAR_RECORRE_COL++)

if (VAR_MATRIZ_TABLERO[VAR_RECORRE_FILA][VAR_RECORRE_COL]==1)

VAR_CONTADOR_FILAS_UNO++;

if (VAR_CONTADOR_FILAS_UNO==3){

JOptionPane.showMessageDialog(null,"GANADOR UNO:
"+VAR_CONTADOR_FILAS_UNO);

VAR_RECORRE_FILA=VAR_MATRIZ_TABLERO.length;

VAR_RECORRE_COL=VAR_MATRIZ_TABLERO.length;

VAR_FINALIZAR = true;

if (VAR_MATRIZ_TABLERO[VAR_RECORRE_FILA][VAR_RECORRE_COL]==2)

{
 VAR_CONTADOR_FILAS_DOS++;

if (VAR_CONTADOR_FILAS_DOS==3){

JOptionPane.showMessageDialog(null,"GANADOR DOS:
"+VAR_CONTADOR_FILAS_DOS);

VAR_RECORRE_FILA=VAR_MATRIZ_TABLERO.length;

VAR_RECORRE_COL=VAR_MATRIZ_TABLERO.length;

VAR_FINALIZAR = true;

if (VAR_MATRIZ_TABLERO[VAR_RECORRE_COL][VAR_RECORRE_FILA]==1)

VAR_CONTADOR_COL_UNO++;

if (VAR_CONTADOR_COL_UNO==3){

JOptionPane.showMessageDialog(null,"GANADOR UNO:
"+VAR_CONTADOR_FILAS_UNO);

VAR_RECORRE_FILA=VAR_MATRIZ_TABLERO.length;

VAR_RECORRE_COL=VAR_MATRIZ_TABLERO.length;

VAR_FINALIZAR = true;

if (VAR_MATRIZ_TABLERO[VAR_RECORRE_COL][VAR_RECORRE_FILA]==2)

VAR_CONTADOR_COL_DOS++;

if (VAR_CONTADOR_COL_DOS==3){

JOptionPane.showMessageDialog(null,"COL DOS: "+VAR_CONTADOR_FILAS_DOS);

VAR_RECORRE_FILA=VAR_MATRIZ_TABLERO.length;

VAR_RECORRE_COL=VAR_MATRIZ_TABLERO.length;

VAR_FINALIZAR = true;

}
 }

if (VAR_JUGADOR==1)

VAR_JUGADOR=2;

else

VAR_JUGADOR=1;

// IMPRIME LOS RESULTADOS DE LA MATRIZ RESULTADO ****************************

public void IMPRIME_ESTADO(int VAR_MATRIZ_AUXILIAR[][], int VAR_JUGADOR_AUXILIAR)

System.out.println("Tirada del jugador: "+ VAR_JUGADOR_AUXILIAR +" **************************");

for(int VAR_FILA=0; VAR_FILA<VAR_MATRIZ_AUXILIAR.length;VAR_FILA++)

for(int VAR_COL=0; VAR_COL<VAR_MATRIZ_AUXILIAR[VAR_FILA].length;VAR_COL++)

System.out.print(" "+VAR_MATRIZ_AUXILIAR[VAR_FILA][VAR_COL]);

System.out.println();

//SE CREA LA CLASE PRINCIPAL ************************************************************************************

class TRES_EN_LINEA
{

public static void main(String args[])

JUEGO_TRES_EN_LINEA VAR_OBJETO_TABLERO = new JUEGO_TRES_EN_LINEA(); // SE CREA EL

OBJETO APARTIR DE LA CLASE BASE

//SE HACE REFERENCIA CON EL OBJETO CREADO A LOS METODOS CREADOS DENTRO DE LA CLASE
BASE

VAR_OBJETO_TABLERO.CAPTURAR_DATOS();