1. Un fichier source ".java" peut-il inclure plusieurs classes (pas de classes internes)?? Quelles sont les restrictions ?

Il peut y avoir plusieurs classes, mais il ne peut y avoir qu'une seule classe publique, et le nom de la classe publique doit être cohérent avec le nom du fichier.

(Recommandations pour plus de questions d'entretien?: questions et réponses d'entretien Java)

2.

Mots réservés en Java, actuellement non utilisés en Java.

3. Parlez de la différence entre & et &&.

Les deux & et && peuvent être utilisés comme opérateurs ET logiques, indiquant un ET logique (et). Lorsque les résultats des expressions des deux c?tés de l'opérateur sont vrais, le résultat de l'opération entière est vrai. Sinon, comme. tant que si l'une des parties est fausse, le résultat est faux.

&& a également pour fonction de court-circuiter, c'est-à-dire que si la première expression est fausse, la deuxième expression ne sera plus évaluée, par exemple pour if(str!= null&& !str.equals( s)) Expression, lorsque str est nulle, l'expression suivante ne sera pas exécutée, donc NullPointerException ne se produira pas si && est remplacé par &, NullPointerException sera levée. If(x==33 &++y>0) y grandira, If(x==33 && ++y>0) ne grandira pas

& peut également être utilisé comme opérateur de bit, lorsque & Lorsque les expressions des deux c?tés de l'opérateur ne sont pas de type booléen, & représente une opération AND au niveau du bit. Nous utilisons généralement 0x0f pour effectuer l'opération & avec un entier afin d'obtenir les 4 bits les plus bas de l'entier. de 0x31 & 0x0f est 0x01 .

4. Comment sortir des multiples boucles imbriquées actuelles en JAVA ?

En Java, si vous souhaitez sortir de plusieurs boucles, vous pouvez définir une étiquette avant l'instruction de boucle externe, puis utiliser l'instruction break avec l'étiquette dans le code du corps de la boucle interne pour sauter de la boucle extérieure.

Par exemple?:

for(int i=0;i<10;i++){
   for(intj=0;j<10;j++){
       System.out.println(“i=” + i + “,j=” + j);
       if(j == 5) break ok;
   }
}

De plus, personnellement, je n'utilise généralement pas d'étiquettes, mais je laisse le résultat de l'expression conditionnelle de la boucle externe être contr?lé par le code du corps de la boucle interne. Par exemple, vous voulez trouver un nombre dans un tableau à deux dimensions.

int arr[][] ={{1,2,3},{4,5,6,7},{9}};
boolean found = false;
for(int i=0;i<arr.length&&!found;i++)       {
        for(intj=0;j<arr[i].length;j++){
              System.out.println(“i=” + i + “,j=” + j);
              if(arr[i][j] ==5) {
                      found =true;
                      break;
              }
        }
}

(apprentissage recommandé?: Tutoriel d'introduction à Java)

5. L'instruction switch peut-elle agir sur l'octet, peut-elle agir sur long et peut-elle agir sur la cha?ne ci-dessus ? ?

Dans switch(e), e ne peut être qu'une expression entière ou une constante d'énumération (police plus grande). L'expression entière peut être le type de base int ou le type wrapper Integer Due to byte, short , char. peut être implicitement converti en int, donc ces types et types d'emballage de ces types sont également possibles. évidemment, ni les types long ni les types String ne sont conformes à la syntaxe de switch et ne peuvent pas être implicitement convertis en type int, ils ne peuvent donc pas être utilisés dans les instructions switch.

Je me trompe quant à savoir si l'instruction switch peut être utilisée sur String. Cette méthode d'écriture est déjà prise en charge après Java 1.7?!

6. short s1= 1; s1 = (s1+1 est de type int, et le c?té gauche du signe égal est de type court, il doit donc être forcé) 1 + 1?; s1 = 1; s1 += 1; Qu'est-ce qui ne va pas ? (Rien de mal)

En bref s1= 1; s1 = s1 + 1; Le résultat est de type int, puis attribué au type court s1, le compilateur signalera une erreur nécessitant un type de conversion.

En bref s1= 1; s1 += 1; puisque += est un opérateur spécifié par le langage Java, le compilateur Java effectuera un traitement spécial sur celui-ci, afin qu'il puisse être compilé correctement.

7. Un caractère chinois peut-il être stocké dans une variable char?? Pourquoi??

La variable char est utilisée pour stocker des caractères codés Unicode. , bien s?r, les caractères chinois peuvent être stockés dans des variables de type char. Toutefois, si un caractère chinois spécial n'est pas inclus dans le jeu de caractères de codage Unicode, le caractère chinois spécial ne peut pas être stocké dans cette variable char. Explication supplémentaire?: le codage Unicode occupe deux octets, donc les variables de type char occupent également deux octets.

8. Utiliser la méthode la plus efficace pour calculer ce qui fait 2 fois 8

2<< 3. (Décalage vers la gauche de trois places) Parce que décaler un nombre vers la gauche de n places ? , Cela équivaut à multiplier 2 à la nième puissance. Ensuite, pour multiplier un nombre par 8, il suffit de le décaler vers la gauche de 3 bits. Les opérations sur bits directement prises en charge par le CPU sont donc les plus efficaces. le nombre le plus efficace de 2 multiplié par 8?? La méthode est 2<<3.

9. Lorsque vous utilisez le mot-clé final pour modifier une variable, la référence ne peut-elle pas être modifiée ou l'objet référencé ne peut-il pas être modifié??

Lorsque vous utilisez le mot-clé final pour modifier une variable, cela signifie que la variable de référence ne peut pas être modifiée, mais que le contenu de l'objet pointé par la variable de référence peut toujours être modifié. Par exemple, pour l'instruction suivante?:

finalStringBuffer a=new StringBuffer("immutable");

L'exécution de l'instruction suivante signalera une erreur de compilation?:

a=new StringBuffer("");

Cependant, l'exécution de l'instruction suivante compilera?:

a.append(" broken!");

Lorsque quelqu'un définit les paramètres d'une méthode, il peut vouloir utiliser le formulaire suivant pour empêcher que l'objet paramètre transmis ne soit modifié à l'intérieur de la méthode?:

public void method(final  StringBuffer param){
}

En fait, ce n'est pas possible , et vous pouvez toujours ajouter plus de paramètres à l'intérieur de la méthode. Utilisez le code suivant pour modifier l'objet paramètre?:

param.append("a");

(Recommandation vidéo d'apprentissage?: cours java)

10. . Quelle est la différence entre les variables statiques et les variables d'instance ?

在語法定義上的區(qū)別：靜態(tài)變量前要加static關(guān)鍵字，而實例變量前則不加。

在程序運行時的區(qū)別：實例變量屬于某個對象的屬性，必須創(chuàng)建了實例對象，其中的實例變量才會被分配空間，才能使用這個實例變量。靜態(tài)變量不屬于某個實例對象，而是屬于類，所以也稱為類變量，只要程序加載了類的字節(jié)碼，不用創(chuàng)建任何實例對象，靜態(tài)變量就會被分配空間，靜態(tài)變量就可以被使用了?？傊?，實例變量必須創(chuàng)建對象后才可以通過這個對象來使用，靜態(tài)變量則可以直接使用類名來引用。

例如，對于下面的程序，無論創(chuàng)建多少個實例對象，永遠都只分配了一個staticVar變量，并且每創(chuàng)建一個實例對象，這個staticVar就會加1；但是，每創(chuàng)建一個實例對象，就會分配一個instanceVar，即可能分配多個instanceVar，并且每個instanceVar的值都只自加了1次。

public class VariantTest{
        publicstatic int staticVar = 0;
        publicint instanceVar = 0;
        publicVariantTest(){
              staticVar++;
              instanceVar++;
              System.out.println(staticVar +instanceVar);
        }
}

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!