Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

PREGUNTA:  Si a = true y b = false, la expresión:

!(!(a || b) && !(a))

Toma el mismo resultado que:

a) a && b

b) !(a || !b)

c) b ll (a&&b)

d) !(!a || b) || !b






RESPUESTA: la respuesta correcta es la d). Pregunta con bastante mala idea ya que es bastante liosa mezclando símbolos. Es probable que terminemos con un dolor de cabeza después de haber estado un rato dándole vueltas. Hay que tener en cuenta que el orden de precedencia de los operadores es:

1º) Operadores unarios como ! y -
2º) Operadores multiplicativos *, /, %
3º) Operadores aditivos: +, -
4º) Comparación matemática: >, >=, <, <=
5º) Comparación de igualdad: ==, !=
6º) Conjunción &&
7º) Disyunción ||

Y también que dentro de un mismo nivel, la ejecución es de izquierda a derecha.

Si a= true y b=false y evaluamos la expresión inicial tenemos:

! ( !( true || false) && !(true))

!(true) devuelve false

x && false devuelve false, luego la expresión interior !(a || b) && !(a) devuelve false. Al tener toda la expresión negada, el resultado final es true.

La opción a) plantea true && false, que devuelve false, con lo cual no puede ser solución.

La opción b) plantea !(true || !false), lo interior devuelve true y el resultado global es false con lo cual no puede ser solución.

La opción c) plantea false || ... que devolverá false.

Conclusión: la opción correcta es la d), que nos permite obtener true (aparte del dolor de cabeza) 

PREGUNTA: En el lenguaje C± ("c más menos"), la sentencia catch:

a) Agrupa las sentencias para el tratamiento de la excepción

b) Agrupa las sentencias para la detección de la excepción

c) Devuelve el resultado de la excepción

d) Devuelve el resultado de la excepción y termina el programa




RESPUESTA: La correcta es la a). Dentro de una sentencia catch escribimos todas las instrucciones que deben ejecutarse cuando se captura una excepción, es decir, nos sirve para agrupar las sentencias para el tratamiento de la excepción.

No estoy seguro porque esto habría que probarlo compilando código, pero me resulta un poco extraña esta parte del código:

String a = jTextField1.getText().toString();
       String b = jTextField2.getText().toString();
       String c = jTextField3.getText().toString();
       String d = jTextField4.getText().toString();
       String e = jTextField5.getText().toString();
       String f = jTextField6.getText().toString();
       st.executeUpdate("INSERT INTO pacientes (nombre, ci, fechanac, ingreso, ultima, proxima) VALUES ("jTextField1.getText().toString()", "jTextField2.getText().toString()", "jTextField3.getText().toString()", "jTextField4.getText().toString()", "jTextField5.getText().toString()",  "jTextField6.getText().toString()")");   


Al método executeUpdate le probaría a pasar esto:

st.executeUpdate("INSERT INTO pacientes (nombre, ci, fechanac, ingreso, ultima, proxima) VALUES ('"+jTextField1.getText().toString()+"', '"+jTextField2.getText().toString()+"', '"+jTextField3.getText().toString()+"', '"jTextField4.getText().toString()+"', '"+jTextField5.getText().toString()+"',  '"jTextField6.getText().toString()+"')");

Cada campo a insertar, entre apóstrofes, y cada string entre comillas; para que interprete la invocación del método bien como un string, precederlo y ponerle después el símbolo +. Puedes probar a ver si va.

PREGUNTA: Indicar si la siguiente afirmación es verdadera o falsa:

"La clase Vector de Java define un tipo de colección y un tipo de lista. "


RESPUESTA:

Es verdadera, hemos dicho que la clase vector tiene gran similitud con ArrayList, y al igual que ArrayList es una colección y un tipo de lista.

¿Pero el código que te he puesto no resuelve el comportamiento de tu clase?

Esto puede tener su complejidad. Para empezar veamos la línea:

$sql = "SELECT * FROM usuarios WHERE username='$user' AND password='$pass' ";

El comportamiento esperado sería que en user y password tengamos un usuario y contraseña normal, como "juan" y "alegria2012" . Al ejecutar la consulta tendríamos:

$sql = "SELECT * FROM usuarios WHERE username='juan' AND password='alegria2012' ";

Un ataque podría venir si se introduce como contraseña:

unacualquiera’  OR PASSWORD LIKE '%

El código de color es la inyección SQL a través de la cual el hacker o quien sea está intentando acceder maliciosamente. Lo que la query quedaría así:

$sql = "SELECT * FROM usuarios WHERE username='juan' AND password='unacualquiera’  OR PASSWORD LIKE '%
 
En este caso trata de entrar sin hacer más daño, pero podría escribir:

unacualquiera; DROP TABLE usuarios

Lo cual sería un intento por borrar la tabla de usuarios de la base de datos.

Una primera validación podría consistir en un condicional que busque caracteres como comas, puntos y comas, signo igual, paréntesis, palabras claves SQL como LIKE, TABLE, DROP, %, etc. y en caso de ser detectado no ejecutar el query.

Hay varias maneras de hacerlo, yo probaría algo así.
 
import java.net.URL;
import java.io.BufferedReader;

URL url = new URL("http://wwis.inm.es/057/c00879.htm");
BufferedReader bs = new BufferedReader(new InputStreamReader(url.openStream()));     
String txt;           
while ((txt = bs.readLine()) != null) System.out.println(txt);

En primer lugar le daría un repaso a las clases que intervienen para comprender lo que se pretende. Luego yo comprobaría que puedo meter el contenido de texto en una variable y leer el contenido. Una vez tuviera probado esto, procedería a analizar cómo puedo extraer exactamente los datos que a mí me interesan, ya que aparte de lo que a tí te interesa vendrán más cosas. La cuestión es ir probando.

¿A qué te refieres con refactorizar? Refactorizar suele aludir a reordenar el código, pero esto suele hacerse con algún fin. ¿Qué fin es el que persigues? Por ejemplo podríamos refactorizar empleando if ... en lugar de switch, pero se supone que si hacemos esto es buscando algo ¿qué buscas? Otra forma de refactorizar sería definir cuadrado, circulo y triangulo_recto como subclases de forma. Esto sería bastante lógico y adecuado a la programación orientada a objetos, ya que usaríamos herencia. Esta sería una refactorización que yo probablemente haría, pero no entiendo bien qué es lo que buscas.

Y respecto a las pruebas, a la hora de probar tienes que definir qué quieres probar. Por ejemplo, podríamos querer probar distintas cosas:

a) Que se pueden crear objetos de tipo Forma
b) Que se pueden crear objetos de tipo Forma cuyo atributo tipoForma sea 1
c) Que se pueden crear objetos de tipo Forma cuyo atributo tipoForma sea 2
d) Que se pueden crear objetos de tipo Forma cuyo atributo tipoForma sea 3
e) Que el cálculo de área para un objeto de tipo Forma cuyo atributo tipoForma es CUADRADO devuelve un valor correcto
f) Que el cálculo de área para un objeto de tipo Forma cuyo atributo tipoForma es CIRCULO devuelve un valor correcto
g) Que el cálculo de área para un objeto de tipo Forma cuyo atributo tipoForma es TRIANGULO_RECTO devuelve un valor correcto

Si vas a refactorizar lo lógico es primero refactorizar y luego plantear las pruebas.

Para plantear las pruebas, lo primero que tienes que saber es qué quieres probar.

Te digo un posible planteamiento:

lo primero es definir la clase que queremos probar. Yo voy a definir:

public class Multiplicador {

    //No declaramos campos

    public Multiplicador () {
        //Nada que declarar
    }

    public int multiplica (int a, int b) {       return a*b;   }

}

Esta clase simplemente me permite crear un objeto con un método que devuelve el resultado de multiplicar dos números.

Ahora voy a probar con JUnit que el método devuelve el resultado correcto. Para ello creo una clase de test donde se pide al usuario que entre por teclado dos números y se comprueba que el resultado sea correcto:

import java.util.Scanner;
public class MultiplicadorTest extends junit.framework.TestCase {
    private Multiplicador objeto1;

    public void testOperacion(){
        System.out.println ("Por favor introduce el primer número");
        int entradaTeclado1 = 0;
        Scanner sc1 = new Scanner(System.in);
        entradaTeclado1 = Integer.parseInt(sc1.nextLine());
        System.out.println ("Por favor introduce el segundo número");
        int entradaTeclado2 = 0;
        Scanner sc2 = new Scanner(System.in);
        entradaTeclado2 = Integer.parseInt(sc2.nextLine());
        objeto1 = new Multiplicador();
        int resultado;
        resultado = objeto1.multiplica(entradaTeclado1, entradaTeclado2);
        assertEquals (resultado, entradaTeclado1*entradaTeclado2);
    }

}


Al ejecutar el método test JUnit me dice "OK"; si escribiéramos

assertEquals (99, entradaTeclado1*entradaTeclado2);

El resultado que obtendríamos sería junit.framework.AssertionFailedError: expected:<99> but was:<20>, es decir, en este caso no se cumple la aserción que hemos especificado.

PREGUNTA: Indicar si la siguiente afirmación es verdadera o falsa:

"Los vectores u objetos de la clase Vector son bastante similares a los ArrayList. Las diferencias hay que buscarlas a nivel interno."




RESPUESTA: es verdadera. Tener en cuenta que en general la clase ArrayList es más usada y recomendada que la clase Vector precisamente por esas diferencias que presenta a nivel interno.