Questions d'entretien Java de base (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. (Étude recommandée : questions d'entretien Java)

2. Java a-t-il goto ?

Un mot réservé en Java qui n'est pas actuellement en Java. utiliser.

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

& 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. , tant qu'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)), lorsque str est nul, 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 la boucle externe, puis utiliser l'instruction break avec l'étiquette dans le code du corps de la boucle interne pour sauter.

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 affecté par la boucle interne expression conditionnelle. Contrôle du code du corps de la boucle, par exemple, pour 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;
              }
        }
}

5. L'instruction switch peut-elle agir sur un octet, un long ou une chaîne ?

Dans switch ( In e), e ne peut être qu'un entier. expression ou constante d'énumération (police plus grande). L'expression entière peut être le type de base int ou le type d'empaquetage Integer puisque byte, short et char peuvent être implicitement convertis en int, donc, ces types et types wrapper de ces types sont également. possible.

É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. (Après java1.7, il peut déjà être utilisé sur le type String, ainsi que sur char byte short int et leurs classes d'empaquetage.)

6 short 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; Qu'est-ce qui ne va pas ?

Pour short s1= 1; s1 = s1 + 1 ; puisque le type d'expression sera automatiquement promu lors de l'opération s1+1, le résultat est de type int. Lors de l'attribution au type court s1, le compilateur signalera. que le type doit être une erreur de conversion.

En bref s1= 1; s1 += 1; puisque += est un opérateur spécifié par le langage Java, le compilateur Java le traitera spécialement, afin qu'il puisse être compilé correctement.

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

Les variables de type char sont utilisées pour stocker des caractères codés Unicode ? Le jeu de caractères d'encodage contient des caractères chinois, donc bien sûr, les caractères chinois peuvent être stockés dans des variables 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 la variable de type char occupe également deux octets.

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

2<< car décaler un nombre vers la gauche de n bits é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 sont directement supportées par le CPU. et sont les plus efficaces. Par conséquent, le moyen le plus efficace de découvrir ce qui fait 2 fois 8 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é ?

Lors de l'utilisation du 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!");

Quelqu'un définit une méthode Lors de la transmission de paramètres, vous souhaiterez peut-être utiliser le formulaire suivant pour empêcher la méthode de modifier l'objet paramètre transmis :

public void method(final  StringBuffer param){
}

En fait, ce n'est pas possible. Vous pouvez toujours ajouter le code suivant à l'intérieur. la méthode pour modifier l'objet paramètre. :

 param.append("a");

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!