Collection de questions d'entretien Java classiques (2)

1. La différence entre int et Integer

(Tutoriels associés recommandés : questions d'entretien Java )

1. Integer est une classe wrapper de int, qui est un type de données de base de Java

2. Les variables Integer doivent être instanciées avant de pouvoir être utilisées, alors que les variables int n'ont pas besoin de le faire

3 , Integer est en fait une référence à un objet. Lorsqu'un nouvel Integer est créé, un pointeur est en fait généré pointant vers l'objet ; tandis que int stocke directement la valeur des données

4. L'entier est nul et la valeur par défaut de int est La valeur est 0

2. Qu'est-ce qu'une boucle for each ? Sur quels types de données peut-elle être parcourue ?

La version améliorée de la boucle for est plus simple à écrire et moins sujette aux erreurs (car vous n'avez pas à vous soucier que le tableau sorte des limites). La couche inférieure est également obtenue en utilisant). un itérateur, mais l'itérateur est obtenu par jvm. Nous n'avons besoin que d'obtenir l'itérateur, donc lors de l'utilisation de l'élément variable de boucle foreach, nous ne sommes pas autorisés à utiliser l'objet collection pour modifier le nombre d'éléments dans la collection. .

Écriture :

for(String it : set){
    System.out.println("集合的元素：" + it);
}

Inconvénients :

Lors de l'opération sur l'index du tableau ou de l'ajout ou de la suppression de la collection, une erreur peut être signalée.

(Apprentissage recommandé : Programme d'introduction à Java)

3.Quelle est la différence entre la surcharge et la réécriture ?

1. La surcharge de méthodes

est un moyen pour les classes de traiter différents types de données de manière unifiée. Plusieurs fonctions portant le même nom existent en même temps, avec un nombre/type de paramètres différent. La surcharge est une manifestation du polymorphisme dans une classe.

La surcharge de méthodes en Java signifie que vous pouvez créer plusieurs méthodes dans une classe. Elles ont le même nom mais des paramètres et des définitions différents.

Lors de l'appel de méthodes, le nombre spécifique et le type de paramètres qui leur sont transmis déterminent la méthode à utiliser.

En cas de surcharge, le nom de la méthode doit être le même, mais le type et le numéro du paramètre sont différents, et le type de valeur de retour peut être identique ou différent. Le type de valeur de retour ne peut pas être utilisé comme critère pour distinguer les fonctions surchargées.

2. Remplacement de méthode

La liste des paramètres doit être exactement la même que la méthode remplacée, sinon elle ne peut pas être appelée réécriture mais surcharge.

Le type renvoyé doit toujours être le même que le type de retour de la méthode surchargée, sinon il ne peut pas être appelé un remplacement mais une surcharge.

La restriction du modificateur d'accès doit être supérieure au modificateur d'accès de la méthode remplacée (public>protected>default>private)

La méthode remplacée ne doit pas lever de nouvelle exception vérifiée ni être supérieure à La méthode remplacée déclare une exception vérifiée plus large. Par exemple : une méthode de la classe parent déclare une exception vérifiée IOException. Lors de la substitution de cette méthode, vous ne pouvez pas lancer d'exception. Vous ne pouvez lancer que des exceptions de sous-classes de IOException, et vous pouvez lancer des exceptions non vérifiées.

Remarque : les constructeurs ne peuvent pas être hérités et ne peuvent donc pas être remplacés, mais ils peuvent être surchargés.

4. Quelle est la différence entre l'interface et la classe abstraite ?

1. Ni les classes abstraites ni les interfaces ne peuvent être instanciées directement. Si elles doivent être instanciées, les variables de classe abstraite doivent pointer vers des objets de sous-classe qui implémentent toutes les méthodes abstraites, et les variables d'interface doivent pointer vers des classes qui. implémenter toutes les méthodes d'interface.

2. Les classes abstraites doivent être héritées par les sous-classes et les interfaces doivent être implémentées par les classes.

3. Les interfaces ne peuvent être utilisées que pour les déclarations de méthodes. Les classes abstraites peuvent être utilisées pour les déclarations de méthodes et les implémentations de méthodes.

4. Les variables définies dans les interfaces ne peuvent être que des constantes statiques publiques. les classes abstraites sont des variables ordinaires.

5. Toutes les méthodes abstraites d'une classe abstraite doivent être implémentées par la sous-classe. Si la sous-classe ne peut pas implémenter toutes les méthodes abstraites de la classe parent, alors la sous-classe ne peut être qu'une classe abstraite. De même, lorsqu'une classe implémente une interface, si elle ne peut pas implémenter toutes les méthodes d'interface, alors la classe ne peut être qu'une classe abstraite.

6. Les méthodes abstraites ne peuvent être déclarées, pas implémentées. Les interfaces sont le résultat de la conception, et les classes abstraites sont le résultat de la reconstruction

7. classes abstraites

8. S'il y a une méthode abstraite dans une classe, alors la classe ne peut être qu'une classe abstraite

9. La méthode abstraite doit être implémentée, elle ne peut donc pas être statique ou. privé.

10. Les interfaces peuvent hériter d'interfaces et peuvent hériter de plusieurs interfaces, mais les classes ne peuvent hériter que d'une seule racine.

La principale raison pour laquelle l'héritage multiple de classes n'est pas autorisé est que si A hérite de B et C en même temps, et que b et c ont une méthode D en même temps, comment A décide-t-il laquelle choisir ? hériter?

Mais il n'y a pas de problème avec les interfaces. Les interfaces sont toutes des méthodes abstraites et peu importe qui en hérite, les interfaces peuvent donc hériter de plusieurs interfaces.

(Tutoriel vidéo recommandé : tutoriel vidéo Java )

5. La différence entre final, enfin, finaliser

final. : Mots-clés et modificateurs en Java.

A). Si une classe est déclarée finale, cela signifie qu'elle ne peut pas dériver de nouvelles sous-classes et ne peut pas être héritée en tant que classe parent. Par conséquent, une classe ne peut pas être déclarée abstraite et finale à la fois.

B). Si vous déclarez des variables ou des méthodes comme finales, vous pouvez vous assurer qu'elles ne seront pas modifiées pendant l'utilisation.

（1）被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。

（2）被声明final的方法只能使用，不能重载。

finally：java的一种异常处理机制。

finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生。使用finally可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

finalize，它是一个方法，属于java.lang.Object类，它的定义如下：

protected void finalize()throws Throwable{}

众所周知，finalize()方法是GC（garbagecollector运行机制的一部分,在此我们只说说finalize()方法的作用是什么呢？

finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常（uncaughtexception，GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。

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!