T6 Java

T-6

 

 

 

---

x.3 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	Si un argumento formal de tipo wrapper es modificado en un método entonces el argumento real también es modificado
	Si un argumento formal de tipo List es modificado en un método entonces el argumento real también es modificado
	Si un argumento formal de tipo primitivo es modificado en un método entonces el argumento real también es modificado
	Si un argumento formal de tipo Circulo es modificado en un método entonces el argumento real también es modificado
	Si un argumento formal de tipo Boolean es modificado en un método entonces el argumento real también es modificado

t3.1 - Complete el código siguiente en una clase Test para comparar dos objetos de tipo Persona según su orden natural.No deje espacios en blanco en los recuadros

Persona p1 = new PersonaImpl(.........);  
Persona p2 = new PersonaImpl(.........);  
if() {      
     mostrar(p1 + " y " +  p2 + " son iguales");  
} else {     
        if(){         
             mostrar(p1 + " está antes en el orden que " +  p2);     
        } 
        else{         
            mostrar(p1 + " está después en el orden que " +  p2);     
        }  
}

t3.3 - Si el método equals de la clase PersonaImpl es el siguiente:

public boolean equals (Object o){   
   boolean res = false;   
   if (o instanceof Persona){    
       Persona p = (Persona) o;    
       res = getApellidos().equals(p.getApellidos()) &&                          
                                 getNombre().equals(p.getNombre());   
   }   
   return res;  
}

Complete el método compareTo para que sea consistente con el método equals. No deje espacios en blanco en las respuestas.

public  compareTo( p) {   
     int res = ;    
     if (){    
          = ;          
     }   
     return res;  
}

t3.4 - Complete la interfaz del tipo Punto para que puedan compararse puntos según su orden natural.

public interface Punto  {   
       Double getX();   
       Double getY();   
       void setX(Double x);   
       void setY(Double y);  
}

e.5 - Se ha definido la excepción ExcepcionRadioNegativo que hereda de Exception. Queremos que sea disparada en el método setRadio de la clase CirculoImpl. Complete el código para que todo sea correcto:

  public class TestCirculo extends Test {          
       public static void main(String []  args)    {          
              Punto p = new PuntoImpl(1.,1.);          
              Circulo c = new CirculoImpl(p,1.0);          
              c.setRadio(4.) ;       
       }  
  }

e.4 - Escriba el código de una excepción no comprobada para ser activada cuando se intenta construir un Circulo de radio negativo

    ExcepcionRadioNegativo   {     
               (, Double ){    
              (s+"radio: "+r);   
              }  
    }

e.3 - Complete el siguiente código que crea una excepción comprobada de nombre ExcepcionRadioNegativo para el tipo Circulo. Esta clase incluye un constructor sin parámetros y otro con un parámetro de tipo String.

public class RadioNoValidoException  {       
       public RadioNoValidoException ( ) {        
              ;     }       
       public RadioNoValidoException (String texto) {        
              ;     
       }  
}

e.2 - Suponiendo que el método setRadio lanza una excepción de tipo ExcepcionRadioNegativo, complete el bloque try-catch de forma que capture la excepción lanzada al ejecutar el método setRadio

public static void main(String [] args) {     
       {        
             p = 
             (1.0,1.0);        
             c =
              (p,3.0);        
            c.setRadio(-1.);     
       }
       ( e){        
            System.out.println("Excepción capturada"+e);     
       }  
}  

e.1 - Relacione las palabras siguientes con los bloques que aparecen en el esquema de tratamiento de excepciones

- try catch finally Bloques que son recorridos secuencialmente hasta encontrar el tipo de excepción que se disparó - try catch finally Bloque opcional que, en caso de existir, se ejecuta siempre - try catch finally Bloque que engloba el trozo de programa donde se desea controlar las excepciones

9 - ¿Cuáles de las siguientes sentencias Java son correctas?

	public void setRadio(Double radio) throw ExcepcionCirculoRadioNegativo{…}
	public class ExcepcionCirculoRadioNegativo extends RuntimeException {…}
	try{c.setRadio(4.);} catch { ExcepcionCirculoRadioNegativo ecr } {…}
	if (radio<0) throw new ExcepcionCirculoRadioNegativo(“Error”, radio);
	try {c.setRadio(-1.);} catch (ExcepcionCirculoRadioNegativo ecr) {…}

8 - ¿Cuáles de las siguientes cuestiones son comunes a las excepciones que heredan de RuntimeException y de Exception?

	En la signatura de los métodos que puedan lanzarlas estará una cláusula throws
	Sus constructores son similares
	Se lanzan con sentencias throw
	Se tratan con sentencias try-catch
	El error de compilación “Unhandled Exception”

7 - Si nos aparece un error de compilación “Unhandled Exception” entonces

	Significa que a la cláusula throw le falta el new
	Podemos solucionarlo con una sentencia try-catch
	Se trata de una excepción que hereda de RuntimeException
	Podemos solucionarlo con una cláusula throws en la cabecera del método
	Se trata de una excepción que hereda de Exception

6 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java?

	La captura de excepciones en una sentencia try-catch no termina el programa
	La sección finally es obligatoria en una sentencia try-catch
	Una sentencia catch correcta podría ser catch (ExcepcionCirculoRadioNegativo ecr) {….}
	El orden de las sentencias catch no importa
	En el bloque de sentencias bajo la cláusula try sólo puede haber llamadas a métodos que lanzan excepciones.

5 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java para la excepciones que heredan de RuntimeException (no comprobadas)?

	Sus constructores solo admiten argumentos de tipo String
	Se disparan con una sentencia throw
	La clase que las implementa debe tener en su declaración: extends RunTimeException
	La clase que las implementa debe tener en su declaración: implements RuntimeException
	Se pueden capturar y tratar mediante una sentencia try-catch

4 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java para la excepciones que heredan de Exception (comprobadas)?

	La clausula throws debe de ponerse también en la interfaz
	No pueden ser lanzadas o disparadas con una sentencia throw
	Si se capturan mediante una sentencia try-catch no hace falta poner throws en la cabecera
	Los métodos que las pueden disparar deben de tener en su cabecera una clausula throws
	Sólo pueden ser tratadas mediante una sentencia try

3 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java?

	Las excepciones permiten que un programa continúe al ser lanzadas con una sentencia throw
	Las excepciones que heredan de RuntimeException no pueden ser tratadas en una sentencia try
	En la invocación a super en el constructor de una excepción puede haber argumentos de distintos tipos
	Los constructores de una excepción pueden recibir argumentos de distinto tipo
	En un constructor de una clase excepción la única sentencia suele ser una llamada a super

2 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java?

	Una excepción debe implementar varios métodos
	Una excepción puede implementar varios constructores
	En la cabecera de una clase estará siempre la palabra implements
	Una excepción se implementa mediante una clase
	El código de un constructor de una excepción suele ser una llamada al constructor de la clase padre

1 - ¿Cuáles de las siguientes afirmaciones son ciertas en Java?

	Una excepción termina siempre con la ejecución del programa
	Las excepciones son errores en tiempo de ejecución
	Las excepciones se implementan mediante interfaces
	Las excepciones son errores en tiempo de compilación
	Las excepciones siempre son clases hijas de otras

C3.6 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	El método compareTo recibe un argumento del tipo que se quiere comparar
	La interfaz Comparable sirve para implementar un orden alternativo de un tipo
	El método compare debe devolver un valor mayor que 0 si el primer argumento es mayor que el segundo
	El método compare recibe un argumento del tipo que lo implementa
	Los métodos toString y hashCode son métodos que se heredan de Object

C3.7 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	La clase que implementa un orden alternativo debe implementar la interfaz Comparator
	El método compare debe devolver un valor menor que 0 si el primer argumento es mayor que el segundo
	La invocación p1.compareTo(p2) devuelve un int
	El método compareTo debe devolver un valor igual a 0 si el objeto this es igual al argumento formal
	La interfaz Comparator sirve para implementar el orden natural de un tipo

C3.8 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	El método compare debe devolver un valor mayor que 0 si el objeto this es mayor que el argumento formal
	La clase que implementa un orden alternativo debe extender la interfaz Comparator
	Un objeto de tipo Comparator se crea mediante el operador new
	Los métodos compareTo y equals son métodos que se heredan de Object
	Si c es un objeto de tipo Comparator, la invocación c.compare(p1,p2) devuelve un int

C3.9 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	El método compareTo recibe un argumento del tipo Object
	Si p1.compareTo(p2) es mayor que 0 entonces p1.equals(p2) debe ser false
	El método compare debe implementarse en la clase que implementa el tipo
	El método compareTo se implementa mediante invocaciones de los métodos compareTo de las propiedades del tipo
	Si p1.compareTo(p2) es igual a 0 entonces p1.equals(p2) debe ser true

C3.15 - El orden natural del tipo Persona es alfabético de apellidos, en caso de igualdad, alfabético de nombres y si persiste el empate, por DNI. Qué sentencias se podrían poner en la línea de puntos para que el programa sea coherente

Persona p1=new PersonaImpl("Pablo","García","31122334W",25);  
Persona p2=new PersonaImpl("María","García","28423123V",23);  

if (………………………………………………………){
       System.out.println(p1 + " es posterior en orden alfabético a "+p2);  
}

	compare(p1,p2)<0
	p1.compareTo(p2)<0
	p2.compareTo(p1)<0
	p1.compareTo(p2)>0
	p2.compareTo(p1)>0

C3.14 - Tenemos una clase ComparadorPersonaEdad que ordena objetos de tipo Persona por edad de menor a mayor. Qué sentencias se podrían poner en la línea de puntos para que el programa sea coherente(puede haber más de una)

Persona p1=new PersonaImpl("Antón","García Maratón","31122334W",23);  
Persona p2=new PersonaImpl("María","Pérez Piña","34423123V",25);  
Comparator c = new ComparadorPersonaEdad();  
if (………………………………………………………){
      System.out.println(p1 + " es más joven que "+p2);  
}

	c.compare(p2,p1)>0
	p1.compareTo(p2)>0
	c.compare(p1,p2)<0
	c.compare(p2,p1)<0
	c.compare(p1,p2)>0

C3.13 - Tenemos una clase ComparadorPersonaEdad que ordena objetos de tipo Persona por edad de menor a mayor. Qué sentencias se podrían poner en la línea de puntos para que el programa sea coherente

Persona p1=new PersonaImpl("Antón","García Maratón","31122334W",25);  
Persona p2=new PersonaImpl("María","Pérez Piña","34423123V",23);  
Comparator c = new ComparadorPersonaEdad();  
if (………………………………………………………){
             System.out.println(p1 + " tiene más edad que "+p2);  
}

	c.compare(p1,p2)>0
	c.compare(p2,p1)>0
	c.compare(p2,p1)<0
	p1.compareTo(p2)>0
	c.compare(p1,p2)<0

C3.12 - Queremos construir un orden alternativo para Punto de forma que después podamos ordenar un List por la abscisa de cada Punto de mayor a menor, esto es, primero los puntos de mayor X y al final de la lista los puntos de menor X. Entonces si la cabecera del método compare es int compare (Punto p1, Punto p2) el cuerpo del método tiene la sentencia:

	return compare(p1.getX(),p2.getX());
	ninguna de las restantes
	return p1.getX().compareTo(p2.getX());
	return p2.getX().compareTo(p1.getX());
	return p1.getX().compare(p2.getX());

C3.11 - Si lp es un objeto de tipo List y p un objeto de tipo Punto entonces cuáles de las siguientes invocaciones son correctas

	Collections.min(lp, new ComparadorPunto());
	Collections.sort(lp, new ComparadorPunto());
	lp=Collections.sort(lp);
	Collections.sort(lp);
	p=Collections.min(lp);

t3.5 - Dos objetos de tipo Punto son iguales si coinciden sus coordenadas x e y cuyo acceso es mediante los métodos getX y getY. Complete el método equals para que compruebe si dos puntos son iguales. (No deje más espacios en blanco que los estrictamente necesarios)

public   ( o) {   
     boolean ;   
     if(){    
         Punto p = ;    
         res = ;   
     }
     return res;  
}

t3.7 - Complete el método hashCode del tipo Punto usando los métodos getX y getY

public  hashCode() {     
      return  + 31 * ;  
}

C3.10 - ¿Cuáles de las siguientes afirmaciones son correctas en Java?

	El método sort de la clase Collections recibe un List y devuelve otro List ordenado
	El método min de la clase Collections devuelve void
	Los métodos de la clase Collections se invocan desde un objeto de tipo List
	La clase Collections es una clase de utilidad
	El método sort de la clase Collections devuelve void

---

Puntuacion Total
Aciertos
Aciertos Parciales