Quelles sont les bonnes questions et réponses d'entrevue java concernant les génériques et les annotations? [fermé]

Depuis la sortie de Java 5, j'ai vu des dizaines de personnes ne pas comprendre pourquoi, étant donné une interface I, et les classes A et B extends A vous ne pouvez pas passer un I<B> où un I<A> est requis. Beaucoup de gens trouvent cela contre-intuitif.

Pour tester la capacité d'une personne à raisonnerà propos des génériques, je leur demanderais d'abord s'il est possible d'attribuer un I<B> à une référence I<A> comme décrit ci-dessus. Si non, pourquoi pas? S'ils se trompent, dites-leur qu'ils ont tort et demander pour essayer de remplir les blancs ici pour montrer pourquoi cet exemple serait de type non sûr s'il pouvait compiler:

   //...
   List<String> list = new LinkedList<String>();
   someMethod(list);
   //blank 1
}
public void someMethod(List<Object> list) {
   //blank 2
}

À ce stade, cela devrait être assez facile et je serais un peu inquiet s'ils ne pouvaient pas construire un tel exemple. Un exemple est

//blank 1
String item = list.get(0);

//blank 2
list.add(Integer.valueOf(5));

Ce test:

Http://tests4geeks.com/test/java

Contient quelques questions sur les annotations.

Il ne contient aucune question sur le générique. Mais au lieu de cela, il y a d'autres thèmes intéressants comme:

Multi-Threading,

Mémoire,

Algorithmes et structures de données,

POO,

Etc.

• Qu'est-ce que le Class Enum<E extends Enum<E>> assure?
• Est-ce que <T> List<? extends T> x() est une signature utile?
• Les politiques de rétention des annotations et pourquoi sont-elles en place?
• Supposons que vous souhaitiez réutiliser une classe dans différents contextes utiliseriez-vous des annotations ou une configuration externe? (c'est-à-dire que l'annotation introduit des dépendances).

Plus Difficile:

• Exemples d'un type générique valide qui ne peut pas être exprimé avec le système de type Java et conduira à des avertissements du compilateur.
• Exemples où le compilateur java va / ne va pas inférer le type générique? (exemples de code où le compilateur infère le mauvais type)
• Quelles informations de type générique ne sont pas effacées et peuvent être récupérées à partir du code octet? (Super type tokes sont une application)
• Qu'est-ce que APT (cas d'utilisation quand ne pas utiliser la réflexion)?

Question: Comment pouvez-vous déterminer quel type d'objet un générique utilise au moment de l'exécution?

Réponse:, Il n'est pas possible de déterminer le type par type d'effacement.

1. Générique:

Q: Quelle est la différence entre une Hashmap et une Hashtable?

A: Hashtable est synchronisé, Hashmap ne l'est pas.

1. Annotations:

Q: Décrivez la sérialisation des objets java avec le javax.XML.lier.Interface Marshaller et annotations.

A: Décrire quelque chose comme ça dans un contexte significatif devrait être acceptable:

@XmlRootElement
class Employee {
...
}

Génériques: Poser une question conçus pour voir s'ils comprennent type d'effacement.

Annotations: Demandez-leur quelle est leur annotation préférée et comment cela fonctionne (vous n'avez pas besoin d'une explication technique détaillée, mais vous cherchez quelque chose de plus que de la "magie").

Annotations: Quels sont les risques? (le compilateur peut entrer dans une boucle infinie et bloquer le processus de construction).

Génériques: Comment construire un mixin en utilisant des génériques? (écrivez une classe générique qui prend un paramètre, puis étendez-le avec la sous-classe comme paramètre).

Aussi, +1 sur l'effacement de type.

Si vous êtes à la recherche d'un programmeur Java rock star, vous pouvez créer quelques questions avancées à partir du chapitre Generics dans le Java efficace de Bloch. Des choses comme les conteneurs homogènes ou hétérogènes (les exemples de cage à oiseaux et de cage à lion d'un des tutoriels java), l'effacement, etc.

Chez les personnes moins âgées, je cherche principalement à comprendre pourquoi on voudrait des génériques (vous seriez surpris de voir combien de personnes n'apprécient pas cela et croient à la façon Java 2 de faire des choses encore des règles), et des choses comme ça.

Dans les annotations, j'aime poser des questions sur l'annotation "Override" et ses avantages. J'aime aussi avoir une discussion plus approfondie sur les avantages et les inconvénients des annotations et quand il est approprié de les utiliser - je ne suis pas un fan de la méta-programmation trop zélée. C'est aussi une bonne chance de voir si quelqu'un a utilisé Hibernate ou JUnit avec des annotations.

Voici quelques-uns que je viens de faire:

[[Génériques méfiants] Est-ce que décommenter l'une de ces lignes causerait des problèmes? Ceux qui, le cas échéant? Pourquoi ou pourquoi pas?

public class Cage<T> { ... }
public class Animal { ... }
public class Bear extends Animal { ... }
// Cage<Animal> c = new Cage<Bear>();
// Cage<Bear> c = new Cage<Animal>();
// Cage<?> c = new Cage<Animal>();
// Cage<Animal> c = new Cage<?>();

Only [Contraintes] Seul Animals devrait entrer dans Cages. Comment pouvons-nous resserrer les définitions de classe ci-dessus afin qu'elles reflètent cette nouvelle exigence?

[[Problèmes juridiques] Vous ne pouvez pas instancier un tableau de type générique. Ainsi, quelque chose comme new List<Animal>[10] est illégal. Pouvez-vous penser à un scénario où, si cela si vous aviez des problèmes?

Réponses laissées comme un exercice au lecteur you vous n'allez rien apprendre si vous ne les comprenez pas vous-même! Mais voici quelques conseils.

• [Génériques méfiants]: Que signifie ?? Vous souvenez-vous du terme "covariance"?
• [Contraintes]: Java vous permet de contraindre les valeurs d'un paramètre de type. Vous souvenez-vous de la syntaxe?
• [Problèmes juridiques]: Supposons que vous puissiez faire Object[] arr = new List<String>[]. Pouvez-vous écrire un code qui met quelque chose dans arr ' s Lists qui ne devrait pas y entrer?

" À quel type de choses les annotations sont-elles bonnes?"et" à quel type de choses les annotations sont-elles mauvaises?"vient à l'esprit.

Les annotations sont bonnes en méta-programmation, mais en tant que meilleure pratique possible, le code qui a fonctionnéavec les annotations devraient toujours fonctionner si vous les supprimez toutes.

Ou non. Votre kilométrage peut varier, mais vous voudrez probablement tous vos anciens développeurs d'accord sur cela.

Voici quelques génériques:

1)

Question: Si j'avais cette méthode, comment créerais-je une nouvelle instance de type T et l'assignerais-je à une variable appelée item dans cette méthode (supposons que Class<T> a un constructeur par défaut)?

public static <T> Collection<T> select(Class<T> c, String sqlStatement) {
}

Réponse:

T item = c.newInstance();

2)

Question: Si vous vouliez indiquer que le générique étend une classe de base, mais vous ne savez pas quelle est la classe qui étend la classe de base jusqu'à l'exécution, comment pouvez-vous déclarer le générique?

Réponse: Utilisez un caractère générique: <? extends SomeBaseClass>