Las 50 mejores preguntas y respuestas de entrevistas de trabajo para Java Core. Parte 1

¡Hola a todos, damas y caballeros, ingenieros de software! Hablemos de las preguntas de la entrevista. Acerca de lo que necesita para prepararse y lo que necesita saber. Este es un buen momento para repasar o estudiar estos puntos por primera vez. Terminé con una colección bastante extensa de preguntas frecuentes sobre programación orientada a objetos, sintaxis de Java, excepciones de Java, colecciones y subprocesos múltiples, que dividiré en varias partes para mayor comodidad. Es difícil cubrir todo a la vez, pero espero que este material proporcione una buena base para aquellos que se preparan para encontrar su primer trabajo como programadores. Para una mejor comprensión y retención, aconsejo buscar también en otras fuentes. Puede obtener una comprensión más profunda de un concepto al abordarlo desde varios ángulos diferentes. Importante:Solo hablaremos de Java antes de la versión 8. Todas las innovaciones que vinieron en las versiones 9, 10, 11, 12 y 13 no se considerarán aquí. Cualquier idea/comentario sobre cómo mejorar las respuestas es bienvenido . Disfrute de su lectura. ¡Vamos!

Entrevista Java: preguntas sobre programación orientada a objetos

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

Respuesta:

1. conceptos de programación orientada a objetos:

   1. orientación a objetos
   2. herencia
   3. encapsulación
   4. polimorfismo
   5. abstracción

2. Multiplataforma: un programa Java se puede ejecutar en cualquier plataforma sin ningún cambio. Por supuesto, esto requiere una JVM (máquina virtual Java) instalada.

3. Alto rendimiento: el compilador Just-In-Time (JIT) hace posible un alto rendimiento. El compilador JIT convierte el código de bytes en código de máquina y luego la JVM comienza a ejecutarse.

4. Subprocesamiento múltiple: la JVM crea un subproceso de ejecución llamado main thread. Un programador puede crear varios subprocesos derivándolos de la clase Thread o implementando la Runnableinterfaz.

2. ¿Qué es la herencia?

Herencia significa que una clase puede heredar otra clase (usando la palabra clave extends ). Esto significa que puede reutilizar el código de la clase que hereda. La clase existente se conoce como superclassy la clase recién creada es subclass. La gente también dice que use los términos padre y child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

donde Animalesta el parenty Doges el child.

3. ¿Qué es la encapsulación?

Esta pregunta se hace a menudo en entrevistas para puestos de desarrollador de Java. La encapsulación oculta la implementación mediante el uso de modificadores de acceso, getters y setters. Esto se hace para evitar el acceso externo donde los desarrolladores lo consideren necesario. Un ejemplo simple de la vida real es el automóvil. No tenemos acceso directo al funcionamiento del motor. Todo lo que tenemos que hacer es poner la llave en el encendido y encender el motor. Los procesos que tienen lugar bajo el capó no son de nuestra incumbencia. Además, si tuviéramos que interferir en la actividad del motor, podría conducir a una situación impredecible, posiblemente dañando el automóvil y resultando en lesiones corporales. Exactamente lo mismo sucede en la programación. Esto se describe bien en Wikipedia .. También hay un artículo sobre encapsulación en CodeGym .

4. ¿Qué es el polimorfismo?

El polimorfismo es la capacidad de un programa para tratar objetos con la misma interfaz de la misma manera, sin información sobre el tipo específico del objeto. Como dice el refrán, "una interfaz, muchas implementaciones". Con polimorfismo, puede combinar y usar diferentes tipos de objetos en función de comportamientos compartidos. Por ejemplo, tenemos una clase Animal que tiene dos descendientes: Perro y Gato. La clase genérica Animal tiene un comportamiento compartido por todos, la capacidad de emitir un sonido. Usamos capacidades polimórficas cuando necesitamos recopilar todo lo que hereda la clase Animal y ejecutar el método "hacer sonido". Así es como se ve:

List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());

En otras palabras, el polimorfismo es útil. Y esto también se aplica a los métodos polimórficos (sobrecargados). Cómo usar el polimorfismo

Preguntas de la entrevista sobre la sintaxis de Java

5. ¿Qué es un constructor en Java?

Los constructores tienen las siguientes características:

1. Cuando se crea un nuevo objeto, el programa usa el constructor apropiado para crearlo.
2. Un constructor es como un método. Sus características distintivas radican en el hecho de que no hay valor de retorno (incluido void) y que su nombre es el mismo que el nombre de la clase.
3. Si no se crea ningún constructor explícitamente, se crea automáticamente un constructor vacío.
4. Un constructor puede ser anulado.
5. Si declara un constructor con parámetros pero también necesita uno sin parámetros, debe crearlo por separado, ya que no se creará automáticamente.

6. ¿Qué dos clases no heredan Object?

No se deje engañar por las preguntas capciosas: no existen tales clases. ¡Todas las clases heredan la clase Object ya sea directamente oa través de antepasados!

7. ¿Qué es una variable local?

Esta es otra pregunta de entrevista popular para los desarrolladores de Java. Una variable local es una variable que se define dentro de un método y existe mientras se ejecuta el método. Tan pronto como finaliza la ejecución, la variable local deja de existir. Aquí hay un programa que usa una variable local llamada helloMessage en el método main():

public static void main(String[] args) {
   String helloMessage;
   helloMessage = "Hello, World!";
   System.out.println(helloMessage);
}

8. ¿Qué es una variable de instancia?

Una variable de instancia es una variable que se declara dentro de una clase. Existe mientras existe un objeto. Por ejemplo, tenemos una clase Bee, que tiene dos variables de instancia: nectarLoad y maxNectarLoad:

public class Bee {

   /**
    * Current nectar load
    */
   private double nectarLoad;

   /**
    * Maximum nectar that can the bee can collect.
    */
   private double maxNectarLoad = 20.0;
 
  ...
}

9. ¿Qué son los modificadores de acceso?

Los modificadores de acceso son un mecanismo para personalizar el acceso a clases, métodos y variables. Existen los siguientes modificadores, enumerados en orden creciente de acceso:

1. private— Este modificador de acceso se usa en métodos, campos y constructores. El acceso está limitado a la clase en la que se declaran.
2. package-private (default)— Este es el nivel de acceso predeterminado para las clases. El acceso está limitado al paquete específico en el que se declara una clase, método, variable o constructor.
3. protected— Este modificador de acceso ofrece el mismo nivel de acceso que package-privatecon la adición de acceso para las clases que heredan una clase con el protectedmodificador.
4. public— Este nivel de acceso también se utiliza para las clases. Este nivel de acceso significa que hay acceso completo en toda la aplicación.

10. ¿Qué es la anulación de métodos?

Anulamos los métodos cuando una clase secundaria quiere cambiar el comportamiento de su clase principal. Si también necesitamos hacer lo que está en el método principal, podemos usar super.methodName() en el método secundario, que ejecutará el método principal. Podemos agregar nuestra lógica adicional después de eso. Requisitos que se deben observar:

• la firma del método debe ser la misma
• el valor de retorno debe ser el mismo

11. ¿Qué son las firmas de métodos?

La firma de un método es la combinación del nombre del método y los argumentos que toma el método. La firma del método es el identificador único de un método cuando se sobrecargan métodos.

12. ¿Qué es la sobrecarga de métodos?

La sobrecarga de métodos es una característica del polimorfismo en la que cambiamos la firma del método para crear varios métodos que realizan la misma acción:

• el mismo nombre
• diferentes argumentos
• puede haber diferentes tipos de devolución

Por ejemplo, el método ArrayListde la clase add()se puede sobrecargar, permitiéndonos agregar de diferentes maneras dependiendo de los argumentos de entrada:

• add(Object o)— Este método simplemente agrega un objeto
• add(int index, Object o)— Este método agrega un objeto en un índice específico
• add(Collection<Object> c)— Este método agrega una lista de objetos
• add(int index, Collection<Object> c)— Este método agrega una lista de objetos a partir de un índice específico.

13. ¿Qué es una interfaz?

Java no admite la herencia múltiple. Para superar esta limitación, se agregaron interfaces en la forma que conocemos y amamos;) Durante mucho tiempo, las interfaces solo tenían métodos sin ninguna implementación. En el contexto de esta respuesta, hablemos de ellos. Por ejemplo:

public interface Animal {
   void makeSound();
   void eat();
   void sleep();
}

Algunos detalles se desprenden de esto:

• Todos los métodos en una interfaz son públicos y abstractos.
• Todas las variables son públicas estáticas finales
• Las clases no heredan interfaces (es decir, no usamos la palabra clave extends). En su lugar, las clases los implementan (es decir, usamos la palabra clave implements). Además, puede implementar tantas interfaces como desee.
• Las clases que implementan una interfaz deben proporcionar una implementación de todos los métodos que se encuentran en la interfaz.

Como esto:

public class Cat implements Animal {
   public void makeSound() {
       // Method implementation
   }

   public void eat() {
       // Implementation
   }

   public void sleep() {
       // Implementation
   }
}

14. ¿Qué es un método predeterminado en una interfaz?

Ahora hablemos de los métodos predeterminados. ¿Para qué son? ¿Para quién son? Estos métodos se agregaron para servir a "ambas manos". ¿De qué estoy hablando? Bueno, por un lado, era necesario agregar una nueva funcionalidad: lambdas y la API Stream. Por otro lado, era necesario conservar aquello por lo que Java es famoso: la compatibilidad con versiones anteriores. Para hacer esto, las interfaces necesitaban algunas nuevas soluciones listas para usar. Así es como nos llegaron los métodos predeterminados. Un método predeterminado es un método implementado en una interfaz, marcado con la defaultpalabra clave. Por ejemplo, el conocido stream()método en la Collectioninterfaz. Créame, esta interfaz no es tan simple como parece. O también el igualmente famoso forEach()método en elIterableinterfaz. Tampoco existía hasta que se agregaron los métodos predeterminados. Por cierto, también puedes leer sobre esto en CodeGym aquí .

15. Entonces, ¿cómo heredamos dos métodos predeterminados idénticos?

La respuesta anterior sobre qué es un método predeterminado plantea otra pregunta. Si puede implementar métodos en interfaces, teóricamente puede implementar dos interfaces con el mismo método. ¿Como hacemos eso? Aquí hay dos interfaces diferentes con el mismo método:

interface A {
   default void foo() {
       System.out.println("Foo A");
   }
}

interface B {
   default void foo() {
       System.out.println("Foo B");
   }
}

Y tenemos una clase que implementa estas dos interfaces. Pero, ¿cómo elegimos un método específico en la interfaz A o B? La siguiente construcción especial permite esto: A.super.foo():

public class C implements A, B {
   public void fooA() {
       A.super.foo();
   }

   public void fooB() {
       B.super.foo();
   }
}

Por lo tanto, el fooA()método utilizará el foo()método predeterminado de la Ainterfaz, mientras que el fooB()método utilizará el foo()método de la Binterfaz.

16. ¿Qué son los métodos y clases abstractos?

En Java, abstractes una palabra reservada. Se utiliza para denotar clases y métodos abstractos. Primero, necesitamos definiciones. Un método abstracto es un método que se declara utilizando la abstractpalabra clave sin una implementación en una clase abstracta. Es decir, este es un método como en una interfaz, pero con la adición de una palabra clave, por ejemplo:

public abstract void foo();

Una clase abstracta es una clase también marcada con la abstractpalabra clave:

public abstract class A {

}

Una clase abstracta tiene varias características:

• no puedes crear un objeto de una clase abstracta
• puede tener métodos abstractos
• también puede no tener métodos abstractos

Las clases abstractas son necesarias para la abstracción (perdón por la tautología) que tiene un conjunto de comportamientos y estados comunes (es decir, métodos y variables). La vida real está llena de ejemplos. Todo lo que nos rodea. "Animal", "Coche", "Figura geométrica", etc.

17. ¿Cuál es la diferencia entre String, StringBuilder y StringBuffer?

Stringlos valores se almacenan en un conjunto de cadenas constantes. Tan pronto como se crea una cadena, aparece en este grupo. Y no puedes borrarlo. Por ejemplo:

String name = "book";

La variable apuntará al conjunto de cadenas constantes Al configurar la variable de nombre en un valor diferente, tenemos:

name = "pen";

El conjunto de cadenas constantes se ve así: en otras palabras, ambos valores permanecen allí. Búfer de cadena:

• Stringlos valores se almacenan en una pila. Si se cambia un valor, el nuevo valor reemplazará al antiguo.
• String Bufferestá sincronizado y, por lo tanto, es seguro para subprocesos.
• Debido a la seguridad de subprocesos, su rendimiento es deficiente.

Ejemplo:

StringBuffer name = “book”;

Tan pronto como cambia el valor de la variable de nombre, cambia el valor de la pila: StringBuilder es exactamente igual que StringBuffer, solo que no es seguro para subprocesos. Como resultado, es notablemente más rápido que StringBuffer.

18. ¿Cuál es la diferencia entre una clase abstracta y una interfaz?

Clase abstracta:

• Las clases abstractas tienen un constructor predeterminado. Se llama cada vez que se crea un descendiente de la clase abstracta.
• Pueden incluir tanto métodos abstractos como no abstractos. En general, una clase abstracta no tiene que tener métodos abstractos.
• Una clase que hereda una abstracta debe implementar solo métodos abstractos.
• Una clase abstracta puede tener variables de instancia (vea la Pregunta #5).

Interfaz:

• Una interfaz no tiene constructor y no se puede inicializar.
• Solo se pueden agregar métodos abstractos (excepto los métodos predeterminados).
• Las clases que implementan la interfaz deben implementar todos los métodos (excepto los métodos predeterminados).
• Las interfaces solo pueden tener constantes.

19. ¿Por qué acceder a un elemento de un arreglo es O(1)?

Esta pregunta fue hecha literalmente en mi última entrevista. Como aprendí más tarde, el propósito de esta pregunta es ver cómo piensa una persona. Claramente, hay poco valor práctico en este conocimiento. Simplemente saberlo es suficiente. Primero, debemos aclarar que O(1) es una notación para la complejidad temporal de un algoritmo de "tiempo constante". En otras palabras, esta designación indica el tiempo de ejecución más rápido. Para responder a esta pregunta, debemos considerar lo que sabemos acerca de las matrices. Para crear una intmatriz, debemos escribir lo siguiente:

int[] intArray = new int[100];

Se pueden sacar varias conclusiones de esta sintaxis:

1. Cuando se declara una matriz, se conoce su tipo. Si se conoce el tipo, se conoce el tamaño de cada celda de la matriz.
2. Se conoce el tamaño de toda la matriz.

Por lo tanto, para comprender en qué celda escribir, solo necesitamos calcular en qué área de memoria escribir. Para una computadora, esto es muy fácil. La computadora sabe dónde comienza la memoria asignada, la cantidad de elementos y el tamaño de cada celda. Todo esto significa que el lugar para escribir será igual al lugar de inicio de la matriz + el tamaño de cada celda multiplicado por el índice.

Entonces, ¿cómo llegamos a O(1) cuando accedemos a objetos en un ArrayList?

Esta pregunta sigue inmediatamente a la anterior. La verdad es que cuando se trabaja con una matriz que contiene primitivas, sabemos de antemano (en el momento de la creación) el tamaño del tipo de elemento. Pero, ¿qué hacemos si tenemos este tipo de jerarquía de herencia y queremos crear una colección para elementos de tipo A y agregar diferentes implementaciones (B, C y D):

List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());

En esta situación, ¿cómo calculamos el tamaño de cada celda? Después de todo, cada objeto será diferente, posiblemente con diferentes campos adicionales. ¿Qué hacer? Aquí la pregunta se plantea de una manera que pretende confundirte. Sabemos que la colección no almacena objetos directamente. Solo almacena referencias a objetos. Y todas las referencias tienen el mismo tamaño, y se sabe. Como resultado, aquí calculamos las direcciones de la misma manera que en la pregunta anterior.

21. Autoboxing y unboxing

Antecedentes históricos: el autoboxing y el unboxing son algunas de las principales innovaciones de JDK 5. El autoboxing es el proceso de conversión automática de un tipo primitivo a una clase contenedora correspondiente. Unboxing es exactamente lo contrario de autoboxing. Es el proceso de convertir una clase contenedora en una primitiva. Pero si el valor de un envoltorio es , se lanzará nullun durante el desempaquetado.NullPointerException

Primitivas y sus correspondientes envoltorios

// Ocurre el autoboxeo:

• al asignar una primitiva a una referencia a una clase contenedora:

  ANTES de Java 5:

  
  // Manual boxing (the way it was BEFORE Java 5).
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // And so on for other types
  }
  
  After Java 5:
  // Automatic boxing (the way it became in Java 5).
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // And so on for other types
  }
  

• cuando se pasa una primitiva como argumento a un método que espera un contenedor:

  
  public void exampleOfAutoboxing() {
     long age = 3;
     setAge(age);
  }
  
  public void setAge(Long age) {
     this.age = age;
  }
  

// Ocurre el desempaquetado:

• cuando asignamos una instancia de una clase contenedora a una variable primitiva:

  
  // BEFORE Java 5:
  int intValue = new Integer(4).intValue();
  double doubleValue = new Double(2.3).doubleValue();
  char c = new Character((char) 3).charValue();
  boolean b = Boolean.TRUE.booleanValue();
  
  // And after JDK 5:
  int intValue = new Integer(4);
  double doubleValue = new Double(2.3);
  char c = new Character((char) 3);
  boolean b = Boolean.TRUE;
  

• Durante las operaciones aritméticas. Las operaciones se aplican solo a tipos primitivos, por lo que es necesario desempaquetar a los primitivos.

  
  // BEFORE Java 5:
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // A comparison used to require this:
  integerBox1.intValue() > integerBox2.intValue()
        
  // In Java 5
  integerBox1 > integerBox2
  

• al pasar una instancia de una clase contenedora a un método que toma la primitiva correspondiente:

  
  public void exampleOfAutoboxing() {
     Long age = new Long(3);
     setAge(age);
  }
  
  public void setAge(long age) {
     this.age = age;
  }
  

22. ¿Cuál es la palabra clave final y dónde se usa?

La finalpalabra clave se puede utilizar en variables, métodos y clases.

1. El valor de una variable final no se puede cambiar después de inicializarla.
2. Una última clase es estéril :) No puede tener hijos.
3. Un método final no puede ser anulado por un descendiente.

Hemos cubierto las cosas de alto nivel. Ahora vamos a sumergirnos más profundo.

variables finales

Java nos da dos formas de declarar una variable y asignarle un valor:

1. Puede declarar una variable e inicializarla más tarde.
2. Puede declarar una variable y asignarle un valor de inmediato.

Aquí hay un ejemplo que demuestra estos usos de las variables finales:

public class FinalExample {

   // A static final variable that is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";

   // A final variable that is not initialized, but will only work if you
   // initialize it in the constructor:
   final long creationTime;

   public FinalExample() {
       this.creationTime = System.currentTimeMillis();
   }

   public static void main(String[] args) {
       FinalExample finalExample = new FinalExample();
       System.out.println(finalExample.creationTime);

       // The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
//    FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";

       // The final Config.creationTime field cannot be accessed
//    finalExample.creationTime = 1L;
   }
}

¿Puede una variable final ser considerada una constante?

Como no podemos asignar nuevos valores a las variables finales, parece que estas son variables constantes. Pero solo a primera vista: si el tipo de datos de la variable es immutable, entonces sí, es una constante. Pero si el tipo de datos es mutable, es decir, cambiable, entonces será posible usar métodos y variables para cambiar el valor del objeto al que hace referencia una finalvariable. Debido a esto, no se puede llamar una constante. El siguiente ejemplo muestra que algunas variables finales son realmente constantes, mientras que otras no lo son, ya que se pueden cambiar.

public class FinalExample {

   // Immutable final variables
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
   final static Integer FINAL_EXAMPLE_COUNT  = 10;

   // Mutable final variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}

Variables finales locales

Cuando finalse crea una variable dentro de un método, se llama local finalvariable:

public class FinalExample {

   public static void main(String[] args) {
       // You can do this
       final int minAgeForDriveCar = 18;

       // Or you can do this, in a for-each loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

Podemos usar la palabra clave final en un bucle for mejorado, porque se crea una nueva variable después de cada iteración del bucle. Tenga en cuenta que esto no se aplica a un ciclo for normal, por lo que obtendremos un error en tiempo de compilación.

// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
   System.out.println(args[i]);
}

última clase

Una clase declarada como finalno se puede extender. En pocas palabras, ninguna otra clase puede heredarla. Un excelente ejemplo de una finalclase en el JDK es String. El primer paso para crear una clase inmutable es marcarla como final, evitando así que se extienda:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

Métodos finales

Cuando un método se marca como final, se llama método final (tiene sentido, ¿verdad?). Un método final no se puede anular en una clase secundaria. Por cierto, los métodos wait() y notificar() de la clase Object son definitivos, por lo que no tenemos la capacidad de anularlos.

public class FinalExample {
   public final String generateAddress() {
       return "Some address";
   }
}

class ChildOfFinalExample extends FinalExample {

   // Compilation error!
   @Override
   public String generateAddress() {
       return "My OWN Address";
   }
}

Cómo y dónde usar final en Java

• Use la palabra clave final para definir algunas constantes de nivel de clase;
• Cree variables finales para los objetos que no desea que se modifiquen. Por ejemplo, propiedades específicas de objetos que podemos usar para fines de registro.
• Si no desea que se extienda una clase, márquela como final.
• Si necesita crear una clase inmutable, debe hacerla definitiva.
• Si desea que la implementación de un método no cambie en sus descendientes, marque el método como final. Esto es muy importante para asegurarse de que la implementación no cambie.

23. ¿Qué son los tipos mutables e inmutables?

Mudable

Los objetos mutables son objetos cuyo estado y variables se pueden cambiar después de la creación. Los ejemplos de clases mutables incluyen StringBuilder y StringBuffer. Ejemplo:

public class MutableExample {

   private String address;

   public MutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // This setter can change the name field
   public void setAddress(String address) {
       this.address = address;
   }

   public static void main(String[] args) {

       MutableExample obj = new MutableExample("First address");
       System.out.println(obj.getAddress());

       // We are updating the name field, so this is a mutable object
       obj.setAddress("Updated address");
       System.out.println(obj.getAddress());
   }
}

Inmutable

Los objetos inmutables son objetos cuyo estado y variables no se pueden cambiar después de crear el objeto. Una gran clave para un HashMap, ¿no crees? :) Por ejemplo, Cadena, Entero, Doble, etc. Ejemplo:

// We'll make this class final so no one can change it
public final class ImmutableExample {

   private String address;

   ImmutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // We remove the setter

   public static void main(String[] args) {

       ImmutableExample obj = new ImmutableExample("Old address");
       System.out.println(obj.getAddress());

       // There is no way to change this field, so it is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

En la siguiente parte, consideramos preguntas y respuestas sobre colecciones. Mi perfil en GitHub Las 50 mejores preguntas y respuestas de entrevistas de trabajo para Java Core. Parte 2