B3-T6_JAVA Flashcards

(120 cards)

1
Q

En Java8, ¿cómo se define un INTERFACE?

A

Es una colección de MÉTODOS (con o sin implementación, pues, a partir de Java8, se pueden implementar con “Default”) y una serie de CONSTANTES (Ej: Static Final).
Una interface no tiene sentido que tenga “atributos”.

“Las interfaces pueden ser implementadas por otras clases para usar sus métodos o funciones”.

IMPORTANTE: las INTERFACES se declaran con la palabra clave implements. En cambio, las HERENCIAS se declaran con extends.
NOTA: Una CONSTANTE se diferencia de un ATRIBUTO, en que su valor NO varia.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
2
Q

¿En qué se diferencian IDE (Entorno de Desarrollo Integrado) y GUI (Interfaz de Usuario Gráfica) y pon ejemplos?

A

Un IDE es un entorno que sirve para desarrollar programas o software. Generalmente un IDE tiene un editor de código, un compilador o intérprete, y un depurador de código del programa en desarrollo.

En tanto un GUI es una interfaz gráfica de usuario, que proporciona un entorno visual gráfico que permite que un humano utilice un sistema operativo o un software.

En resumen, un entorno de desarrollo integrado (IDE) es un sistema de software para el diseño de aplicaciones que combina herramientas del desarrollador comunes en una sola interfaz gráfica de usuario (GUI).

NOTA: un depurador de código realiza el proceso de encontrar y solucionar errores en el código fuente de cualquier software

IDE: BlueJ, Eclipse, JDK (Oracle), JBuilder, JCreator, JDeveloper, IntelliJ IDEA, …

GUI:
1. Los entornos de escritorio Windows o concretamente la interfaz Aero (que puede deshabilitarse), introducida en Windows Vista
2. En GNU/Linux: X Windows, Open Look, GNOME o KDE.
3. O el de Mac OS X: Aqua

IMPORTANTE: la JRE esta incluida en la JDK. Algunas JDKs:

*OpenJDK
*Amazon Correto
*IBM JDK

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
3
Q

¿Qué es JRE (Java Runtime Environment) en Java?

A

Entorno de ejecución de Java o máquina virtual de Java (JVM) + las bibliotecas de clases y otros componentes para que una aplicación escrita en lenguaje Java pueda ser ejecutada en MÚLTIPLES PLATAFORMAS.
El JRE interactúa con el Java Development Kit (JDK) para ejecutar archivos de programas de Java en cualquier máquina.

Al ser Java multi-plataformas (principal característica de Java) implica que el programa primero hay que compilarlo (JDK) y luego interpretarlo (JRE):

  1. COMPILARLO: pasar el código fuente de nuestro programa (programa.java) a código máquina (bytecode.class), que es el que será interpretado en cualquier plataforma:

programa.java -(Eclipse)-> bytecodes.class (este es interpretado en las JREs)

NOTA: el compilador de java se llama JavaC.

  1. INTERPRETAR: proceso que realiza la JRE de cualquier plataforma para “entender” el bytecodes.class. Es decir, el fichero.class es el bytecode.

NOTA: página de descarga de la JRE => java.com

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
4
Q

Resume la historia de Java:

A

1991: Creado por James Gosling y Patric Naughton, en la empresa Sun Microsystem (ya NO existe, fue absorbida por Oracle).

NOMBRES: OAK (roble) x Gosling -> JAVA (tomar café).

1995: con la llegada de internet es cuando tuvo éxito, ya que funciona en cualquier plataforma. Crearon el navegador “Hot Java”.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
5
Q

¿Cuáles son las características de Java?

A

SENCILLO: ocupa poco.

ORIENTADO A OBJETOS.

DISTRIBUIDO: buen trato en red.

SEGURO: como se hizo para programar en red, se hizo seguro.

NEUTRO: multiplataformas.

ADAPTABLE: mismos tipos de datos primitivos en todas las plataformas.

INTERPRETADO: se compila y luego se interpreta.

MULTI HILO: varios procesos en paralelo.

CASE SENSITIVE.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
6
Q

¿Cuál es el modificador de acceso del siguiente método de Java y explicalos todos?

*public static void main (String args []) {

}

A

El modificador de acceso es public e indica que el método es accesible desde cualquier lugar del código.
En la foto vemos los otros 3 Modificadores de Acceso y sus alcances.

*“void” indica que el método main no retorna ningún valor, es decir, el método finalizará en ese punto sin ejecutar ninguna linea más.

*(String args []) => es la definición de los argumentos que recibe el método main. [] -> indica que el argumento es un arreglo o matriz. String -> tipo de elemento del arreglo.

NOTA: En Java, los arreglos (matrices o arrays) son objetos. Todos los métodos se pueden ser invocados en un arreglo (objeto).
Y un arreglo u objeto es una estructura de datos utilizada para almacenar datos del mismo tipo.

En Java TODA aplicación empieza a ejecutarse desde un método MAIN

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
7
Q

Sabemos que al ser Java un lenguaje ADAPTABLE sus Tipos Primitivos son iguales en todas las plataformas (multiplataforma o neutro), pero ¿cuáles son?

A
  1. ENTEROS: números enteros (7, 2500, …).

1.1. LONG: (8 bytes). Números muy grandes y usan el sufijo “L”.
Ej: 5.000.000.000L

1.2. INT: (4 bytes)
del -2.147.483.648 al 2.147.483.648

1.3. SHORT: (2 bytes)
del -32.768 al 32.768

1.4. BYTE: (1 byte)
del -128 al 127

  1. DECIMALES:

2.1. DOUBLE: (8 bytes) Aproximadamente 15 cifras significativas.
Ej: 4,31122639824

2.2. FLOAT: (4 bytes) Aproximadamente 6 a 7 cifras significativas. Sufijo “F”.
Ej: 3.25F

  1. CHAR: para representar caracteres. Van entre comillas SIMPLES.
    Ej: la letra a -> ‘a’ => caracter unicode.
  2. BOOLEAN: True / False

COMODINES: para almacenar variables se suelen usar:
ENTEROS -> int
DECIMALES -> double

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
8
Q

¿Qué es una variable en Java y cómo se crea (declaración+iniciación)?

A

Espacio en la memoria RAM del ordenador donde se almacena un valor que podrá cambiar durante la ejecución de un programa => VARIABLE (siempre se ejecutará la última variable => siempre se ejecutan las instrucciones por orden).

Para DECLARARLAS, hay que especificar el tipo de dato que almacenará en su interior + el nombre de la variable:
int salario;

Para INICIARLA, hay que darle un valor: (en Java, al contrario que otros lenguajes, no permite usar variables que no se hayan iniciado o dado cierto valor)
salario = 1800;

*Aunque se pueden hacer las 2 cosas a la vez:

int salario = 1800; => reserva y almacena a al vez el espacio en la RAM

COMODINES: para almacenar variables se suelen usar:
ENTEROS -> int
DECIMALES -> double

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
9
Q

¿Cuáles son las 2 maneras de añadir comentarios en Java?

A

// comentarios en 1 linea

/* comentarios
en varias
lineas */

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
10
Q

¿Cómo se guarda una clase en Java?

A

Ctrl+S (Save) => lo guarda en la carpeta “bin” con extensión .class (bytecode) y en la carpeta “src” se guarda el archivo compilado (.java).

NOTA: *PROGRAMA.JAVA => el * indica que aún NO se han guardado los cambios.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
11
Q

Sabemos que Java es POO y que todo es considerado un objeto, incluso la consola, pero ¿qué es un objeto?

A

Es una entidad que representa información sobre una cosa dentro de la CLASE.
Tienen PROPIEDADES (ancho, alto, color, …) y MÉTODOS (lo que puede hacer el objeto: frenar, acelerar, …)
EJEMPLO: System.out.println (edad);

/le estamos pidiendo que el objeto “out” (consola) del SISTEMA imprima (println) la variable “edad”/

System => sistema
println => método
out => OBJETO

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
12
Q

¿Qué es una CONSTANTE de Java?

A

Es un espacio en la memoria RAM que, a diferencia de la VARIABLE, no podrá cambiar durante la ejecución del programa. De hecho, se declara igual que la VARIABLE, pero se añade al principio final.

Es necesario para guardar datos que necesitaremos en un futuro y/o constantemente. Por ejemplo, para hacer un programa que pase de cm a metros => en el que almacenaríamos las unidades como CONSTANTES.

EJEMPLO:
final double pulgadas = 2,54;
final byte edad = 42;

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
13
Q

¿Cuáles son los operadores de Java?

A
  1. ARITMÉTICOS: +, -, * y /.
  2. INCREMENTO y DECREMENTO:
    ++ => INCREMENTO: incrementa en “1” el valor al que lo estés aplicando.
    – => DECREMENTO: lo contrario al anterior.
    += n => incrementa o suma “n” al valor al que lo apliques.
    -= n => lo contrario al anterior.
  3. CONCATENACIÓN: unen valores (conjuntos de caracteres con números o variables).
    + => une o concatena.

NOTA: hay otros 2 tipos de operadores:
3. Lógicos, Relacionales y Booleanos.
4. Binarios

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
14
Q

¿Cuáles son los operadores de Java: Lógicos, Relacionales y Booleanos?

A
  1. Lógicos, Relacionales y Booleanos:
    > mayor que
    < menor que
    <> mayor o menor que
    == igual que
    != distinto que
    && (“y” lógico) cuando comparamos varias condiciones y dará TRUE si se cumplen todas:
    EJ: condicion1&&condicon2&&condicon3 => si se cumplen todas dará TRUE.
    ||(“o” lógico) cuando comparamos varias condiciones y dará TRUE con que se cumpla 1:
    EJ: condicion1||condicon2||condicon3 => con que se cumpla 1 dará TRUE.
    ! (NOT) devuelve el valor contrario a TRUE.
    ? (“if” en linea)

NOTA: hay otros 3 tipos de operadores:
1. ARITMÉTICOS.
2. INCREMENTO y DECREMENTO.
4. Binarios

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
15
Q

¿Cuáles son los operadores de Java: BINARIOS?

A

Los operadores BINARIOS cambian “0s” y “1s” y viceversa.

a) | (OR binario) OR INCLUSIVO => siempre que haya un 1 en cualquier lado del par, el resultado será 1.

0101 (decimal 5) |
0011 (decimal 3)
0111 (decimal 7) => RESULTADO

b) ^ (XOR lógico) OR EXCLUSIVO => El resultado será 1 si el par de bits son diferentes y cero son iguales.

0101 (decimal 5) ^
0011 (decimal 3)
0110 (6) => RESULTADO

c) ~ (complemento) operador negación (NOT). Lo contrario.

~ (0111) => 1000 (8 decimal)

d) & operador bits AND: sólo iguales.

0101 AND
0011
0001 (1) => RESULTADO

NOTA: hay otros 3 tipos de operadores:
1. ARITMÉTICOS.
2. INCREMENTO y DECREMENTO.
3. Lógicos, Relacionales y Booleanos.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
16
Q

Explica el funcionamiento de los operadores de Java de DESPLAZAMIENTO?

A

A < < B : Desplazamiento de A a la izquierda en B posiciones:
Ej: (0011) < < (0001) // Desplaza 0011 una vez dando 110
(0011) < < (0011) // Desplaza 0011 tres veces dando 11000 (son 3 veces porque 0011=3)

A > > B : Desplazamiento de A a la derecha en B posiciones, tiene en cuenta el signo:
(1100) > > (0001) // Desplaza 1100 una vez dando 0110
(1000) > > (0011) // Desplaza 1100 tres veces dando 0001

*Si manipulamos decimales lo que hacemos es dividir el número por 2 tantas veces como indique su desplazamiento:
12 > > 1 // Sería 12 / 2 = 6
12 > > 2 // Sería 12 / 2 = 6; 6/2 = 3

A > > > B : Desplazamiento de A a la derecha en B posiciones, NO tiene en cuenta el signo:
1110 0011 > > > 0011 // Desplaza tres a la izquierda dejando 0001 1100

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
17
Q

Sabemos que tanto las clases propias (las que hacemos nosotros), como las predefinidas (descargadas de API Java) están organizadas en paquetes y contienen diversos métodos, ¿qué métodos conoces de la clase MATH?

A

Esta clase contiene un muestrario de métodos que nos permiten realizar operaciones matemáticas:

Math.sqrt (n) => raiz cuadrada del número “n” (se declara con double).

Math.pow (base, exponente) => potencia de un número (base y exponente son double)
double numero = 2;
double elevado = Math.pow(numero, 10);
System.out.println (“El numero 2 elevado a 10 es “+ elevado);
//El numero 2 elevado a 10 es 1024.0

Math.round (decimal) => redondeo de un número.
double numero = 5.87;
double resultado = Math.round(numero);
System.out.println (resultado);
//6

Math.PI => CONSTANTE de clase con el número PI

Math.random (); => genera por consola números aleatorios entre 0 y 1 (sólo con double)

IMPORTANTE: java.lang.Object => es la SUPERCLASE de Java de la que heredan todas por defecto.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
18
Q

Sabemos que STRING no es un tipo primitivo (int, double, long, …), sino una clase predefinida a descargar de la API Java, pero ¿conoces algunos de sus métodos más utilizados?

A

La clase STRING se usa para la manipulación de cadenas de caracteres.

String mi_nombre=(Manuel);

length() => devuelve la longitud de una cadena de caracteres:

mi_nombre.length()=6 => porque Manuel tiene 6 caracteres.

charAt(n) => devuelve la posición de un carácter dentro de una cadena (las posiciones empiezan a contar desde “0”):

mi_nombre.charAt(2)=n => porque esta en la 3ª posición de Manuel.

substring(x,y) => devuelve una subcadena dentro de una cadena, siendo”x” el carácter a partir del cual se extrae e “y” el nº de carcateres a extraer.

mi_nombre.substring(0,3)= Man =>los 3 primeros caracteres.

equals(cadena) => devuelve TRUE si 2 cadenas que se comparan son iguales y FALSE si no lo fueran (distingue mayus y minus)

equalsIgnoreCase(cadena) => igual que el anterior pero NO tiene en cuenta las mayúsculas.

IMPORTANTE: java.lang.Object => es la SUPERCLASE de Java de la que heredan todas por defecto.
java.lang: es el paquete.
Object: es la clase.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
19
Q

Sabemos que las clases predefinidas de Java están en la API Java (online) divididas en paquetes, pero ¿en qué 2 partes se dividen dichos paquetes y por qué son necesarios los paquetes?

A

1.JAVA (java.awt, java.io, java.util, …)

2.JAVAX (javax.activity, javax.annotation, javax.swing, …)

============
a) Para organizar las clases.

b) Para evitar conflictos de nombres: NO puede haber 2 clases java con el mismo nombre y en el mismo paquete (carpeta), aunque si se puede en distintos paquetes.

c) Para controlar la visibilidad (pública, privada o protegida) de las clases / ENCAPSULAMIENTO (modifica la visibilidad ocultando atributos de un objeto).

IMPORTANTE: java.lang.Object => es el PAQUETE o SUPERCLASE de Java de la que heredan todas por defecto.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
20
Q

La VISIBILIDAD y ENCAPSULAMIENTO son conceptos diferentes, entonces ¿por qué se relacionan en Java?

A

Para definir la “Visibilidad” en Java, se dispone de palabras reservadas:

public: nos indica que es accesible desde cualquier clase [interface].
private: solo es accesible desde a clase actual.
protected: accesible desde la clase actual, sus descendientes o el paquete del que forma parte.
default: accesible desde cualquier clase del paquete.

El ENCAPSULAMIENTO permite cambiar dicha visibilidad de atributos y métodos, ocultando dichos métodos y atributos de una clase declarándolos PRIVATE, para su exclusivo uso interno.

*No obstante, se puede acceder a dichos elementos ENCAPSULADOS con los métodos: Getters y Setters.
EJEMPLO:

class Punto {

private double puntox, puntoy;

public double getPuntox() {

return puntox;

}

public void setPuntox (double puntox) {

this.puntox = puntox;

}

MNEMOTECNIA: Una lavadora implementa la encapsulación, porque pone a disposición del usuario sólo los botones necesarios para su uso (encender, subir potencia, abrir compuerta, etc), mientras que otras funcionalidades.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
21
Q

Menciona 2 bibliotecas (paquetes) para la creación de interfaces gráficas de usuario:

A

AWT: (Abstract Window Toolkit) es la parte de Java para construir interfaces gráficas de usuario.

import java.awt.*; => importa todas las clases del paquete.

SWING: abstrae el SO y proporciona su propia colección de gráficos.

import javax.swing *; => trae todos las clases.
import javax.swing.JOptionPane; => sólo trae la clase JOptionPane.

IMPORTANTE: son los 2 paquetes que forman la JFC (Java foundation Classes), que son la parte de la API de Java compuesta por las clases para crear interfaces gráficas.

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
22
Q

Comenta 2 clases Java para introducir información dentro de nuestro programa y algunos de sus métodos:

A
  1. SACNNER (es una clase reciente, pues apareció en Java 5.0). Métodos:

nextLine() => introduce texto (string).

nextInt() => introduce números enteros.
int edad= entrada.nextInt();

nextDouble() => introduce decimales.

import java.util.Scanner;

*Son métodos NO estáticos.

  1. JOptionPane (mas antigua) Construye una ventana sencilla. Métodos:

showInputDialog () => con este método se construye dicha ventana.

import javax.swing.JOptionPane;

*Método estático.

NOTA: en método NO estáticos hay que crear un objeto perteneciente a la clase para utilizarlos.
Cuando el método es estático hay que usar la clase delante (ej: Math.sqrt(9)).

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
23
Q

Sabemos que el flujo de ejecución de un programa en Java recorre linea a linea (empezando por la 1ª) todo el código, pero ¿qué 2 maneras existen de modificarlo?

A
  1. CONDICIONALES: (a saltos)

1.1 if -> else => puede ir el “if” sólo.

1.2. SWITCH (opción a evaluar){=> case1 -> break; -> case1 -> break; => default;}

  1. BUCLES: (repeticiones)

2.1. BUCLES INDETERMINADOS: no se sabe las veces que se repetirán.
a) WHILE
b) DO WHILE: evalúa la condición después de ejecutar el código de su interior, es decir, este bucle va a ejecutar el código mínimo una vez

2.2. BUCLES DETERMINADOS: se sabe cuantas veces se repite antes de ejecutar.
a) FOR (inicio del bucle; condición; contador del bucle)
for (int i=0; i<10; i++){
System.out.println (“Manuel”);} => imprime 10 veces el nombre Manuel.
b) FOR EACH

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
24
Q

Sabemos que [arreglo, matriz o array] es lo mismo, pero ¿qué utilidad tiene?

A

Estructura de datos para almacenar valores del mismo tipo o relacionados. A diferencia de las variable, pues estas almacenan un sólo valor => una matriz es una agrupación de variables y se pueden recorrer con bucles.

int [ ] mi_matriz = new int [3];

/*int => tipo de variable.
[] => especificamos que se trata de una matriz.
new => operador
int => tipo de dato a almacenar.
[10] => nº de valores a almacenar */

mi_matriz [0]= 35;
mi_matriz [1]= 10;
mi_matriz [2]= 42;

/*nombre_matriz [posición] = valor a almacenar; */

NOTA: también se puede declarar e iniciar a la vez, como las variables:
int [] mi_matriz = [35, 10, 42];

*Las matrices, al igual que las variables, NO pueden tener caracteres extraños ni espacios en sus nombres.

NOTA: hay matrices bidimensionales y multimensionales: int [ ] [ ] bloque = new int [4][5]

How well did you know this?
1
Not at all
2
3
4
5
Perfectly
25
Sabemos que una clase *abstracta* no se puede implementar (no puedes crear objetos: new...), sólo *heredar* de ella, pues funciona como una superclase, pero, en caso de heredar de ella, ¿cómo podemos asegurar que la implementamos esta correcta?
@override Es opcional, pues con esta anotación simplemente le indicamos al *compilador* que compruebe si hemos cometido error alguno al sobreescribir el método de la clase *abastracta* o padre (ejemplo: error con el nombre del método). public abstract class Persona{ => Persona es una clase *abstracta*. *Persona p1=new Persona ();* => daría ERROR, porque no se pueden crear objetos (instanciarla). public abstract class Persona extends Empleado=> Empleado hereda de Persona (clase abstracta), con la finalidad de usar sus métodos. NOTA: si Persona también fuese una clase abstracta no cabria la posibilidad error, es decir, no habría que usar la anotación @override, porque en las clases abstractas NO se crean objetos (no se instancian), por lo cual no habría que implementar los métodos de la clase padre
26
¿Se puede heredar un método ESTÁTICO de una interface en Java?
No. Los métodos estáticos de las interfaces NO se heredan. Esto es muy importante, ya que los métodos estáticos de las clases sí se heredan, y puede llevar a error. Solo se puede acceder a un método estático de una interfaz mediante una referencia de dicha interfaz. Lo estático pertenece SÓLO a su clase, no puedo usar métodos estáticos de otras clases aunque sean heredados, es decir, la HERENCIA es para métodos normales, NO *estáticos*. *public static void ajustarIRPFempleados ()* Una clase abstracta no puede ser instanciada, solo heredada. Cómo Java no permite la herencia múltiple (una clase NO puede heredar de más de una clase padre) habrá ocasiones en las cuales debamos utilizar interfaces. NOTA: La *interface* se crea en Java en un paquete a parte del de las clases y así no se mezclen. NOTA2: los métodos en Java NO se pueden borrar.
27
Sabemos que en Java no hay HERENCIA *múltiple* (heredar de varias clases padres), sino la herencia *simple*, pero SI puede implementar varios *interfaces*, ¿cuál es la palabra clave para ello?
IMPLEMENTS public abstract class Persona extends Entidad *implements* Guardable, Clonable { => la clase Persona hereda de la clase Entidad (padre), de la que implementa 2 interfaces (Guardable y Clonable) *Al ser clase *abstracta* hay que codificar (instanciar) las interfaces (Guardable y Clonable) que implementamos, pues en una clase abstracta no se instancian. NOTA: Una clase *abstracta* (al tener todos sus métodos abstractos o sin instanciar) es parecido a un *interface*, con la diferencia de que el *interface NO puede tener atributos y la *clase abstracta* SI.
28
¿Qué tiene que ver la palabra clave *Enum* con una *variable*?
Enum o Tipos Enumerados => cuando surge la necesidad de almacenar en una variable una serie de valores del mismo tipo y no queremos que se modifiquen ni se incluyan valores de otro tipo en dicha variable. Por ejemplo, si creamos la variable "talla", la limitaríamos a que los únicos valores aceptados sean del tipo talla (pequeña, mediana, grande o extragrande) y no permitir introducir en dicha variable un valor del tipo color (azul, rojo, ...), x ejemplo. *Se declara fuera del "main". *enum talla {(pequeña, mediana, grande, extragrande}* *Se usarían en otra clase.
29
¿Qué es un CONSTRUCTOR en la programación orientada a objetos (y en Java)?
Su nombre es bastante descriptivo, constructor, que construye, se encarga de construir algo en este caso se encarga de inicializar un objeto, es decir, es un método especial que se utiliza para inicializar un objeto recién creado y asignarle valores iniciales a sus variables de instancia. Se declara con **new** y su contrario (destructor) usa la palabra **finally** y se encarga de enviar el objeto en desuso al _GC_.
30
Sabemos que TODA clase de Java (las nuestras y predefinidas) heredan de OBJECT, que se encuentra en el paquete x defecto *java.lang* (java.lang.object), pero ¿conoces algunos de los métodos que aporta?
La clase *Object* es conocida como la clase CÓSMICA, pues todos heredan de ella, a no ser que creemos una herencia manualmente: *public class Persona extends Entidad{* => Persona hereda de Entidad y Entidad hereda de Object (ya que no tiene herencia manual): *public class Entidad{* _MÉTODOS de la Clase Object_: CLONE: clona objetos, es decir, lo aplicas sobre algo y te crea una copia. EQUALS: compara si 2 objetos son iguales (boolean). FINALIZE: es el método al que llama el "Garbage Collector", aunque tú lo puedes codificar. El GC lo llama cuando determina que no hay más referencias al objeto. HASHCODE: una función que devuelve de cada objeto un código *hash* (como un identificador de cada objeto). Notify, NotifyAll y wait: métodos para manejar / sincronizar hilos.
31
Simplifica la creación de CLASES y OBJETOS en Java:
*public class Coche{* => creación de la clase "Coche" (publica). *Coche SeatLeon = new Coche ();* =>creamos el objeto "SeatLeon", haciendo referencia a la clase (Coche) y con el constructor (new Coche). /*Ahora crearemos los atributos (propiedades) de la clase */ *String color;* *String marca;* *int km;* /*ahora creamos el método *main* */ *public static void main (String [] args) {* /*y referenciamos los atributos con los objetos */ *SeatlLeon.color= "Negro";* *SeatlLeon.marca= "Seat";* *SeatlLeon.km= 0;* /*para sacarlo por consola */ *System.out.println ("El color del SeatLeon es: " + SeatLeon.color);* NOTA: *contructor* es un elemento de la clase cuyo nombre coincide con la misma, para inicializar objetos (instancia).
32
¿En qué se diferencian las siguientes sintaxis: *public void método ()* y *public int método ()*?
En que *public void método ()* NO retorna nada. En cambio, *public int método ()* retorna un entero. *Entre paréntesis irían los argumentos del método. *Para poder usar un método hay que crear un objeto, pues un método es una acción o comportamiento de los objetos. EJEMPLO: creamos un método para sumar 2 números: public void suma{ suma = num1 + num2 } NOTA: si creásemos el objeto (cuenta) de la clase Operaciones (Operaciones cuenta= new Operaciones), lo podríamos relacionar con el método anterior de la siguiente manera: *cuenta.suma ();*
33
Sabemos que *JavaC* es el compilador principal de Java que transforma nuestro código (.java) a código máquina o bytecode (.class), pero ¿conoces otros compiladores en Java?
_xjc_: este compilador genera clases de Java a partir de un XSD. _rmic_: este compilador genera archivos de clase *stub*, *skeleton* y *tie* para objetos remotos.
34
Si con *JavaC* compilamos nuestro código (.java) a .class (bytecode), ¿cómo podriamos desensamblar dicho fichero.class?
javap *java -c programa.class*
35
Enumera algunas herramientas de Java:
_jdb_: depurador (revisar el programa linea a linea en búsqueda de errores) x CONSOLA. _jdeps_: analizador de dependencias, clases y paquetes. _jmc y jconsole_: herramientas de monitorización de la JVM, para poder analizar o detectar, en tiempo de ejecución, si hubiera alguna aplicación fallando.
36
¿Qué funciones tienen las herramientas de Java *jarsinger* y *keytool*?
_jarsinger_: firmar ficheros "jar". _keytool_: para criptografía.
37
¿Para qué se usan las miniconsolas JSHELL?
Se llaman REPL (ReadEvaluatePrintLoop) y sólo se suelen usar para hacer pruebas, pues es una sencilla consola Java que nos permite ejecutar un bloque de código de una forma rápida y directa NOTA: fue introducido en Java 9.
38
¿Qué función tiene la herramienta de Java *javadoc*?
Genera documentación HTML (estructura) a partir del código fuente de nuestro programa.
39
JDK vs JRE:
_JDK_ (Java Development Kit = kit de desarrollo de Java) es para construir programas con Java. Trae herramientas útiles como: compilador (javac), desensamblador de bytecode (javap), depurador (jdb) para identificar y corregir errores, ... Una instalación de JDK ya contiene un JRE. _JRE_ (Java Runtime Environment = entorno de ejecución de Java) contiene la JVM (intérprete) + las librerias (fichero rt.jar), y su ÚNICA función es la de ejecutar nuestro programa en múltiples plataformas, por ello, debe estar instalado en todo equipo donde vaya a correr nuestro programa Java. EJEMPLO: si vas a desarrollar una aplicación GUI en Java con SWING => en tú equipo instalas la JDK y si un amigo quiere ver esa app tendrá que instalarse el JRE (includo en la JDK). NOTA: como hemos comentado, la JDK contiene también la JRE, pues algunos IDEs llevan la JDK embebida. IDEs: Eclipse, JBuilder, JCreator, XCode, NetBeans, ...=> el IDE es el escritorio donde programar.
40
Sabemos que, además de las JVM (intérprete), en la JRE estan las librerías BASE contenidas en el archivo rt.jar, pero ¿cómo se cargan?
_BootStrapClassLoader_ Es el cargador de clases principales: String, Integer, Date, ... IMPORTANTE: Para usar librerías de terceros (NO están en rt.jar, ni son las tuyas propias), como Hibernate, Spring,... habría que configurar sus rutas en la variable de entorno *CLASSPATH* y se cargarían con _ClassLoader_, que es el cargador de clases de CLASSPATH. *La variable de entorno CLASSPATH se encuentra dentro del fichero _MANIFEST.MF_ (que, a su vez, esta dentro del fichero META-INF), donde existe un "campo" llamado *Class-Path:ruta(s)*, donde configuramos la ruta de la librería de terceros. *La estructura de Manifest.mf es clave:valor => ClassPath:fichero.jar (como cualquier variable de entorno). *Para crear un paquete de clases las comprimimos en un fichero *.jar: => *jar cvf fichero.jar clase1.class clase2.class* NOTA: la JRE esta incluida en el paquete de la JDK. NOTA2: la extensión de los ficheros paquetes que contienen las librerías es *.jar*.
41
Los Thread o Hilos (miniprocesos en que se divide la ejecución del programa), además de crearlos nosotros, existen otros predefinidos como el GC, definelo:
Los objetos se crean con el operador *new* y se borran con este hilo (Garbage Colector), que funciona descargando los objetos que no se están utilizando de la memoria. NOTA: la parte de la memoria donde se guardan los objetos de Java se llama: *heap*. *Existe la clase _Thread_ en el paquete *java.lang* para crear tus propios hilos: public class HiloAdicional extends Thread => para heredar de dicha clase.
42
Sabemos que una clase es una estructura donde definimos atributos y métodos. Explica la palabra reservada *final* usada en dichos 3 contextos:
1. Si se usa para una CLASE: nada podrá heredar de dicha clase (NO extends => plublic class hija extends padre). *Aunque ella si podrá heredar de otras clases que no tengan "final". 2. Si se usa para un ATRIBUTO: el valor de dicho atributo no podrá cambiar. *final int num= 3;* => valor constante (no cambia) 3. Si se usa en un MÉTODO: ese método no se podrá sobrescribir (NO @override). *public final void método ()* => el código de ese método NO se podrá sobreescribir. NOTA: la sobreescritura (la cual se la indicamos al compilador con la anotación @overrive para que nos la analice en busca de posibles errores que hayamos cometido en la replica), se da cuando se produce la *herencia*.
43
¿Para qué sirve la palabra reservada *static*?
Para definir atributos y métodos que no tienen nada que ver con los objetos, sino con la clase. Es decir, un método estático influye a toda su clase a la que pertenece, así que no hace falta instanciarlo (se llama directamente). *Los métodos instanciados son en los que se pone el objeto a la izquierda => objeto.método ( ). NOTA: todo lo *estático* pertenece a la clase y lo *NO estático* pertenece a los objetos.
44
Resume los modificadores de visibilidad o acceso:
PUBLIC: CUALQUIERA. PROTECTED: su clase ,clases del paquete y clases externas que hereden de ella (subclases o hijas) DEFAULT: su clase y las clases de su paquete. PRIVATE: SÓLO su clase. MNEMOTECNIA: van de más a menos (de todo a sólo la clase) => CDTE (letras en que terminan), sabiendo que PUBLIC y PRIVATE están en los extremos, porque son opuestos.
45
En un programa Java, ¿puedo definir un método codificado en lenguaje C++, x ejemplo?
SI, con la palabra reservada *native*. Se usa en declaraciones de métodos para especificar que el método no se implementa en el mismo archivo de Java, sino en otro lenguaje.
46
¿Qué relación tienen la palabra reservada "volatile" y "synchronized"?
Al marcar un atributo como *volatile*, la JVM garantiza que el resultado de cada operación (thread) de escritura no se escriba en la memoria local, sino en la memoria principal (RAM, es decir, ese atributo no sería cacheado (introducido en cache), por lo que se usará el valor que hay en la RAM, pudiéndose compartir con el resto de hilos. Este hecho, de que el hilo vaya a buscar la información a la RAM en lugar de la caché, tiene una penalización en el rendimiento. Pero, cualquier hilo (thread) puede acceder al valor más actualizado, al estar compartido directamente desde la RAM en lugar de la memoria local. NOTA: los métodos, clases, interfaces, variables y parámetros locales NO pueden declararse VOLÁTILES. ============ *Synchronized* también mejora la gestión de hilos. Pues, en lugar de que un cierto método pueda ser ejecutado por varios hilos, al marcarlo como *synchronized* le produciríamos un *bloqueo mutex* mientras el hilo actual lo esta ejecutando y se liberaría una vez termine. Así sucesivamente, de manera que sólo pueda ser ejecutado por un hilo cada vez secuencialmente. NOTA: los campos, clases e interfaces NO pueden declararse como *sincronizados*.
47
Sabemos que la *serialización* es el proceso de convertir un objeto de la RAM en un flujo de bytes para poderlo guardar en el disco duro, enviarlo por red, ..., pero ¿qué relación tiene con declarar un atributo *TRANSIENT*?
Los atributos *transient* son aquellos que NO quieras *serializar* (convertir a flujo de bytes), es decir, con ·transient" le decimos al motor de Java (JVM), que NO serialize dicho atributo de tal objeto, por tanto, que no lo guarde. public class Usuario implements Serializable { private String nombre; private transient String password; } *Esto implicaría que cuando se serialice el valor que haya en la variable password, al ser declarada como transient, no se va a serializar*
48
¿A qué nos referimos con *Java GENERICS*?
Los tipos genéricos (Generics) permiten establecer restricciones (bounded) a nivel de tipo, haciendo que ciertas clases, interfaces o métodos acepten únicamente los tipos estipulados. Es decir, cuando se que tipo de cosas va a contener mi clase, puedo especificarlo de antemano y así no se desvirtuaran en gran medida las clases hijas respecto del padre. Ya que nuestra clase no va a variar respecto del TIPO GENERICO con el que la hemos declarado. *class nombre_clase indicas que sólo aceptarás clases genéricas que hereden de tipo entero. Array < Integer a2=new Array Generico para Almacenar Integer Su uso esta ligado, mayoritariamente, a las *colecciones* (listas vinculadas, tablas hash, pilas, colas y árboles, entre otros), donde ayudan a realizar comprobación de tipos en tiempo de compilación.
49
¿Qué es la SOBRECARGA en Java?
Que haya en una misma clase varias versiones del mismo método. Es decir, tener varios métodos con el *mismo nombre*, pero con *número diferente parámetros*. Java utiliza el número y tipo de parámetros para seleccionar que definición de método ejecutar. EJEMPLO: Clase *String* tiene varios métodos llamados "value of". value of (char c) value of (double d) value of (int i)
50
Sabemos que @override es la *anotación* para comprobar los métodos sobrescritos, pero ¿qué es una *anotación* en Java?
Las @anotaciones son elementos de programación, que sirven para CONFIGURAR nuestro código (clase, método, atributos, ...). *Para indicar una anotación => @interface (cierto es que le pegaría más @anotation) *Para indicar donde ponemos la anotación => @Target (@Target(ElementType.Type)): Estos son los diferentes tipos a los que podemos aplicar nuestras anotaciones: Type Field Method Parameter Constructor Local_Variable Annotation_Type Package Module Type_Parameter Type_use *Se puede usar tanto las @notaciones predefinidas en Java, como las que cree uno mismo: *@Target (ElemenType.METHOD)* *public @interface Seguridad{* Indica que la anotación que hemos creado "Seguridad" sólo se podrá aplicar al tipo de rol: METHOD (es decir, sólo sirve en métodos). /* las anotaciones se crean = que las clases => botón derecho -> new -> annotacion => *public @interface ANNOTATION{* *@Target (ElemenType.PARAMETER)* *public @interface Required{* Cuando vayamos a una clase y le pongamos @Required delante de un parámetro => querrá decir que es un parámetro requerido u obligatorio.
51
Hablando de Programación de Red a *bajo nivel*, ¿cuál es la diferencia entre Socket/ServerSocket y DatagramSocket?
Que **Socket/ServerSocket**, se encarga de implementar el extremo de la conexión del Servidor. Y, **DatagramSocket**, implementa tanto el servidor como el cliente, es decir, es un "conector" a través del cual enviamos y recibimos paquetes (datagramas) UDP. NOTA: en cuanto a Programación de Red a *alto nivel* tenemos **RMI** (Java Remote Method Invocation), que es un mecanismo ofrecido por Java para invocar un método _remotamente_.
52
Sabemos que las JFC (Java Foundation Classes) son clases para crear interfaces gráficas visuales, pero ¿cuáles son los 2 paquetes que contienen?
_AWT_: (java.awt.event) presenta *componentes pesados* que en cada plataforma sólo pueden tener una representación determinada. _Swing_: (javax.swing.event) presenta *componentes ligeros* que pueden tomar diferentes aspectos y comportamientos. *Tienen en común un sistema para gestionar los *eventos* (basado en la gestión de excepciones) que se producen al interactuar con el usuario de la interfaz gráfica.
53
¿Qué definición tiene el concepto *Reflection* en Java?
El concepto de *Reflection* simplemente nos quiere decir que el programa tiene la capacidad de observar y modificar su estructura de manera dinámica (de ahí que se refleje su mismo código). Podemos elegir una clase que hemos escrito previamente en un IDE y después de compilada, mientras el programa se ejecuta, poder modificarla. Es decir, proporciona la capacidad de acceder a los metadatos (clase, atributos, métodos) de un objeto en tiempo de ejecución y modificarlos. *Api JPA (Java™ Persistence API) y sus ORM: Hibernate, OpenJava y TopLink.
54
¿En qué se diferencian las Herramientas de Automatización del desarrollo de Java: Ant (build.xml), Maven (pom.xml) y Grandle?
ANT, es más básico que las otras 2, pues sólo automatiza el Desarrollo (construcción del proyecto) y NO hace Gestión de Dependencias. En cambio, tanto MAVEN como GRANDLE si que automatizan las dos partes: Gestión de Dependencias y Construcción del Proyecto. *ANT, se abastece del fichero *build.xml*, que es una especie de script, para compilar, empaquetar, ... todo en el mismo fichero. *MAVEN, usa el fichero *pom.xml* (Project Object Model.xml). NOTA: tanto ANT como MAVEN son herramientas de Apache. IMPORTANTE: IVY o Apache IVY, es una extensión o subproyecto de Apache ANT para la gestión de Dependencias.
55
Enumera algunas JDKs oficiales e indica si es posible crear una JDK uno mismo:
IMPORTANTE: la JRE esta incluida en la JDK. Algunas JDKs: *OpenJDK *_Amazon Correto_ *IBM JDK Si, es posible que cada uno se haga su propia JDK, pues *Sun Microsystem* creó un estándar de JVM, a partir de cual, cada uno puede crearse su propia JDK y se llama JVMS (Java Virtual Machine Specification). Es decir, gracias a esta especificación o estándar (JVMS), cualquier máquina virtual tendría la *misma infraestructura*.
56
¿Qué 2 librerías open source para Java permiten trabajar con documentos PDF?
*iText *PDFBox
57
¿Cuál es la librería de Java más importante para *criptografía*?
BouncyCastle.
58
¿Qué utilidad tienen las librerías de Apache: Xerces, Xalan y FOP (Formatting Objects Processor)?
_Apache Xalan_ y _Apache FOP_: (procesors XSL) ambos son conversores de formato: *Xalan: transforma documentos de XML en HTML u otros tipos de lenguajes de marcado. *FOP: convierte archivos XSL FO (Formatting Objects) a PDF u otros formatos imprimibles. NOTA: Un documento XSL-FO es un documento XML en el que se especifica cómo se van a formatear unos datos para presentarlos en pantalla, papel u otros medios. _Apache XERCES_: es un *parsers* XML, es decir, es una colección de bibliotecas para el análisis sintáctico, validación, serialización y manipulación de documentos XML.
59
Define las librerías para la realización de *pruebas unitarias y de carga* en Java?
_JUnit_: nos permite comparar el resultado esperado de un método, con el que realmente estamos obteniendo después de ejecutar el método. _Mockito_: Nos ayuda a *simular* la respuesta de otro método necesario, para ejecutar el método que necesitamos probar. NOTA: *Mockito-Core* es un FrameWork con un juego de pruebas unitarias para crear objetos simulados (mocks= burla o imitación). _JMeter_: proyecto de Apache que puede ser utilizado como una herramienta de prueba de carga para analizar y medir el rendimiento de una variedad de servicios, con énfasis en aplicaciones web.
60
¿Existe en Apache y Google alguna librería parecida a la librería de clases base de Java *java.lang*?
_Apache Commons_ Provee componentes de software Java de código abierto, parecido a java.lang. Estas librerías se agrupan en: *Proper *Sandbox *Dormant _Guava de Google_: conjunto de bibliotecas comunes de código abierto para Java, desarrollado por Google (aporta COLECCIONES).
61
Describe las librerías de Apache: Tika y POI:
_Apache POI_: para manejo de documentos de *Office*. _Apache TIKA_: detección y extracción de contenido (metadatos) de más de mil tipos de formatos diferentes .
62
¿Para qué sirve la herramienta Pentaho Kettle?
Herramienta que extrae y analiza datos con técnicas ETL (extraer, transformar y cargar, en sus siglas en inglés). Estos datos se muestran a posteriori en Cuadros de Mandos (almacenados), que serán muy útiles para crear informes y tener un seguimiento de la consecución de objetivos. *ETL: (Extract, Transform, Load) es un tipo de integración de datos que hace referencia a los tres pasos ETL, que se utilizan para mezclar datos de múltiples fuentes => PARA CONSTRUIR UN ALMACÉN DE DATOS.
63
¿Cuál es la librería que nos sirve para generar GETTERS automáticamente?
LOMBOK *La librería _Lombok_ inyecta su código con el nuestro aportándonos: *getters, setters, constructors, parametros, ...* de manera automática y x medio de @anotaciones. EJEMPLOS: import lombok.Setter; import lombok.equals; NOTA: una vez importado se invoca por medio de @anotaciones: @Getter @Setter @Equals & HashCode @Tostrins (encadenar)
64
Enumera algunas clases de la librería *java.util* de Java: SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
_java.util.ArrayList_ => implementación de *matriz redimensionable*. _java.util.LinkedList_ => implementación de *listas doblemente enlazadas*. _java.util.HashMap_ => tabla hash basado en una implementación de la interfaz Map de Java, el cual será una colección de Key-value (clave-valor). Un HashMap permite nulos,no se encuentra ordenada ni sincronizada. _java.util.HashTable_ => implementación de tabla *Hash* (estructura de datos que asocia llaves o claves con valores). Una Tabla Hash SI esta sincronizada. _java.util.TreeMap_ => implementa estructura de datos TreeMap es una colección que almacena pares clave-valor en un orden ordenado de forma natural. Esta ordenado en orden ascendente de sus claves. _java.util.StringTokenizer_ => nos permite dividir el *string* (cadena) en un número de *tokens* (substring) igual al número de líneas de texto. El carácter delimitador de lineas es: "/n".
65
¿Qué aportan las 2 clases StringBuffer y StringBuilder sobre STRING? SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
Antes de que existieran estas 2 clases, un STRING (cadena) NO se podía modificar. _java.lang.StringBuffer_ => un búfer de cadena (secuencia de caracteres), es cómo una cadena (String), pero MODIFICABLE. Sus métodos están sincronizados, por lo que permite trabajar con múltiples hilos y es el más seguro (pero NO el + rápido). _java.lang.StringBuilder_ => esta clase esta diseñada para usarse como reemplazo de *StringBuffer* (multi-hilos) en lugares donde el búfer de cadena estaba siendo utilizado por un solo subproceso (hilos). No obstante, es más rápida que StringBuffer, por lo cual SE RECOMIENDA UTILIZAR ESTA.
66
¿Cuál es la clase concreta de Java para formatear y analizar fechas de manera sensible a la configuración regional?
_SimpleDateFormat_. **java.text.SimpleDateFormat** => permite formatear (fecha -> texto) y normalizar. SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
67
Enumera algunas clases de la librería java.io de Java: SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
_java.io.Readers_ => clase abstracta para LEER secuencias de caracteres. _java.io.Writers_ => clase abstracta para ESCRIBIR secuencias de caracteres. _java.io.InputStreams_ => representa un flujo de ENTRADA de bytes. _java.io.OutputStreams_ => representa un flujo de SALIDA de bytes. IMPORTANTE: *java.nio* es su versión más MODERNA.
68
Enumera algunas clases de la librería java.sql de Java: SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
(1º CONEXIÓN) _java.sql.Connection_ => una conexión (sesión) con la base de datos específica. La conexión se realiza por medio del objeto *DataSource* (_contendrá los datos para la conexión y los métodos para consultar la BD_). (2º CONSULTA) _java.sql.PreparedStatement_ => después de haber establecido la conexión (sesión) con la BD, con la creación de este objeto (_donde almacenamos nuestra consulta_) ejecutaremos nuestras consultas a la BD. (3º CURSOR) _java.sql.ResultSet_ => si nuestra consulta a la BD es de tipo SELECT (query), obtendremos el objeto *resultset* para recorrer y manipular la información obtenida.
69
¿Cuál es la diferencia entre *this* y *super*?
_this_: sirve para hacer referencia a la instancia actual del objeto. _super_: sirve para hacer referencia a la clase padre del objeto.
70
¿Con qué 4 bloques se desarrolla un programa en Java?
1. _CLASE_: estructura de programación donde definimos atributos (para guardar la información) y métodos (funciones) para construir OBJETOS (instancias). *public _class_ empleados{* 2. _INTERFACE_: esqueleto con una serie de métodos VACÍOS, para OBLIGAR a las clases a implementarlos y tengan un comportamiento homogéneo. 3. _ENUMERADO_: un *Enum* es una estructura que sirve para definir constantes, como un conjunto de valores. Ej: *public enum demarcación{* PORTERO, DEFENSA, CENTROCAMPISTA, DELANTERO } 4. _ANOTACIÓN_: empieza por @Target (donde influye la anotación), @override (comprobar métodos sobrescritos) y nos sirve para configurar cualquier cosa que haya dentro de nuestro código. Es una especie de comentario funcional. Ej: @interface => es su sintaxis: *public @interface deprecated* => estamos diciendo que el método es obsoleto.
71
Menciona algunos comandos de la JDK:
_javac_: compilar (.java -> .class) => empaquetas con *jar*. _jar_: empaquetar (extensión de toda aplicación o librería Java). _java_: intérprete (ejecuta el programa en consola) _javadoc_: genera código HTML a partir del código fuente de Java. _javap_: desensambla y analiza los ficheros .class _jdb_: depurador _jarsinger_: firma nuestro código empaquetado (.jar) dotandolo de + seguridad. _jconsole_: monitoriza la JVM y controlar el programa Java (memoria, hilos, ...) _wsimport_: analiza un archivo WSDL (Web Services Description Language) y genera los artefactos necesarios para desarrollar aplicaciones de servicios web JAX-WS (SOAP) -> *para que el CLIENTE acceda a lso servicios web públicados*. _xjc_: compilador JAVA <----> XML. _jjs_: capacidad de poder ejecutar, dentro del programa Java, código JavaScript. *En JDK8 metieron el motor de JavaScript *NASHORN* (sustituye a RHINO). Aunque es sustituido por GraalVM (políglota). NOTA: este conjunto de utilidades las instala el IDE en el directorio /bin IMPORTANTE: la JRE, que a su vez esta incluida en la JDK, contiene la JVM + librerías de clases base (rt.jar).
72
Enumera algunos elementos de la JVM:
_ClassLoader_: carga en memoria el fichero .class y las clases de las librerías cuyas rutas hemos configurado en la VE *ClassPAth*. _MEMORIA_: a) Heap: parte de la memoria donde se guardan los *objetos* que se van creando dinámicamente (new objeto). b) Stack: aquí se guardan los hilos. c) Registros: guardan las direcciones de memoria (stack, heap, ...). _JIT_: (Just In Time) traduce el *bytecode.class* al código máquina de la plataforma en cuestión. _GC_: (Garbage Collector) el Recolector de Basura libera la memoria eliminado lo que esta en desuso => ES LA ÚNICA MANERA DE ELIMINAR EN JAVA.
73
Al instalar una app habría que descargarla, instalarla y ejecutarla en cada máquina, ¿hay alguna manera de reducir este proceso en Java?
Si, con **JNLP** (Java Network Launching Protocol), que es una especificación para iniciar un programa Java remotamente a través de la red. Lo utiliza la tecnología de implementación Java Web Start (JWS). Esta especificación permite tener centralizado en un servidor web un programa (Cliente Standalone) evitando los problemas de distribución e instalación. NOTA: la app *Cliente STANDALONE* son aplicaciones de escritorio con una librería de componentes gráficos (Swing o AWT). FUNCIONAMIENTO: teniendo el cliente StandAlone (aplicación de escritor) instalada en el servidor central (Servidor Web). Los clientes (cada PC) sólo tendría que clickear en el archivo JNLP del Servidor y este le descarga automáticamente dicha aplicación.
74
Todas las clases relacionadas con temas de red se encuentran en la librería java.net de Java, enumera algunas: SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
*Los *sockets* son mecanismos que enlazan 2 programas independientes (CLIENTE / SERVIDOR). La librería *java.net* provee 2 clases: _java.Socket_: para implementar la conexión desde el lado del CLIENTE. _java.net.ServerSocket_: desde el SERVIDOR. _java.net.URLConnection_: para abrir una conexión HTTP. _java.net.INetAddress_: proporciona métodos para obtener la IP de cualquier nombre de Host (puede manejar IPv4 e IPv6)
75
Sabemos que JDBC (Java Database Connectivity) es el puente entre el mundo Java y el mundo de la base de datos, pero ¿cuáles son las clases que forman parte de JDBC?
1. _java.sql._ (Driver, Connection, Statement y ResultSet). 2. _javax.sql.DataSource_ (interface) NOTA: JDBC es la API de *Bajo Nivel* por tratar directamente con la BD. JPA (Java Persistence API) es la de *Alto Nivel* (implementa los ORMs: Hibernate, TopLink y OpenJPA), porque NO trata directamente con la BD. *JDBC es el puente (Java--BD) y JPA agrega una capa adicional de abstracción (ORM).*
76
Sabiendo que la clase para fechas de Java *java.util.date* no es muy útil, di ¿cuál es el paquete que se suele usar?
_java.time_ NOTA: antes *joda-time*, pero la copiaron al paquete *java.time*. SINTAXIS: *import java.util.HashSet* import: COMANDO java.util: LIBRERÍA HashSet: CLASE
77
Define brevemente las clases del paquete *java.util* "logging, jar, zip y regex":
_java.util.loggin_: para generar mensajes de *log* a *ficheros*. _java.util.jar_: para manejar ficheros *.jar* desde el programa. _java.util.zip_: para manejar ficheros *.zip* desde el programa. _java.util.regex_: para crear *expresiones regulares*.
78
La *Persistencia de Datos* es el medio mediante el cual una aplicación puede recuperar información de la BD y hacer que esta *persista*, hay 2 APIs para ello, define JDBC:
_JDBC_: (Java Database Connectivity) es la de Bajo Nivel, porque tratamos directamente con las tablas (BD). A diferencia de JPA que usa la capa de abstracción EM (intermediario). 1. DRIVER: es un objeto Java que conecta (CONNECTION) con la BD (MySQL/MAriaDB, Oracle, Postgres, ...). *Puede abrir tantas conexiones con la BD como le pidamos, pues no tiene control y puede saturar (tumbar) el servidor. 2. Para solucionar el problema de control de DRIVER se usa el objeto *DataSource*. A este objeto se harán las peticiones, que gestionará antes de pasárselas al DRIVER, con las instrucciones WAIT (espera) y NOTIFY (acceso). *A medida que se usan las conexiones se van devolviendo al DataSource para liberarlas. IMPORTANTE: Crearemos objetos de la clase *PreparedStatement* para ejecutar nuestras *querys* (consultas). Y para las *querys* que sean SELECT usaremos objetos de la clase *ResultSet* (cursos de BD) para recorrerlas. NOTA: es el mismo sistema de JPA, sólo que este incluye una capa abstracción (EM) en medio => no trata directamente con la BD.
79
La *Persistencia de Datos* es un medio mediante el cual una aplicación puede recuperar información de la BD y hacer que esta *persista*, hay 2 APIs para ello, define JPA:
_JPA_: (Java Persistence API) es la de ALTO nivel porque NO trabaja directamente con la BD (usa el intermediario EM). JDBC y JPa tienen el mismo sistema (DataSource -> Driver -> PreparedStatement - ResultSet), pero JPA introduce encima la capa EM (Entity Manager), que es una capa de abstracción, para la *automatización*, que hace de intermediaria entre la BD y cliente. Es decir, el SQL (BD) te lo dan hecho, tú solamente le pides al ORM , que guarde tal objeto y él automáticamente lo coloca en la tabla que le corresponda. O, le pides recuperar tal objeto y el ORM (Hibernate, EclipseLink y OpenJPA) te hace automáticamente la SELECT y te da el objeto solicitado. En resumen, tú ya NO tienes que bucear en las tablas, como en JDBC.
80
Sabemos que en la API de Persistencia JPA los ORMs nos automatizan el trabajo, pero ¿qué son?
Los ORM (Object Relational Mapping), son productos para transformar del mundo de la relación de objetos al mundo de las tablas (BD). Existen en casi todos los lenguajes para convertir un objeto en una tabla o fila. JDBC no los incluye, por lo cual es el lenguaje de *bajo nivel* (imperativo) al tener que tratar nosotros directamente con las tablas. A diferencia de JPA (Alto Nivel). *Hibernate (en .NET se llama NHibernate). *EclipseLink (antes TopLink). *OpenJPA.
81
¿Qué clases tenemos en Java relacionadas con el mundo XML y Servicios Web?
_javax.DocumentBuilder_: (DOM) lee el documento XML y genera objetos en forma de árbol. _javax.SAXparser_: (SAX) hace la lectura sobre la marcha (streaming) sin que se cargue todo el documento en memoria. _javax.DocumentBuilder_ y _javax.xml.ws_: paquetes para hacer servidores web a base de @anotaciones.
82
El API de Java nos proporciona el framework (Java Collection Framework) de las colecciones o jerarquía de *INTERFACES* para la ampliación funcional, pero ¿qué 2 colecciones / jerarquías hay?
1. Map: estructura (tabla) de doble entrada: CLAVE,VALOR. 2. Iterable: Listas (list), Colas (queue) y Conjuntos (set). 2.1. Todas heredan de *ITERABLE*, es decir, es la que esta encima de la jerarquía. 2.2 Le sigue *COLLECTION*, amplia las funciones de las de arriba (iterable), que TODAS serán heredades por el resto de *interfaces* que cuelgan de ellas. 2.3. A partir de ahí cuelgan todos las *interfaces* y *clases*, empezando por: LIST (listas), Colas (queue) y Conjuntos (set). Esta "colección" o "jerarquía" de interaces, también se componen de las clases que las implementan (ver foto). Es decir, los *clases* se heredan (extends) y las *interafaces* se implementan (implements). *Todas las *clases* implementan las *interfaces* con: *Interaface Collection * => E: es el tipo de colección (ej:List)
83
Sabemos que el Java Collection Framework posee 2 tipos de colecciones tanto de ITERABLE como de MAP,define los mapas?
Es una estructura / tabla de doble entrada (clave,valor) para guardar datos. Es como un índice en la BD. EJEMPLO: Pepe (valor) + 75792315V (clave) =< se coloca en la misma fila. 1. Se implementa de la siguiente manera: *put* (75792315V, Pepe) 2. Y para recuperar a esa persona: *get* (75792315V) NOTA: se recupera (localiza) por la CLAVE. COMANDOS: put (k,v) get (k) KeySet (75792315V) values (Pepe) CLASES JAVA: _HashMap_: colección desordenada y NO sincronizada. Permite NULOS. _HashTable_: (Diccionary) ordenada y sincronizada. _TreeMap_: colección ordenada en orden *ascendente* de las claves.
84
Sabemos que hay 2 tipos de colecciones (Iterables y Map) y que las *INTERABLES* se dividen en 3 niveles, ¿conoces comandos de dichos niveles?
1. *ITERABLE*: 1ª de la jerarquía => TODAS heredan de ella. *iterator ( )* 2. *COLLECTION*: 2ª de la jerarquía, suma sus métodos a los de *iterable*. *add (E)* => añadir colección (E) *size ( )* => (int) calcular el tamaño de la colección. *isEmpty ( )* => (boolean) preguntas a la colección si esta vacía. *toArray ( )* => transforma una colección en un [array de java] *contains (object) => (boolean) comprobar si cierto objeto esta dentro de la colección. *remove (object)* => borrar un objeto. *clear ( )* => borrar TODO. 3. *LIST (listas), Colas (queue) y Conjuntos (set)*: son los primeros *interfaces* que heredan de *collection*. *get (int indice)* => para obtener un objeto en base a un índice. *Todas las *clases* implementan las *interfaces* con: *Interaface Collection * => E: es el tipo de colección (ej:List)
85
Sabemos que con las EXCEPCIONES (notificaciones) podemos comunicar un modulo de un mismo programa (Llamante o Módulo A) con otro módulo (Destino Módulo B), pero ¿cuál es su uso mayoritario?
Es un mecanismo (try-catch) para controlar los posibles errores, notificándolos en tiempo de ejecución, a través de las estructura: _Throw / Throws_: (son los métodos que lanzan las excepciones (notificaciones) *thorw* es para lanzar una excepción por linea de comandos hasta el nivel que hizo la llamada, donde se captura y se trata (try-catch) y *throwS* para pasar la excepción hacía arriba (con "super") a su clase padre (superclase) *THROWABLE*. _try-catch_: *try* se queda el método si no ha habido error y si hubo error se ejecuta / gestiona en el *catch* (parecido a if/else). _Finally_: SIEMPRE SE EJECUTA, tanto si hubiera error (catch) como si no lo hubiera (try). IMPORTANTE: *THROABLE*: clase PADRE (SuperClase) de la que heredan las *excepciones* y *errores*. *EXCEPTION*: clase PADRE (SuperClase) de la que heredan las *excepciones* y, a su vez, hereda de THROWABLE (ver foto). *CHECKED EXCEPCION*: (heredan de *Excepción*) el compilador de Java obliga a tratar ciertas excepciones y habría que pasar dicha *excepción* para arriba (superclase) con *throws* o con *throw* + try/catch. *UNCHECKED EXCEPCION*: (hereda de *RunTimeException)* las excepciones que el compilador NO obliga a tratar.
86
Sabemos que EXCEPTION es el mecanismo para *notificar las excepciones*, pero ¿cuál es la clase BASE de la que heredan todas las Excepciones en Java?
EXCEPTION: es la clase de la que heredan SÓLO las excepciones. Aunque, THROWABLE es la superclase de todos los ERRORES y EXCEPCIONES en el lenguaje Java, por tanto la clase EXCEPTION hereda de THROWABLE (ver foto). NOTA: en el examen se dio por valida THROWABLE, pues es la que esta más arriba en la jerarquía. SENTENCIAS HEREDADES PARA TRATAR LAS NOTIFICACIONES / ERRORES: try (notificaciones SIN error) -catch (ERRORES), throw o throwS y finally (siempre se ejecuta). *CHECKED*: son las clases que heredan de EXCEPTION (try-catch) => trata las expeciones. *UNCHECKED*: son las que heredan de RunTimeException => el compilador NO obliga a tratarlas.
87
Sabemos que las clases THROWABLE -> EXCEPTION nos aportan las sentencias para tratar las *excepciones* (try-catch, throw/throwS y finally), pero: a) ¿Se tiene que poner sólo un bloque *catch* con el *try*? b) ¿Puede ser que en el método g( ) se puedan lanzar/elevar (throw/throws) varios tipos de errores o excepciones en lugar de sólo una?
a) NO, se pueden poner varios bloques *catch* con un *try*. NOTA: parecido a la estructura: SWITCH: case1 + break, case2+break,.. default; b) SI, se pueden lanzar varias excepciones.
88
Sabemos que EXCEPTION es un mecanismo de Java que, por medio de ciertas sentencias (try-catch, throw/throws y finally) tratamos los errores sobre la marcha por medio de notificaciones entre un módulo y otro, pero ¿existe alguna manera de filtrar el tipo de errores que queremos tratar?
Si, con la siguiente Jerarquía de Criticidad: *ALL< DEBUG< INFO< WARN< ERROR< FATAL< OFF* *Con ALL saldrían todas las excepciones (notificaciones) y con OFF ninguna* EJEMPLO: si yo tuviera configurado el nivel *Warning*(WARN), las excepciones o errores de rango: INFO, DEBUG y ALL _no_ saldrían => SÓLO saldrían de WARN en adelate (ERROR< FATAL). mnemotecnia: ADIWEFO => que coño es? NI PUTA IDEA: ADIdas en la WEFa másculino? :/
89
Sabemos que con el fichero *log* podemos apreciar el comportamiento del sistema, porque registra cronológicamente todas las actividades (mensaje) de un sistema, pero ¿cómo podemos generar dichos mensajes que se registran en los *log*?
_API Logging_: este API es muy flexible pues genera / registra los mensajes de *log* en ficheros, BBDD, muestran por consola, ... Se puede configurar el formato de mensaje de *log* por si queremos sacar la fecha, la clase Java en la que se ha producido el error, el método, ... NOTA: esta es la librería de Java, aunque también existen otras de terceros (Log4j, LogBack, TinyLog o Apache Commons Log), y TODAS son gestionadas por la API SLF4J. Es decir, se llama al Api SLF4J y ella se encarga de implementar las demás. MNEMOTECNIA: la "F" (slF4j) significa Facade => indicando que esa Api SLF4J es la fachada de las demás.
90
Sabemos que la Api SLF4J ("Fachada") nos abstrae de todas las librerías de *loggin*, pero ¿cuáles son estas librerías que implementa SLF4J?
*Exactamente, usamos esta API de terceros (SLF4J) para independizarnos (abstraernos) del resto de librerías, es una especie de "fachada".* Esta "fachada" o "facade" (SLF4J) implementa las siguientes librerías para generar ficharos *log*: *java.util.LOGGING => es la de Java. *Log4J *LogBack *TinyLog IMPORTANTE: estas librerías para generar *log* se componen por 3 entidades: LOGGER, APPENDER y LogOut / Encoder.
91
Sabemos que tenemos la Api SLF4J para que se encargue de *implementar* las librerías (Logging, Log4J, LogBack, TinyLog, ...) para generar ficheros *log*, pero ¿de qué 3 entidades se componen dichas librerías?
1. LOGGER: es una entidad asociada a una clase donde configuramos el *level* de los mensajes *log* que queremos recibir y donde. Es decir, es una especie de filtrado, como con las *excepciones*, para que sólo procese los mensajes del level configurado o *superiores*: (ADIWEFO) *ALL< DEBUG< INFO< WARN< ERROR< FATAL< OFF* Ej: si se configura el LOGGER con el *level* WARN, sólo sacará los mensajes de WARN, ERROR... 2. APPENDER: (=adjunto) es el dispositivo en el que voy a generar el *log*. Es decir, LOGGER le pasa los mensajes de *log* para que APPENDER los ponga donde correspondan: BD, consola, fichero, ... 3. LayOut / EnCoder: manera de especificar el formato del mensaje *log* y que campos va a tener. (layout = diseño).
92
Sabemos que los *hilos* se encargan de ejecutar los programas, pero, además de los *hilos* por defecto, hay 2 maneras de crear hilos ¿define una?
Las 2 formas son: (Herencia y Runnable) Forma 1.HERENCIA de la Clase *THREAD* + sobrescritura del método *RUN ( )*, es decir: PRIMERO: definimos el *hilo*: *Class hilo Extends Thread* SEGUNDO: codificamos el método *run* que sobrescribimos de su clase abstracta: *@override public void run ( ){ //cuerpo de del hilo }* IMPORTANTE: el método de la clase THREAD con que se lanza el nuevo hilo y llama al método *run()* es: *hilo.start ( );* *Se colocaría en la Cola de Ejecución del "Planificador de Hilos" (scheduler) de la JRE y, cuando le toque, empezaría a ejecutarse por el método *run*.
93
Sabemos que los *hilos* se encargan de ejecutar los programas, pero, además de los *hilos* por defecto, hay 2 maneras de crear hilos ¿define una?
Las 2 formas son: (Herencia y Runnable) Forma 2. Implementando el interface *RUNNABLE* *class TareaBackUp implemets Runnable{* PRIMERO: Como todo interface esta compuesto por métodos (funciones) vacíos que tenemos que implementar => lo haremos codificando el método *run*. *@override public void run ( ){ //cuerpo de del hilo }* Como NO hereda de THREAD no es un hilo, entonces hay que crearlo: *Thread hilo = new Thread (CUERPO DEL HILO);* Ej: el ·cuerpo del hilo· puede ser TareaBackUp IMPORTANTE: el método start()( inicia el nuevo hilo y llama al método run(): *hilo.start ( );*
94
Sabiendo que los hilos se definen de 2 maneras (heredar de Thread o implmentando Runnable), explica cuál es su funcionamiento:
Los hilos van a dar saltos por los *objetos* y *métodos* (NO x las *clases*). Cuando hay muchos hilos de ejecución alrededor de un mismo *objeto* accediendo a él, podriamos tener el problema de sincronización (problema de lectura / escritura): SOLUCIÓN: como sabemos, todas las *clases* y *objetos* de Java heredan de la clase OBJECT (java.lang.OBJECT), por lo que todas tienen los métodos: WAIT ( ) y NOTIFY ( ). Son para gobernar todos los hilos, indicando cual entre (notify) y cual espera (wait). A continuación, con el método "SYNCHRONIZED" se sincronizan (secuencialmente) dichos hilos, momento en el cual el objeto pasa a funcionar como un *monitor*, que va dando paso a los hilos anteriormente *sincronizados*. _wait ( )_: pone en *espera* a los "consumidores" cuando NO hubieran datos que consumir. _notify ( )_: avisa a los consumidores de que ya hay datos a consumir. _synchronized_: sincroniza los hilos una vez que *notify* les da paso. Es decir, *wait* pausa o bloquea el hilo, hasta que sea avisado por *notify*, entonces *synchronized* se encarga de su acceso secuencial.
95
Sabemos que para evitar problemas de lectura / escritura, cuando varios hilos compartan el mismo atributo, habría que sincronizarlos (wait/notify => synchronized), pero ¿es posible saber que hilo esta pasando en un momento concreto?
Si, para ello puedes llamar a: *Thread.currentThread.getID* Es decir, obtiene el subproceso (hilo) actualmente en ejecución. public static System.Threading.Thread CurrentThread { get; }
96
¿Para qué sirven las herramientas MAVEN, GRANDLE, ANT, IVY, ...?
Son herramientas de consola, que todos los IDEs la tienen integrada y que estandariza la configuración de un proyecto en todo su ciclo de vida, por medio de 2 funciones: 1. AUTOMATIZACIÓN de la construcción (compilado, empaquetado, ...). 2. GESTOR de DEPENDENCIAS (instalación de LIBRERÍAS). NOTA: ANT no realiza la instalación de librerías, para ello se apoya en su extensión IVY. FICHERO PRINCIPAL DE _MAVEN: pom.xml FICHERO PRINCIPAL DE _ANT_: build.xml IMPORTANTE: también existen los *archetypes*, que son Plantillas de Proyecto que podemos definir. NOTA: mvnrepository.com => repositorio de Maven para buscar cualquier librería (Lombok, Gueva, ...).
97
Sabemos que el fichero principal de MAVEN es *pom.xml*, define la infraestructura de dicho fichero:
En dicho fichero (pom.xml) hay unas etiquetas llamadas , que tienen cada una 3 campos. Usados por los fabricantes para publicar sus librerías en internet, de manera que nunca coincidan en el mismo nombre. NOTA: CUALQUIER dependencia de MAVEN con Java tendrá esos 3 campos jerárquicos o coordenadas para localizarla. Es decir, dentro del *group ID* busca el *artifact-ID* y dentro busca la *version*. IMPORTANTE: en este fichero (pom.xml) declaramos la librería que necesitemos. Entonces, MAVEN se la descarga y la guarda en tú directorio oculto ".m2" (y ya siempre la tendrás disponible) NOTA: *maven* en Java es como *npm* en JavaScript.
98
Sabemos que, junto a ANT (IVY) o GRANDLE, *Maven* es una herramienta para "Automatizar Tareas" y "Gestor de Dependencias", pero ¿conoces algún comando?
*mvm package*: Hace el trabajo de compilar, verificar (TEST) y construir el proyecto. Construye el archivo jar y lo coloca en la carpeta (TARGET) especificada bajo el proyecto especificado. *mvn install*: instala el artefacto en el repositorio local de Maven. *mvn deploy*: despliega el artefacto en un repositorio remoto. *_Maven Artifact_: es un un bloque de código reutilizable. NO es lo mismo que un jar (java archive) o libreria. Porque, aunque un jar es un bloque de código reutilizable, *pero ya compilado*.
99
Sabemos que Apache MAVEN se encarga de la AUTOMATIZACIÓN de nuestro programa y la instalación de LIBRERÍAS, pero ¿cómo instalamos nosotros Maven?
1º Descargandonos de *maven.apache.org* el fichero ".zip": *apache.maven-3.x.x-bin.zip*, 2º Este fichero porta el comando *mvn*, pero para poder usarla tenemos que poner su ruta en la Variable de Entorno PATH (Linux), para darle visibilidad: *export PATH= $PATH: /users/TAINUX/apache.maven-3.x.x-bin* Ej: mvn version => para ver la versión de Maven y Java. 3º LO EJECUTAMOS: *mvn package* => Hace el trabajo de compilar, verificar y construir el proyecto. Construye el archivo jar y lo coloca en la carpeta (TARGET) especificada bajo el proyecto especificado. 4º Una vez compilado y empaquetado de Maven, configuramos el fichero *pom.xml* (vi pom.xml) para la gestión de dependencias, usando la librería LOMBOK (si, esa que nos servía para generar los métodos *getters* y *setters*). El pom.xml debe quedar así: **org.projectlombok** **lombok** **1.18.24** esto es una ruta: /user/projectlombok/lombok/1.18.24 NOTA: al rellenar esos 3 campos o coordenadas maven localiza la librería en su repositorio (repo.maven.apache.org) y te la descarga. Después la ejecutamos con el comando *mvn package*.CUALQUIER dependencia de MAVEN con Java tendrá esos 3 campos o coordenadas en el pom.xml para localizarla.
100
¿Cuál es la estructura de nuestros directorios que requiere Maven que tengamos?
src/main/java (adjunto foto) IMPORTANTE: fichero principal: pom.xml (donde configuramos las librerías a través de los 3 campos: group id, artifact id y version) repositorio de maven: repo.maven.apache.org
101
¿En qué se diferencian los 3 conceptos: Aplicación Concurrente, Programación Estructurada y Paralelismo?
_Aplicación Concurrente_: aplicación que se descompone en un conjunto de procesos que se ejecutan a la vez, pero NO en paralelo, se va cambiando de una a otro. Ej: tengo abiertos en mi PC: youtube, whaspp, utorrent descargando, ... _Programación Estructurada_: igual que el anterior, pero aquí si importa el orden de las tareas. _Paralelismo_: poder ejecutar varias tareas de manera simultanea, por lo cual, necesitaremos un equipo con varios procesadores.
102
¿Qué son las funciones LAMBDA? -->
Funciones anónimas, es decir, funciones que no necesitan *clase* => proporciona un tiempo de ejecución seguro y aislado. Es decir, es una manera de poner una función *anónima* para NO tener que crear una clase y un método. Simplemente le especificas en la parte de la IZQUIERDA el *parámetro entrada* y ( --> ) en la DERECHA el *cuerpo de la función*: Persona p --> {return p.getAltura ( ) { SIMBOLO: (-->)
103
¿Cuáles son los motores o versiones del mismo motor JavaScript para programar conjuntamente: Java, JavaScript, Phyton y Ruby?
El primer motor de JavaScript para programar con Java era RHINO, pero la llegada de Java8 trae una nueva versión NASHORN y que posteriormente fue sustituido por el definitivo GRAALVM. NOTA: con la VM _GraalVM_ ya podemos programar conjuntamente: Java, JavaScript, Python y Ruby. Por ello, la llaman la Máquina Virtual *POLIGLOTA*. RHINO-> NASHORN- (motores JavaScript para Java) > GraalVM (políglota).
104
¿Qué objetos van en linea con los *Streams* con la "Programación Funcional"?
_OBJETOS FUNCION_: Implementando la interface *@FunctionalInterface*, va en la linea de los STREAMS con la "Programación Funcional" => con la idea de crear funciones como si fueran "objetos propios" de una sóla función, sin necesidad de clases e interfaces. Es decir, una interface funcional es aquella que tiene un único método abstracto. Así de sencillo. No importa que además tenga métodos estáticos o implementados por defecto. Java 8 añadió la anotación @FunctionalInterface para marcar este tipo de interfaces. NOTA: la _programación_ _funcional_ esta basada en el uso de verdaderas funciones matemáticas, con sus raíces en el calculo LAMBDA (diseñado para investigar la definición de función). En este estilo de programación las funciones son ciudadanas de primera clase. NOTA2: una _función_ es una subrutina o subprograma (también llamada rutina o método), que forma parte del algoritmo principal y resuelve una tarea específica.
105
Sabemos que una *interfaz* esta compuesta por métodos vacíos (sin código), pero ¿esto siempre es así?
No, con la llegada de Java 8 se trajeron los *Default Method* (métodos por defecto) para rellenar con código algunos métodos en interfaces con la palabra reservada _DEFAULT_
106
¿Para qué se invento la *Programación Asíncrona* y en que se diferencia de la *Programación Multihilo* (wait-notify, synchronized, monitores, ...)?
A diferencia de la MULTIHILO, en la que podíamos trabajar con múltiples hilos gracias a los métodos "wait", "notify" y "synchronized" (heredados de la clase OBJECT). La Programación ASÍNCRONA ejecuta una tarea u otra dependiendo del resultado del proceso. Se inventó para hacer aplicaciones *concurrentes* más finas o espectaculares. NOTA: la *Programación Concurrente* consiste en múltiples tareas que se inician, ejecutan y completan en períodos de tiempo superpuestos, sin un orden específico. NO en paralelo. Ej: vas saltando de una tarea a otro, aunque están todas disponibles: youtube, whasapp, utorrent, BDO, ...
107
Sabemos que los "stream" van encadenando cosas hasta llegar al resultado final, son un tipo de *Programación Funcional*, pero ¿qué es un STREAM y tipos?
Los STREAMs son una nueva funcionalidad en Java 8 que nos ayudan a manipular nuestra colecciones (buscar, filtrar, reordenar, reducir, etc…) Se puede declarar con el método *of* de la clase *Stream*: *Stream.of ("Maria", "Juan", "Oliver") Hay dos tipos de flujos en Java: byte y carácter. Cuando un flujo de E/S administra bytes de 8 bits de datos binarios sin formato, se denomina flujo de bytes. Y, cuando el flujo de E/S administra caracteres Unicode de 16 bits, se denomina flujo de caracteres.
108
¿Con qué herramienta de la JDK se genera documentación HTML a partir del código fuente?
javadoc
109
¿Cuándo se utiliza final en la definición de un método?
Cuando no queremos que las clases “hijas” puedan sobrescribirlo.
110
¿Una clase puede implementar varios interfaces?
Sí. Lo que no puede es heredar de varias clases (no existe la herencia múltiple).
111
¿Es posible *instanciar* una clase abstracta?
No, es una clase pensada para que hereden de ella y terminar de definir sus métodos abstractos.
112
¿Cómo podríamos averiguar si un objeto pertenece a una clase que implementa un interface?
Existen dos métodos: 1. API _Reflexion_ . 2. Con _instanceof_. NOTA: la API Reflect nos permite inspeccionar y manipular clases e interfaces completas (es decir métodos y campos) en tiempo de ejecución
113
¿Para qué usamos la palabra reservada *static* en un atributo de una clase?
Para definir que ese atributo “pertenece” a la clase y no a los distintos objetos de la misma, es decir, la clase en Java también ocupa memoria.
114
¿Qué uso tiene la clase java.lang.Object?
Es la clase de la que hereda cualquier clase en Java (del sistema o las nuestras). De esta forma cualquier objeto en Java tendrá siempre una serie de métodos importantes como: * toString() * equals() * hashCode() * wait() * notify() * finalize()
115
¿Cómo se declara una constante en Java?
static final
116
¿De qué dos formas se puede crear hilos en Java?
1. Heredando de la clase _Thread_. 2. Implementando el interface _Runnable_.
117
¿Se puede modificar un objeto de la clase String por ej. para transformarlo a mayúsculas?
No, la clase String es inmutable. Para eso tenemos StringBuffer y StringBuilder.
118
Si en un método nos pasan un parámetro de tipo Object, ¿podemos saber de qué clase es realmente?
Si, con el método getClass() –> nos devuelve un objeto de tipo Class (API de la Reflexion). NOTA: la API Reflect nos permite inspeccionar y manipular clases e interfaces (completas es decir métodos y campos) en tiempo de ejecución
119
¿Qué librerías conoces para manipular información en formato JSON en Java?
Jackson GSON (de google)
120
¿Qué librerías conoces para poder generar ficheros de log?
*TinyLog *log4j *logback *slf4j (es una fachada para cualquiera de las anteriores, es decir, nosotros llamamos a SLF4J y este se encarga de gestionar las librerías de “logging”)