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 ?

在語法定義上的區(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!