Java

Compilación de algunos códigos de Java

Java basics

Diferencia entre JDK, JRE y JVM
- JVM(Java Virtual Machine). Es una máquina abstracta. Es una especificación que provee un ambiente en tiempo de ejecución que el bytecode de Java utiliza para ejecutarse.
- JRE(Java Runtime Environment). Es un ambiente en tiempo de ejecución que implementa JVM y provee todas las librerias y otros archivos que la JVM usa en tiempo de ejecución.
- JDK(Java Development Kit). Es una herramienta necesaria para compilar, documentar y empaquetar programas de Java. El JDK incluye completamiente JRE.
Sincronización
- La sincronización es un proceso que mantiene a todos los hios de ejecuación en sintonía.
- La sincronización evita errores de consistencia en memoria causados por la memoria compartidad entre los hilos.
Hilos vs Procesos
Wrapper class
- Los 8 tipos primitivos de datos de Java tiene una clase dedicada correspondiente, las cuales llamamos wrapper classes o clases envolventes, porque envuelven los tipos de datos en objetos de esa clase.
- Boing vs Unboxing
```
int integer = 10;
Integer intRef = new Integer(integer) // Boxing
int j = intRef.intValue(); // Unboxing
Integer kRef = i; // Autoboxing
int l = kRef; // Autounboxking
        
```
- Una ventaja es que podemos pasar por referencia los tipos de datos primitivos.
Diferencia entre las palabras reservadas final, finally y finalize fulfill
- Final. Se usa para aplicar restricciones a una clase, un método o variable.
  - Una Clase final no puede heredar
  - Un Método final no se puede sobreescribir
  - Una Variable final no se le puede cambiar el valor.
- Finally. Se utiliza para poner código que se ejecutará sin importar si una excepción surge o no.
- Finalize. Se utiliza para un proceso de limpieza justo antes del que objecto sea recolectado pro el Garbage Collector
```
class FinalizaExample {
    public void finalize() throws Throwable {
        System.out.printlin("Finalize is called");
    }
}
class Demo {
    public void static main(String[] args) {
        System.out.printlin("Doing things ...");

        FinalizaExample fRef = new FinalizaExample();
        fRef = null;
        System.gc();
    }
}
        
```

Diferencia entre StringBuffer y StringBuilder

Las operaciones de StringBuffer son thread-safe y sincronizadas, mientras que las operaciones de StringBuilder NO son thread-safe.
StringBuffer se suele utilizar cuando varios hilos estan trabajan sobre la misma cadena.

El rendimiento de StringBuilder es mayor comparado con StringBuffer.

class Demo {
    public void static main(String[] args) {
        String str1 = new String("Hello");
        StringBuilder builder = new StringBuilder("Hello");
        StringBuffer buffer = new StringBuffer("Hello");

        str.concat(" Hi..."); // Inmutable
        builder.append(" Hi..."); // Mutable
        buffer.append(" Hi..."); // Mutable
    }
}

Diferencias entre Heap y Stack memory

class Point {
    int x,y;
    void showPoint() {
        System.out.println("Point is: " + x + "-" + y);
    }
}

public static void main(String[] args) {
    // Construccion del objeto
    Point p1 = new Point();

    System.out.println(p1); // Point@12834
}

Diferencia entre ArrayList y Vector
Diferencia entre HashMap y HashTable

Java OOP

Diferencia entre Clases abstractas e Interfaces

/*
class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

abstract class Shape {
    Shape() {
        System.out.println("Shape is constructed");
    }
    abstract draw(); // No definition
}
*/

interface Shape {
    void draw();
}

//class Rectangle extends Shape { // Object to Object inheritance
class Rectangle implements Shape { // NO Object to Object inheritance
    void draw() { // Override (mandatory)
        System.out.println("Drawing a Rectangle");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a Circle");
    }
}

class Polygon extends Shape {
    void draw() {
        System.out.println("Drawing a Polygon");
    }
}

public class Demo {
    public static void main(String[] args) {
        Shape s;
        s = new Circle(); // Polymorphic statement - UPCASTING
        s.draw();
    }
}

¿Qué es polimorfismo? Describe una interface que puede tener muchas implementaciones. Es una característica que nos permite asignar diferentes significados o usos a algo en diferentes contextos.
Diferencia entre overloading y overriding en métodos
Ejemplo

¿Se puede sobreescribir un método privado o estático en Java?

#+name Test.java

class Base {
    private static void display() { System.out.println("Static from Base"); }
    public void print() { System.out.println("Non-static from Base"); }
}

clase Derived extends Base {
    private static void display() { System.out.println("Static from Derived"); }
    public void print() { System.out.println("Non-static from Derived"); }
}
public class Test {
    public static void main(String[] args) {
        Base obj1 = new Derived();
        obj1.display();
        obj1.print();
    }
}

roverty/Java

Java

Java basics

Java OOP