Questions d'entretien de base Java (1)

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 ?

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个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!