Résumé des questions d'entretien Java souvent oubliées

Classes statiques et méthodes statiques

Si une classe doit être déclarée comme statique, il n'y a qu'un seul cas, qui est une classe interne statique.

Les classes internes statiques sont en fait les mêmes que les classes ordinaires (c'est-à-dire les classes de niveau supérieur dont les noms de classe doivent être les mêmes que les noms de fichiers), sauf que les classes internes statiques sont définies dans une certaine classe depuis. ce sont des classes, si vous souhaitez les utiliser, elles doivent être instanciées. Conceptuellement, elles sont différentes des variables statiques et des méthodes statiques. Ne vous laissez pas confondre par le mot « statique » (ne pensez pas que toutes les choses statiques peuvent être utilisées directement sans instanciation. Les classes internes statiques sont là. il y a une différence), et il n'y a que des classes internes statiques, mais il n'y a pas de concept de classes statiques (classes de niveau supérieur).

par exemple

public class Singleton{
    private Singleton(){}

    private static class SingletonHolder{
        private final static Singleton instance;
    }

    public Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

Les méthodes statiques ne peuvent accéder qu'aux membres statiques, et les méthodes d'instance peuvent accéder à la fois aux membres statiques et aux membres d'instance. La raison pour laquelle les méthodes statiques ne sont pas autorisées à accéder aux variables membres d'instance est que les variables membres d'instance appartiennent à un certain objet , et l'objet n'existe pas nécessairement lorsqu'une méthode statique est exécutée. Le mot clé this ne peut pas être utilisé dans les méthodes statiques.

Index inversé

Index inversé

Il peut être plus facile à comprendre s'il est traduit en index transposé, ce qui équivaut à faire une transposition matricielle.

L'index inversé est une méthode d'indexation utilisée pour stocker un mappage de l'emplacement de stockage d'un mot dans un document ou un groupe de documents sous recherche en texte intégral.

Reflection

ReflectionLe proxy dynamique fourni dans l'API est également une fonction très puissante et peut implémenter nativement la fonction d'interception de méthode dans AOP. Tout comme la signification du mot anglais réflexion, utiliser l'API de réflexion revient à regarder le reflet d'une classe Java dans l'eau. Après avoir connu la structure interne d'une classe Java, vous pouvez interagir avec elle, notamment en créant de nouveaux objets et en appelant des méthodes dans les objets.

Cette méthode d'interaction a le même effet que son utilisation directement dans le code source, mais elle offre une flexibilité d'exécution supplémentaire. L’un des plus gros inconvénients de l’utilisation de la réflexion est la mauvaise performance. Pour la même opération, le temps requis pour utiliser l’API de réflexion est probablement un ou deux ordres de grandeur plus lent que pour son utilisation directe. Cependant, dans l'implémentation actuelle de la JVM, les performances des opérations de réflexion ont été considérablement améliorées.

La première fonction principale de l'API de réflexion Java est d'obtenir la structure interne du programme au moment de l'exécution.

Algorithme de fusion multidirectionnel

Le tri par fusion est également un algorithme de tri efficace mis en œuvre à l'aide de la méthode diviser pour régner. Il a été inventé par John von Neumann, le fondateur des ordinateurs modernes, en. 1945.

Le tri par fusion est à la fois un tri stable et très efficace parmi de nombreux algorithmes de tri. En même temps, le tri par fusion peut être utilisé non seulement pour le tri interne, mais également pour le tri externe.

L'idée du tri par fusion est la suivante (en prenant comme exemple la fusion bidirectionnelle) :

• Divisez le tableau en deux sous-tableaux ; >

• Triez les deux tableaux de mots ;

• Fusionnez les deux tableaux de mots triés.

La fusion dite N-way consiste à diviser le tableau en N sous-tableaux, à trier le

tableau puis à le fusionner. Par conséquent, la fusion bidirectionnelle est le cas le plus général de tri par fusion.

par exemple

Légende

def msort(array):
    length = len(array)
    if length == 1:
        return array
    else:
        mid = length / 2
        left = msort(array[0: mid])
        right = msort(array[mid: length])
        return merge(left, right)

Non récursif

def msort(array):
    length = len(array)
    step = 1
    while step < length:
        for left in range(0, length - step, 2 * step):
            result = merge(array[left:left + step],
                           array[left + step: min(left + 2 * step,
             length)])
            array = array[0:left] + result + array[min(left + 2 *
                                                       
           step, length)]
        step = step * 2
    return array

def merge(left, right):
    llen = len(left)
    lcur = 0
    rlen = len(right)
    rcur = 0
    result = []
    while lcur < llen and rcur < rlen:
        lone = left[lcur]
        rone = right[rcur]
        result.append(min(lone, rone))
        if lone < rone:
            lcur += 1
        else:
            rcur += 1
    result += left[lcur:]
    result += right[rcur:]
    return result

Type d'énumération

Type énuméré

• le type enum ne prend pas en charge le

  constructeur des modificateurs publics et protégés, donc le constructeur doit être privé ou amical. De ce fait, l'objet énumération ne peut pas être initialisé dans le programme en appelant directement son constructeur.

• Étant donné que la valeur du type enum est en fait représentée par un objet construit pendant l'exécution, dans l'environnement de cluster, chaque machine virtuelle construira également un objet d'énumération. Par conséquent, vous devez faire attention lorsque vous effectuez des opérations de comparaison. Si vous utilisez directement l'opérateur de signe égal (« == »), ces valeurs d'énumération apparemment identiques ne doivent pas être égales, car ce ne sont pas la même instance d'objet.

Multi-threading

Il existe deux façons d'implémenter le multi-threading en Java : hériter de la classe Thread et implémenter l'interface Runnable. Tant qu'elle est multi-threading. threadé dans le développement du programme, il implémentera toujours principalement l'interface Runnable, car l'implémentation de l'interface Runnable présente les avantages suivants par rapport à l'héritage de la classe Thread :

1. fonctionnalité d'héritage unique de Java ;

2. Améliore la robustesse du programme, le code peut être partagé par plusieurs threads, et le code et les données sont indépendants

3. plusieurs zones de thread du même code de programme traitent la même ressource.

Ce qui suit est un programme multithread implémenté en implémentant l'interface Runnable. Le code est le suivant :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!