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()+", VAR_OBJETO_SEMAFORO.VALOR_DURACION()); System.out.println(); }
Duración:
"+
} } 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_XVAR_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_YVAR_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_XVAR_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_YVAR_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 arreg lo 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_FILA1][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
VAR_RECORRE_FILA=0;
{ 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
VAR_RECORRE_COL=0;
{ 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 "+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) {
UNO:
VAR_CONTADOR_FILAS_DOS++; if (VAR_CONTADOR_FILAS_DOS==3){ JOptionPane.showMessageDialog(null,"GANADOR "+VAR_CONTADOR_FILAS_DOS);
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 "+VAR_CONTADOR_FILAS_UNO);
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
}
//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();
} }
