Title: Parte10
Course: 2025 - LISI - Programacion Orientada a Objetos 1-3

Q: ___________ se adjunta a la clase de la clase que la compone para denotar la relación de agregación con el objeto compuesto.
- Un diamante vacío
- Un diamante lleno
- Un óvalo vacío
- Un óvalo lleno
A: Un diamante vacío

Q: Una relación de agregación suele representarse como __________ en ___________.
- Un campo de datos/la clase de agregación
- Un campo de datos/la clase agregada
- Un método/la clase agregante
- Un método/la clase agregada
A: Un campo de datos/la clase de agregación

Q: Composición significa ______________.
- que los campos de datos deben declararse privados
- que una clase extiende a otra clase
- que una variable de supertipo se refiere a un objeto de subtipo
- que una clase contiene un campo de datos que hace referencia a otro objeto
A: que una clase contiene un campo de datos que hace referencia a otro objeto

Q: ¿Cuál de las siguientes afirmaciones convertirá una cadena 's' a un valor entero 'i'? Seleccione todas las que correspondan
- ```i = Integer.parseInt(s);```
- ```i = (new Integer(s)).intValue();```
- ```i = Integer.valueOf(s).intValue();```
- ```i = Integer.valueOf(s);```
- ```i = (int)(Double.parseDouble(s));```
A: ```i = Integer.parseInt(s);```; ```i = (new Integer(s)).intValue();```; ```i = Integer.valueOf(s).intValue();```; ```i = Integer.valueOf(s);```; ```i = (int)(Double.parseDouble(s));```

Q: ¿Cuál de las siguientes afirmaciones convertirá una cadena 's' a un valor double 'd'? Seleccione todas las que correspondan.
- ```d = Double.parseDouble(s);```
- ```d = (new Double(s)).doubleValue();```
- ```d = Double.valueOf(s).doubleValue();```
A: ```d = Double.parseDouble(s);```; ```d = (new Double(s)).doubleValue();```; ```d = Double.valueOf(s).doubleValue();```

Q: ¿Cuáles de las siguientes afirmaciones son correctas? Seleccione todas las que correspondan.
- ```Integer.parseInt("12", 2);```
- ```Integer.parseInt(100);```
- ```Integer.parseInt("100");```
- ```Integer.parseInt(100, 16);```
- ```Integer.parseInt("345", 8);```
A: ```Integer.parseInt("100");```; ```Integer.parseInt("345", 8);```

Q: ¿Cuál es la salida de la siguiente sentencia? ```Integer.parseInt("10", 2);```
- 1;
- 2;
- 10;
- Invalid statement;
A: 2;

Q: ¿Cuáles de las siguientes afirmaciones convierte un valor double 'd' a una cadena 's'? Seleccione todas las que correspondan.
- ```s = Double.valueOf(d).toString();```
- ```s = d;```
- ```s = Double.valueOf(d).stringOf();```
- ```s = String.stringOf(d);```
- ```s = d + "";```
A: ```s = Double.valueOf(d).toString();```; ```s = d + "";```

Q: Puede asignar directamente un valor de tipo de datos primitivo a un objeto contenedor. A esto se le llama ______________.
- auto boxing
- auto unboxing
- auto conversion
- auto casting
A: auto boxing

Q: Considere el siguiente código. Seleccione todas las que correspondan.
[Image: 1010]
- Está bien asignar 1, 2, 3 a una matriz de objetos enteros en JDK 1.5.
- Está bien convertir automáticamente un objeto Integer en un valor int en la línea 2.
- Está bien mezclar un valor int con un objeto Integer en una expresión de la línea 3.
- La línea 4 está bien. Un valor int del objeto intArray[0] se asigna a una variable doble d.
A: Está bien asignar 1, 2, 3 a una matriz de objetos enteros en JDK 1.5.; Está bien convertir automáticamente un objeto Integer en un valor int en la línea 2.; Está bien mezclar un valor int con un objeto Integer en una expresión de la línea 3.; La línea 4 está bien. Un valor int del objeto intArray[0] se asigna a una variable doble d.

Q: Para crear una instancia de BigInteger con el número 454, se debe utilizar ________________. Seleccione todas las que correspondan.
- ```BigInteger.valueOf(454);```
- ```new BigInteger(454);```
- ```BigInteger.valueOf("454");```
- ```new BigInteger("454");```
A: ```BigInteger.valueOf(454);```; ```new BigInteger("454");```

Q: Seleccione todas las que correspondan. Para sumar un BigInteger b1 a un BigInteger b2 (es decir, asignar el resultado a b2), escriba _________.
- ```b1.add(b2);```
- ```b2.add(b1);```
- ```b2 = b1.add(b2);```
- ```b2 = b2.add(b1);```
- ```b1 = b2.add(b1);```
A: ```b2 = b1.add(b2);```; ```b2 = b2.add(b1);```

Q: ¿Cuál es la salida del siguiente código?
[Image]
- 3
- 4
- 10
- 11
A: 3

Q: Para crear una instancia de BigDecimal con el número 454.45, utilice ___________. Seleccione todas las que correspondan.
- ```BigDecimal.valueOf(454.45);```
- ```new BigDecimal(454.45);```
- ```BigDecimal("454.45");```
- ```new BigDecimal("454.45");```
A: ```BigDecimal.valueOf(454.45);```; ```new BigDecimal("454.45");```

Q: BigInteger y BigDecimal son inmutables.
- Verdadero
- Falso
A: Verdadero

Q: Considere dos objetos BigDecimal b1 y b2. Para dividir b1 entre b2 y asignar el resultado a b1, se debe escribir_________________________
- ```b1.divide(b2);```
- ```b2.divide(b1);```
- ```b1 = b1.divide(b2, 20, RoundingMode.HALF_UP);```
- ```b1 = b2.divide(b1, 20, RoundingMode.HALF_UP);```
- ```b2 = b2.divide(b1, 20, RoundingMode.HALF_UP);```
A: ```b1 = b1.divide(b2, 20, RoundingMode.HALF_UP);```

Q: ¿Cuáles de las siguientes clases son inmutables? Seleccione todas las que correspondan.
- ```Integer```
- ```Double```
- ```BigInteger```
- ```BigDecimal```
- ```String```
A: ```Integer```; ```Double```; ```BigInteger```; ```BigDecimal```; ```String```

Q: ¿Cuáles de las siguientes declaraciones de instancias son correctas?
- ```new java.math.BigInteger("343");```
- ```new java.math.BigDecimal("343.445");```
- ```new java.math.BigInteger(343);```
- ```new java.math.BigDecimal(343.445);```
A: ```new java.math.BigInteger("343");```; ```new java.math.BigDecimal("343.445");```

Q: ¿Cuál de las siguientes declaraciones es preferible para crear una cadena con el mensaje "Bienvenido a Java"?
- ```String s = "Bienvenido a Java";```
- ```String s = new String("Bienvenido a Java");```
- ```String s; s = "Bienvenido a Java";```
- ```String s; s = new String("Bienvenido a Java");```
A: ```String s = "Bienvenido a Java";```

Q: Analice el siguiente código.
[Image]
- El programa tiene un error de compilación porque s no se inicializa, pero se hace referencia a él en la instrucción println.
- El programa tiene un error de tiempo de ejecución porque s no está inicializado, pero se hace referencia a él en la instrucción println.
- El programa tiene un error de tiempo de ejecución porque s es null en la instrucción println.
- El programa se compila y funciona bien.
A: El programa tiene un error de compilación porque s no se inicializa, pero se hace referencia a él en la instrucción println.

Q: ¿Cuál es el resultado del siguiente código?
[Image]
- s1 y s2 hacen referencia al mismo objeto String
- s1 y s2 hacen referencia a diferentes objetos String
A: s1 y s2 hacen referencia al mismo objeto String

Q: ¿Cuál es la salida del siguiente código?
[Image]
- s1 y s2 hacen referencia al mismo objeto String
- s1 y s2 hacen referencia a diferentes objetos String
A: s1 y s2 hacen referencia al mismo objeto String

Q: ¿Cuál es la salida del siguiente código?
[Image]
- s1 y s2 hacen referencia al mismo objeto String
- s1 y s2 hacen referencia a diferentes objetos String
A: s1 y s2 hacen referencia a diferentes objetos String

Q: ¿Cuál es la salida del siguiente código?
[Image]
- s1 y s2 tienen el mismo contenido
- s1 y s2 tienen contenidos diferentes
A: s1 y s2 tienen el mismo contenido

Q: ¿Cuál es la salida del siguiente código?
[Image]
- s1 y s2 hacen referencia al mismo objeto String
- s1 y s2 tienen el mismo contenido
- s1 y s2 son objetos diferentes
A: s1 y s2 son objetos diferentes

Q: Suponga que s1 y s2 son dos cadenas. ¿Cuáles de las siguientes afirmaciones o expresiones son incorrectas? Seleccione todas las que correspondan.
- ```String s = new String("nueva cadena");```
- ```String s3 = s1 + s2```
- ```s1 >= s2```
- ```int i = s1.length```
- ```s1.charAt(0) = '5'```
A: ```s1 >= s2```; ```int i = s1.length```; ```s1.charAt(0) = '5'```

Q: ¿Cuál es la salida del siguiente código?
[Image]
- UnABCversidad
- UnABCversABCad
- UniversABCad
- Universidad
A: Universidad

Q: Suponga que s contiene la cadena "ABCABC", el método __________ devuelve una nueva cadena "aBCaBC". Seleccione todas las que correspondan.
- ```s.change('A', 'a')```
- ```s.change('a', 'A')```
- ```s.replace('A', 'a')```
- ```s.replace('a', 'A')```
- ```s.replace("ABCABC", "aBCaBC")```
A: ```s.replace('A', 'a')```; ```s.replace("ABCABC", "aBCaBC")```

Q: ¿Cuál es la salida del siguiente código?
[Image]
- Bienvenido a Java
- Bien enido a Java
- Bien venido Java
- Bienvenido java
A: Bien venido Java

Q: ¿Qué muestra la siguiente afirmación?
```System.out.println("Java es genial".replaceAll("is", "AAA"));```
- JavaAAAgenial
- JavaAAA genial
- Java AAA genial
- Java AAAgenial
A: Java AAA genial

Q: ¿Qué muestra el siguiente código?
[Image]
- false false
- true false
- true true
- false true
A: false true

Q: ¿Qué muestra el siguiente código?
[Image]
- A B C A#B#C
- A #B#C A#B#C
- A,B; C A#B#C
- A B C A B C
A: A,B; C A#B#C

Q: ¿Qué muestra el siguiente código?
[Image]
- A,B;C;D
- A B C D
- A B C;D
- A B;C;D
A: A B C D

Q: ¿Cuál de las siguientes opciones es la declaración correcta para devolver una cadena de una matriz de caracteres?
- ```toString(a)```
- ```new String(a)```
- ```convertToString(a)```
- ```String.toString(a)```
A: ```new String(a)```

Q: Supongamos que s es " abc ", el método __________ devuelve una nueva cadena "abc".
- ```s.trim(s)```
- ```trim(s)```
- ```String.trim(s)```
- ```s.trim()```
A: ```s.trim()```

Q: Asuma que la cadena s contiene "ABCABC"; el método______________________retorna un arreglo de caracteres.
- ```toChars(s)```
- ```s.toCharArray()```
- ```String.toChars()```
- ```String.toCharArray()```
- ```s.toChars()```
A: ```s.toCharArray()```

Q: __________ devuelve una cadena. Seleccione todas las que correspondan.
- ```String.valueOf(123)```
- ```String.valueOf(12.53)```
- ```String.valueOf(false)```
- ```String.valueOf(new char[]{'a', 'b', 'c'})```
A: ```String.valueOf(123)```; ```String.valueOf(12.53)```; ```String.valueOf(false)```; ```String.valueOf(new char[]{'a', 'b', 'c'})```

Q: El siguiente programa muestra __________.
[Image]
- Java
- Java y HTML
- Y HTML
- no se muestra nada
A: Java

Q: Analice el siguiente código.
[Image]
- El programa tiene un error de compilación porque no se puede especificar la capacidad inicial en el constructor StringBuilder.
- El programa tiene un error de tiempo de ejecución debido a que la capacidad del generador es 4, se agregan cinco caracteres "ABCDE" en el generador.
- El programa tiene un error de tiempo de ejecución porque la longitud de la cadena en el generador es 5 después de que se agrega "ABCDE" en el generador. Por lo tanto, strBuilder.charAt(5) está fuera de rango.
- El programa se compila y funciona bien.
A: El programa tiene un error de tiempo de ejecución porque la longitud de la cadena en el generador es 5 después de que se agrega "ABCDE" en el generador. Por lo tanto, strBuilder.charAt(5) está fuera de rango.

Q: El siguiente programa muestra __________.
[Image]
- Java
- Java y HTML
- Y HTML
- no se muestra nada
A: Java y HTML

Q: ¿Cuál de las siguientes afirmaciones es verdadera? Seleccione todas las correctas.
- Puede agregar caracteres a un generador de cadenas.
- ```String.valueOf(12.53)```
- ```String.valueOf(false)```
- ```String.valueOf(new char[]{'a', 'b', 'c'})```
A: Puede agregar caracteres a un generador de cadenas.; ```String.valueOf(12.53)```; ```String.valueOf(false)```; ```String.valueOf(new char[]{'a', 'b', 'c'})```

Q: Suponga que StringBuilder strBuilder es "ABCDEFG", después de invocar _________, strBuilder contiene "AEFG".
- ```strBuilder.delete(0, 3)```
- ```strBuilder.delete(1, 3)```
- ```strBuilder.delete(1, 4)```
- ```strBuilder.delete(2, 4)```
A: ```strBuilder.delete(1, 4)```

Q: Supongamos que StringBuilder strBuilder es "ABCDEFG", después de invocar _________, strBuilder contiene "ABCRRRRDEFG".
- ```strBuilder.insert(1, "RRRR")```
- ```strBuilder.insert(2, "RRRR")```
- ```strBuilder.insert(3, "RRRR")```
- ```strBuilder.insert(4, "RRRR")```
A: ```strBuilder.insert(3, "RRRR")```

Q: Supongamos que StringBuilder strBuilder es "ABCCEFC", después de invocar _________, strBuilder contiene "ABTTEFT".
- ```strBuilder.replace('C', 'T')```
- ```strBuilder.replace("C", "T")```
- ```strBuilder.replace("CC", "TT")```
- ```strBuilder.replace('C', "TT")```
- ```strBuilder.replace(2, 7, "TTEFT")```
A: ```strBuilder.replace(2, 7, "TTEFT")```

Q: Los métodos StringBuilder _____________ no solo cambian el contenido de un constructor de cadenas, sino que también devuelven una referencia al constructor de cadenas. Seleccione todas las que correspondan.
- ```delete```
- ```append```
- ```insert```
- ```reverse```
- ```replace```
A: ```delete```; ```append```; ```insert```; ```reverse```; ```replace```

Q: _________ retorna el último caracter de una variable strBuilder.
- ```strBuilder.charAt(strBuilder.length() - 1)```
- ```strBuilder.charAt(strBuilder.capacity() - 1)```
- ```StringBuilder.charAt(strBuilder.length() - 1)```
- ```StringBuilder.charAt(strBuilder.capacity() - 1)```
A: ```strBuilder.charAt(strBuilder.length() - 1)```