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();
      }
  }