Questions d'entretien Java de base (2)

11. Est-il possible d'émettre un appel à une méthode non statique à partir d'une méthode statique ?

Non. Étant donné que les méthodes non statiques sont associées à des objets, un objet doit être créé avant que les appels de méthode puissent être effectués sur l'objet. Lors de l'appel de méthodes statiques, il n'est pas nécessaire de créer un objet et peut être appelé directement. (Étude recommandée : questions d'entretien Java)

En d'autres termes, lorsqu'une méthode statique est appelée, aucun objet instance ne peut avoir été créé si une méthode non statique est issue d'une méthode statique. méthode, lors de l'appel d'une méthode, à quel objet la méthode non statique est-elle associée ? Cette logique ne peut pas être établie, donc une méthode statique émet en interne un appel à une méthode non statique.

12. La différence entre Integer et int

int est l'un des 8 types de données primitifs fournis par Java. Java fournit des classes wrapper pour chaque type primitif. Integer est la classe wrapper fournie par Java pour int. La valeur par défaut de int est 0, tandis que la valeur par défaut de Integer est nulle, c'est-à-dire qu'Integer peut distinguer la différence entre la valeur non attribuée et la valeur 0, tandis que int ne peut pas exprimer la situation de valeur non attribuée.

Par exemple : Si vous souhaitez exprimer la différence entre ne pas passer un examen et avoir une note d'examen de 0, vous ne pouvez utiliser qu'Integer. Dans le développement JSP, la valeur par défaut de Integer est nulle, donc lorsque l'expression el est utilisée pour l'afficher dans la zone de texte, la valeur est une chaîne vide et la valeur par défaut de int est 0, donc lorsque l'expression el est utilisée pour l'afficher dans la zone de texte, le résultat est 0, donc int ne convient pas comme type de données de formulaire de la couche Web.

Dans Hibernate, si OID est défini comme type Integer, alors Hibernate peut déterminer si un objet est temporaire en fonction du fait que sa valeur est nulle. Si OID est défini comme type int, il doit également être mappé dans hbm. Définissez son attribut de valeur non enregistrée dans le fichier sur 0.

De plus, Integer fournit plusieurs méthodes de fonctionnement liées aux entiers, telles que la conversion d'une chaîne en entier. Integer définit également des constantes qui représentent les valeurs maximales et minimales des entiers.

13. À quoi est égal Math.round(11.5) ? À quoi est égal Math.round(-11.5) ?

La classe Math fournit trois fonctions liées. aux méthodes d'arrondi : ceil, floor, round, les fonctions de ces méthodes correspondent à la signification de leurs noms anglais.

Par exemple, la signification anglaise de ceil est plafond, et cette méthode signifie arrondir au chiffre supérieur. Le résultat de Math.ceil(11.3) est 12 et le résultat de Math.ceil(-11.3) est -11. ;

La signification anglaise de floor est floor Cette méthode signifie arrondir à l'inférieur. Le résultat de Math.ceil(11.6) est 11, et le résultat de Math.ceil(-11.6) est

Le plus difficile à maîtriser est la méthode round, qui signifie « arrondir ». L'algorithme est Math.floor(x+0.5), ce qui signifie ajouter 0,5 au nombre d'origine puis l'arrondir à l'inférieur. le résultat de Math.round(11.5) est 12, le résultat de Math.round(-11.5) est -11.

14. Quelle est la différence entre surcharge et remplacement ? La méthode Overloaded peut-elle changer le type de valeur de retour ?

Overload signifie surcharge, et Override signifie écrasement, c'est-à-dire réécriture.

La surcharge signifie qu'il peut y avoir plusieurs méthodes portant le même nom dans la même classe, mais les listes de paramètres de ces méthodes sont différentes (c'est-à-dire que le nombre ou le type de paramètres sont différents).

Override signifie que la méthode de la sous-classe peut avoir le même nom et les mêmes paramètres qu'une méthode de la classe parent. Lorsque cette méthode est appelée via un objet instance créé par la sous-classe, la définition dans la sous-classe sera. appelée méthode, ce qui équivaut à écraser exactement la même méthode définie dans la classe parent. C'est également une manifestation du polymorphisme dans la programmation orientée objet.

Lorsqu'une sous-classe remplace la méthode de la classe parent, elle ne peut lever que moins d'exceptions que la classe parent, ou lever des sous-exceptions des exceptions levées par la classe parent, car la sous-classe peut résoudre certains des problèmes. Les problèmes de la classe parente ne peuvent pas avoir plus de problèmes que la classe parente.

Les droits d'accès des méthodes de sous-classe ne peuvent être que supérieurs à ceux de la classe parent, pas inférieurs. Si la méthode de la classe parent est de type privé, alors il n'y a aucune restriction primordiale dans la sous-classe, ce qui équivaut à ajouter une toute nouvelle méthode à la sous-classe.

Quant à la question de savoir si la méthode Overloaded peut changer le type de la valeur de retour, cela dépend de ce que vous voulez demander ?

Cette question est très vague. Si les listes de paramètres de plusieurs méthodes Overloaded sont différentes, leurs types de retour peuvent bien entendu également être différents.

Mais je suppose que la question que vous voulez poser est la suivante : si les listes de paramètres de deux méthodes sont exactement les mêmes, leurs valeurs de retour peuvent-elles être différentes pour implémenter la surcharge.

Ce n'est pas possible. Nous pouvons utiliser la preuve par contradiction pour illustrer ce problème, car parfois nous n'avons pas besoin de définir la variable de résultat de retour lors de l'appel d'une méthode, c'est-à-dire que nous ne nous soucions pas du résultat. résultat de retour.

Par exemple, lorsque nous appelons la méthode map.remove(key), bien que la méthode Remove ait une valeur de retour, nous ne définissons généralement pas de variable pour recevoir le résultat de retour. À ce stade, supposons qu'il y en ait. Il y a deux noms dans la classe et la liste des paramètres de la méthode est exactement la même, mais le type de retour est différent. Java ne peut pas déterminer quelle méthode le programmeur souhaite appeler, car il ne peut pas juger par le type de résultat renvoyé.

Override peut être traduit par couverture. Au sens littéral, il couvre une méthode et la réécrit pour réaliser différentes fonctions.

La couverture la plus familière pour nous est l'implémentation des méthodes d'interface. Généralement, seules les méthodes sont déclarées dans l'interface, et lorsque nous l'implémentons, nous devons implémenter toutes les méthodes déclarées par l'interface. En plus de cette utilisation typique, nous pouvons également remplacer les méthodes de la classe parent dans la sous-classe lors de l'héritage. Faites attention aux points suivants lors du traitement :

1. Le drapeau de la méthode remplacée doit correspondre complètement au drapeau de la méthode remplacée pour obtenir l'effet d'écrasement

2. la méthode doit être cohérente avec la valeur de retour de la méthode surchargée ;

3. L'exception levée par la méthode surchargée doit être cohérente avec l'exception levée par la méthode surchargée, ou en être une sous-classe ; >

4. La méthode substituée ne peut pas être privée, sinon une nouvelle méthode sera définie dans sa sous-classe sans la substituer.

La surcharge nous est peut-être familière et peut être traduite par surcharge. Cela signifie que nous pouvons définir certaines méthodes avec le même nom, distinguer ces méthodes en définissant différents paramètres d'entrée, puis appeler la VM. La méthode appropriée le fera. être sélectionné pour l’exécution en fonction de différents styles de paramètres. Lorsque vous utilisez la surcharge, veuillez faire attention aux points suivants :

1 Lorsque vous utilisez la surcharge, vous ne pouvez utiliser que des styles de paramètres différents. Par exemple, différents types de paramètres, un nombre différent de paramètres, un ordre différent des paramètres (bien sûr, plusieurs types de paramètres dans la même méthode doivent être différents, par exemple, cela peut être fun(int, float), mais cela ne peut pas être fun(int , int ));

2. La surcharge ne peut pas être effectuée par les autorisations d'accès, les types de retour et les exceptions levées

3. Le type d'exception et le nombre de méthodes n'affecteront pas la surcharge ; >

4. Pour l'héritage, si une méthode a un accès privilégié dans la classe parent, elle ne peut pas être surchargée dans la sous-classe. Si elle est définie, elle définira uniquement une nouvelle méthode. Elle n'obtiendra pas l'effet de surcharge.

15. Les interfaces peuvent-elles hériter d'interfaces ? Les classes abstraites peuvent-elles implémenter des interfaces ? Les classes abstraites peuvent-elles hériter de classes concrètes ?

Les interfaces peuvent hériter des interfaces. Les classes abstraites peuvent implémenter des interfaces et les classes abstraites peuvent hériter de classes concrètes. Les classes abstraites peuvent avoir des méthodes principales statiques.

Remarque : tant que vous comprenez la nature et le rôle des interfaces et des classes abstraites, il est facile de répondre à ces questions. Pensez-y, si vous étiez un concepteur du langage Java, fourniriez-vous un tel support ? Si non Si oui, y a-t-il une raison ? Si vous n’avez aucune raison de ne pas le fournir, la réponse est oui.

N'oubliez pas que la seule différence entre les classes abstraites et les classes ordinaires est que les objets d'instance ne peuvent pas être créés et que les méthodes abstraites sont autorisées.

16. Quel est le mécanisme pour implémenter le polymorphisme en Java ?

S'appuyer sur la variable de référence définie par la classe ou l'interface parent peut pointer vers l'objet instance de la sous-classe ou de la classe d'implémentation spécifique, et la méthode appelée par le programme est liée dynamiquement au moment de l'exécution, ce qui est la variable de référence pointée vers La méthode de l'objet d'instance spécifique est la méthode de l'objet exécuté dans la mémoire, plutôt que la méthode définie dans le type de la variable de référence.

17. Quelle est la différence de syntaxe entre la classe abstraite et l'interface ?

1. Les classes abstraites peuvent avoir des constructeurs, mais les interfaces ne peuvent pas avoir de constructeurs.

2. Il peut y avoir des variables membres ordinaires dans les classes abstraites, mais il n'y a pas de variables membres ordinaires dans les interfaces

3 Les classes abstraites peuvent contenir des méthodes ordinaires non abstraites, et toutes les méthodes dans les interfaces. Doit être Il est abstrait et ne peut pas avoir de méthodes ordinaires non abstraites.

4. Les types d'accès aux méthodes abstraites dans les classes abstraites peuvent être publics, protégés et (type par défaut, bien qu'aucune erreur ne soit signalée sous Eclipse, mais cela ne devrait pas fonctionner), mais les méthodes abstraites dans les interfaces ne peuvent que être des types publics, et la valeur par défaut est le type abstrait public.

5. Les classes abstraites peuvent contenir des méthodes statiques, les interfaces ne peuvent pas contenir de méthodes statiques

6. Les classes abstraites et les interfaces peuvent contenir des variables membres statiques, et les variables membres statiques dans les classes abstraites sont le type d'accès. peut être arbitraire, mais les variables définies dans l'interface ne peuvent être que de type publicstatic final, et la valeur par défaut est de type publicstatic final.

7. Une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d'une seule classe abstraite.

18. La méthode abstraite peut-elle être statique, native et synchronisée en même temps ?

La méthode abstraite ne peut pas être statique car les méthodes abstraites doivent être implémentées par. les sous-classes, et static n'a rien à voir avec les sous-classes !

La méthode native signifie que la méthode doit être implémentée dans un autre langage de programmation dépendant de la plate-forme. Il n'y a aucun problème d'implémentation par une sous-classe, elle ne peut donc pas être abstraite et ne peut pas être mélangée avec de l'abstrait.

Par exemple, la classe FileOutputSteam doit gérer le matériel, et l'implémentation sous-jacente utilise l'implémentation de l'API liée au système d'exploitation ; par exemple, elle est implémentée en langage C dans Windows, donc si vous regardez la source ; code de jdk, vous pouvez retrouver l'open de FileOutputStream La méthode est définie comme suit :

private native void open(Stringname) throwsFileNotFoundException;

Si nous voulons utiliser Java pour appeler une fonction en langage C écrite par d'autres, nous ne pouvons pas l'appeler directement. Nous devons écrire une fonction en langage C selon les exigences de Java, puis notre fonction en langage C appelle celle de quelqu'un d'autre. Fonction langage C.

Étant donné que notre fonction en langage C est écrite selon les exigences de Java, notre fonction en langage C peut être connectée à Java. La méthode d'accueil côté Java consiste à définir la méthode correspondante à notre fonction C, la méthode correspondante. La méthode en Java n'a pas besoin d'écrire du code spécifique, mais elle doit être déclarée native au préalable.

Concernant le problème de l'utilisation conjointe de synchronisé et abstrait, je ne pense pas que ce soit correct, car au cours de mes plusieurs années d'étude et de développement, je n'ai jamais vu cette situation, et je pense que synchronisé devrait être utilisé dans un spécifique Cela n’a de sens qu’en termes de méthode.

De plus, l'objet de verrouillage de synchronisation utilisé par la synchronisation synchronisée sur la méthode est celui-ci, et il est impossible de déterminer de quoi il s'agit sur la méthode abstraite.

19. Une classe interne peut-elle faire référence aux membres de sa classe conteneur ? Y a-t-il des restrictions ?

Absolument. Si ce n’est pas une classe interne statique, il n’y a pas de limite !

Si vous traitez une classe imbriquée statique comme un cas particulier d'une classe interne, alors dans ce cas, vous ne pouvez pas accéder aux variables membres ordinaires de la classe externe, mais vous ne pouvez accéder qu'aux membres statiques de la classe externe. , par exemple, le code suivant :

class Outer
{
    static int x;
    static class Inner
    {
        voidtest(){
          syso(x);
        }
    }
}

20. String s = "Hello"; s = s + "world!"; L'objet chaîne a changé.

Non. Étant donné que String est conçu pour être une classe immuable, tous ses objets sont des objets immuables.

Dans ce code, s pointait à l'origine un objet String avec le contenu "Bonjour", puis nous avons effectué une opération + sur s L'objet pointé par s a-t-il changé ? La réponse est non.

A ce moment, s ne pointe plus vers l'objet d'origine, mais vers un autre objet String avec le contenu "Hello world!". L'objet d'origine existe toujours en mémoire, mais la variable de référence s n'existe plus. .Montrez-le.

Grâce à l'explication ci-dessus, nous pouvons facilement tirer une autre conclusion. Si les chaînes sont souvent modifiées de diverses manières, ou des modifications imprévues, alors utiliser String pour représenter des chaînes entraînera une surcharge de mémoire importante.

Étant donné que l'objet String ne peut pas être modifié après sa création, un objet String est nécessaire pour représenter chaque chaîne différente. À ce stade, vous devriez envisager d'utiliser la classe StringBuffer, qui permet la modification, plutôt que de générer un nouvel objet pour chaque chaîne différente. De plus, il est très simple de convertir ces deux types d’objets.

En même temps, on peut aussi savoir que si vous souhaitez utiliser une chaîne avec le même contenu, vous n'êtes pas obligé de créer une nouvelle chaîne à chaque fois. Par exemple, si nous voulons initialiser une variable de référence String nommée s dans le constructeur et la définir comme valeur initiale, nous devrions faire ceci :

public class Demo {
    private String s;
    ...
public Demo {
    s = "Initial Value";
    }
    ...
}

au lieu de

s = new String("Initial Value");

Ce dernier appellera le constructeur à chaque fois pour générer un nouvel objet, qui a de faibles performances et une surcharge de mémoire élevée, et n'a aucun sens car l'objet String ne peut pas être modifié, donc pour les chaînes avec le même contenu, un seul objet String est nécessaire pour les représenter.

En d'autres termes, si vous appelez le constructeur ci-dessus plusieurs fois pour créer plusieurs objets, leurs attributs de type String pointent tous vers le même objet.

La conclusion ci-dessus est également basée sur le fait que pour les constantes chaîne, si le contenu est le même, Java les considère comme représentant le même objet String. L'appel du constructeur avec le mot-clé new créera toujours un nouvel objet, que le contenu soit ou non le même.

Quant à la raison pour laquelle la classe String doit être conçue comme une classe immuable, elle est déterminée par son objectif. En fait, non seulement String, mais aussi de nombreuses classes de la bibliothèque de classes standard Java sont immuables.

Lors du développement d'un système, nous devons parfois concevoir des classes immuables pour transmettre un ensemble de valeurs liées, ce qui est également une manifestation de la pensée orientée objet.

Les classes immuables présentent certains avantages. Par exemple, comme ses objets sont en lecture seule, il n'y aura aucun problème d'accès simultané par plusieurs threads. Bien entendu, il existe également certains inconvénients. Par exemple, chaque état différent a besoin d’un objet pour le représenter, ce qui peut entraîner des problèmes de performances. Par conséquent, la bibliothèque de classes standard Java fournit également une version variable, StringBuffer.

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!