Les types de données en Java peuvent être divisés en deux catégories :
Types de données de base, également appelés types de données primitifs.
Pour comparer byte, short, char, int, long, float, double, boolean, utilisez le double signe égal (==) et comparez leurs valeurs.
Type de référence (classe, interface, tableau)
Lorsqu'ils comparent en utilisant (==), ils comparent leurs adresses de stockage en mémoire. Par conséquent, à moins qu'il ne s'agisse du même nouvel objet, le résultat de leur comparaison est vrai, sinon le résultat de la comparaison est faux. Les objets sont placés sur le tas et la référence (adresse) de l'objet est stockée sur la pile. Regardez d'abord la carte mémoire et le code de la machine virtuelle :
public class testDay {
public static void main(String[] args) {
String s1 = new String("11");
String s2 = new String("11");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
Copier après la connexion
Le résultat est :
false true
s1 et s2 stockent respectivement les adresses des objets correspondants. Par conséquent, si s1== s2 est utilisé, les valeurs d'adresse des deux objets sont comparées (c'est-à-dire si les références sont les mêmes), ce qui est faux. Lors de l'appel dans le sens égal, la valeur dans l'adresse correspondante est comparée, la valeur est donc vraie. Ici, nous devons décrire equals() en détail.
2. Explication détaillée de la méthode equals()
La méthode equals() est utilisée pour déterminer si d'autres objets sont égaux à cet objet. Il est défini dans Object, donc tout objet a la méthode equals(). La différence est de savoir si la méthode est remplacée ou non.
Regardez d'abord le code source :
public boolean equals(Object obj) { return (this == obj);
}
Copier après la connexion
Évidemment, Object définit une comparaison des valeurs d'adresse de deux objets (c'est-à-dire comparer si les références sont les mêmes). Mais pourquoi l'appel d'equals() dans String ne compare-t-il pas l'adresse mais la valeur dans l'adresse de la mémoire tas ? Voici le point clé. Lorsque des classes d'encapsulation telles que String, Math, Integer, Double, etc. utilisent la méthode Equals(), elles ont déjà couvert la méthode Equals() de la classe d'objet. Jetez un œil à la fonction equals() réécrite dans String :
public boolean equals(Object anObject) { if (this == anObject) { return true;
} if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length; if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false;
i++;
} return true;
}
} return false;
}
Copier après la connexion
Après la réécriture, il s'agit de la comparaison de contenu, et ce n'est plus la comparaison d'adresse précédente. Par analogie, les classes telles que Math, Integer, Double, etc. remplacent toutes la méthode equals() pour comparer les contenus. Bien entendu, les types de base effectuent des comparaisons de valeurs.
Il convient de noter que lorsque la méthode equals() est remplacée, hashCode() sera également remplacée. Selon l'implémentation de la méthode générale hashCode(), les objets égaux doivent avoir des codes de hachage égaux. Pourquoi en est-il ainsi ? Nous mentionnons ici brièvement le hashcode.
3. Une brève discussion sur hashcode()
Il s'agit évidemment de la différence entre ==, égal et hashCode en Java, mais pourquoi est-il soudainement lié à hashcode(). Vous devez être très déprimé, d'accord, laissez-moi vous donner un exemple simple et vous saurez pourquoi hashCode est impliqué lorsque == ou égal.
Par exemple : Si vous souhaitez savoir si une collection contient un objet, comment devez-vous écrire le programme ? Si vous n'utilisez pas la méthode indexOf, parcourez simplement la collection et comparez si vous y pensez. Et s’il y avait 10 000 éléments dans la collection, ce serait fatiguant, non ? Par conséquent, afin d’améliorer l’efficacité, un algorithme de hachage a été créé. L'idée principale est de diviser la collection en plusieurs zones de stockage (peuvent être considérées comme des compartiments). Chaque objet peut calculer un code de hachage et peut être regroupé en fonction du code de hachage. un objet peut être regroupé selon le hash code. Son hash code peut être divisé en différentes zones de stockage (différentes zones).
Ainsi, lors de la comparaison d'éléments, le hashcode est en fait comparé en premier s'ils sont égaux, la méthode égale est comparée.
Regardez le diagramme du hashcode :
Un objet a généralement une clé et une valeur, et sa valeur hashCode peut être calculée en fonction de la clé, il est ensuite stocké dans différentes zones de stockage en fonction de sa valeur hashCode, comme indiqué ci-dessus. Différentes zones peuvent stocker plusieurs valeurs car des conflits de hachage sont impliqués. Simple : si le hashCode de deux objets différents est le même, ce phénomène est appelé conflit de hachage. En termes simples, cela signifie que le hashCode est le même mais que l'égalité est une valeur différente. Pour comparer 10 000 éléments, il n'est pas nécessaire de parcourir toute la collection. Il suffit de calculer le hashCode de la clé de l'objet que vous souhaitez rechercher, puis de trouver la zone de stockage correspondant au hashCode. La recherche est terminée.
Fu f1=new Zi();
Fu f2=new Son();if(f1 instanceof Zi){
System.out.println("f1是Zi的类型");
}else{
System.out.println("f1是Son的类型");
}
Copier après la connexion
4.多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型）父类类型的变量；
适用场景：当要使用子类特有功能时。
5.多态案例：
例1：
package day0524;
public class demo04 {
public static void main(String[] args) {
People p=new Stu();
p.eat();
//调用特有的方法
Stu s=(Stu)p;
s.study();
//((Stu) p).study();
}
}
class People{
public void eat(){
System.out.println("吃饭");
}
}
class Stu extends People{
@Override
public void eat(){
System.out.println("吃水煮肉片");
}
public void study(){
System.out.println("好好学习");
}
}
class Teachers extends People{
@Override
public void eat(){
System.out.println("吃樱桃");
}
public void teach(){
System.out.println("认真授课");
}
}
Copier après la connexion
答案：吃水煮肉片
好好学习
例2：
请问题目运行结果是什么？
package day0524;
public class demo1 {
public static void main(String[] args) {
A a=new A();
a.show();
B b=new B();
b.show();
}
}
class A{
public void show(){
show2();
}
public void show2(){
System.out.println("A");
}
}
class B extends A{
public void show2(){
System.out.println("B");
}
}
class C extends B{
public void show(){
super.show();
}
public void show2(){
System.out.println("C");
}
}
Copier après la connexion
答案：A B
5. String、StringBuffer和StringBuilder区别
1、长度是否可变
String 是被 final 修饰的，他的长度是不可变的，就算调用 String 的concat 方法，那也是把字符串拼接起来并重新创建一个对象，把拼接后的 String 的值赋给新创建的对象
7. La différence entre les classes abstraites et les interfaces
Les classes abstraites doivent être héritées par les sous-classes, et les interfaces doivent être implémentées par les classes.
Les interfaces ne peuvent faire que des déclarations de méthodes, tandis que les classes abstraites peuvent faire des déclarations de méthodes et des implémentations de méthodes.
Les variables définies dans l'interface ne peuvent être que des constantes statiques publiques, et les variables des classes abstraites sont des variables ordinaires.
L'interface est le résultat de la conception, et la classe abstraite est le résultat d'une refactorisation.
Les classes abstraites et les interfaces sont utilisées pour abstraire des objets spécifiques, mais les interfaces ont le plus haut niveau d'abstraction.
Les classes abstraites peuvent avoir des méthodes et des propriétés spécifiques, tandis que les interfaces ne peuvent avoir que des méthodes abstraites et des constantes immuables.
Les classes abstraites sont principalement utilisées pour abstraire des catégories, et les interfaces sont principalement utilisées pour abstraire des fonctions.
8. La signification de la classe abstraite
Classe abstraite :
Si une classe contient des méthodes abstraites, la classe doit être déclarée comme classe abstraite à l'aide du mot-clé abstract.
Signification :
Fournit un type public pour les sous-classes
encapsule le contenu répété (variables membres et méthodes) dans les sous-classes ;
définit une méthode abstraite. Bien que les sous-classes aient des implémentations différentes, la définition de cette méthode est cohérente.
9. Scénarios d'application des classes abstraites et des interfaces
1. Scénarios d'application des interfaces :
Il existe des exigences spécifiques entre les interfaces de classes, quelle que soit l'interface des classes. comment il est mis en œuvre.
existe comme un identifiant qui peut implémenter une fonction spécifique, ou il peut s'agir d'un pur identifiant sans aucune méthode d'interface.
Il est nécessaire de traiter un groupe de classes comme une seule classe, et l'appelant ne contacte ce groupe de classes que via l'interface.
Plusieurs fonctions spécifiques doivent être implémentées, et ces fonctions peuvent n'avoir aucun lien.
2. Occasions d'application de la classe abstraite (abstract.class) :
En un mot, lorsqu'à la fois une interface unifiée et des variables d'instance ou des méthodes par défaut sont nécessaires, vous pouvez l'utiliser . Les plus courants sont :
définit un ensemble d'interfaces, mais ne veut pas forcer chaque classe d'implémentation à implémenter toutes les interfaces. Vous pouvez utiliser abstract.class pour définir un ensemble de corps de méthode, ou même des corps de méthode vides, puis la sous-classe peut choisir les méthodes qu'elle souhaite couvrir.
Dans certains cas, les interfaces pures ne peuvent à elles seules satisfaire la coordination entre les classes. Les variables représentant les états de la classe doivent également être utilisées pour distinguer différentes relations. Le rôle intermédiaire de l’abstrait peut très bien y répondre.
spécifie un ensemble de méthodes mutuellement coordonnées, dont certaines sont communes, indépendantes de l'état et peuvent être partagées sans qu'il soit nécessaire que des sous-classes les implémentent séparément, tandis que d'autres méthodes nécessitent que chaque sous-classe l'implémente en fonction de ses caractéristiques ; propre état spécifique pour implémenter des fonctions spécifiques
10. Une classe abstraite peut-elle n'avoir ni méthodes ni attributs ?
La réponse est : Oui
Il ne peut y avoir de méthodes abstraites dans les classes abstraites, mais celles qui ont des méthodes abstraites doivent être des classes abstraites. Par conséquent, il ne peut y avoir de méthodes abstraites dans les classes abstraites en Java. Notez que même les classes abstraites sans méthodes et propriétés abstraites ne peuvent pas être instanciées.
11. 接口的意义
定义接口的重要性：在Java编程，abstract class 和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才使得Java成为面向对象的编程语言。
public class Food {}
public class Fruit extends Food {}
public class Apple extends Fruit {}
public class Banana extends Fruit{}
public class GenericTest {
public void testExtends(List extends Fruit> list){
//报错,extends为上界通配符,只能取值,不能放.
//因为Fruit的子类不只有Apple还有Banana,这里不能确定具体的泛型到底是Apple还是Banana，所以放入任何一种类型都会报错
//list.add(new Apple());
//可以正常获取
Fruit fruit = list.get(1);
}
public void testSuper(List super Fruit> list){
//super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
//无法确定Fruit的父类是否只有Food一个(Object是超级父类)
//因此放入Food的实例编译不通过
list.add(new Apple());
// list.add(new Food());
Object object = list.get(1);
}
}
class Fruit{
static String color = "五颜六色";
static public void call() {
System.out.println("这是一个水果");
}
}
public class Banana extends Fruit{
static String color = "黄色";
static public void call() {
System.out.println("这是一个香蕉");
}
public static void main(String[] args) {
Fruit fruit = new Banana();
System.out.println(fruit.color); //五颜六色
fruit.call(); //这是一个水果
}
}
14. La différence entre les threads et les processus
Définition : Un processus est une activité en cours d'exécution d'un programme sur une certaine collection de données ; un thread est un chemin d'exécution dans un processus. (Un processus peut créer plusieurs threads)
Aspect du rôle : dans un système qui prend en charge le mécanisme des threads, le processus est l'unité d'allocation des ressources système et le thread est l'unité de planification du processeur.
Partage des ressources : les ressources ne peuvent pas être partagées entre les processus, mais les threads partagent l'espace d'adressage et les autres ressources du processus dans lequel ils se trouvent. Dans le même temps, le thread possède également sa propre pile, son pointeur de pile, son compteur de programme et d'autres registres.
En termes d'indépendance : le processus a son propre espace d'adressage indépendant, mais pas le thread. Le thread doit dépendre du processus pour exister.
En termes de dépenses. La commutation de processus coûte cher. Les fils sont relativement petits. (Comme mentionné précédemment, l'introduction des fils de discussion est également due à des considérations de coût.)
Vous pouvez lire cet article : juejin.im/post/684490…
15. entre final, final et finalize
final est utilisé pour déclarer des propriétés, des méthodes et des classes, ce qui signifie respectivement que les propriétés sont immuables, que les méthodes ne peuvent pas être remplacées et que les classes ne peuvent pas être héritées
<.>finally est la gestion des exceptions Une partie de la structure de l'instruction, indiquant qu'elle est toujours exécutée.
finalize est une méthode de la classe Object. Cette méthode de l'objet recyclé sera appelée lors de l'exécution du garbage collector. Cette méthode peut être remplacée pour fournir d'autres fonctions lors du recyclage des ressources, telles que la fermeture de fichiers, etc.
16 La différence entre la sérialisation et ParcelableIf Intent in. Android souhaite transférer des objets de classe, cela peut être réalisé de deux manières.
Méthode 1 : Sérialisable, la classe à passer implémente l'interface Serialisable pour passer l'objet,
Méthode 2 : Parcelable, la classe à transférer implémente l'interface Parcelable pour transférer l'objet.
Sérialisable (livré avec Java) : Sérialisable signifie sérialisation, ce qui signifie convertir un objet en un état stockable ou transférable. Les objets sérialisés peuvent être transmis sur le réseau ou stockés localement. Serialisable est une interface balisée, ce qui signifie que Java peut sérialiser efficacement cet objet sans implémenter de méthodes.
Parcelable (exclusivement pour Android) : L'intention de conception originale de Parcelable d'Android est que Serialisable est trop lent (en utilisant la réflexion), afin de faciliter la communication entre les différents composants du programme et entre différents programmes Android (AIDL) Conçus pour transférer efficacement des données qui n'existent qu'en mémoire. Le principe d'implémentation de la méthode Parcelable est de décomposer un objet complet, et chaque partie après décomposition est un type de données pris en charge par Intent, réalisant ainsi la fonction de passage de l'objet.
Efficacité et sélection : Parcelable a de meilleures performances que Serialisable, car ce dernier est fréquemment GC pendant le processus de réflexion, il est donc recommandé d'utiliser Parcelable lors du transfert de données entre mémoires, comme le transfert de données entre les activités. Serialisable peut conserver les données pour un stockage facile, alors choisissez Serialisable lorsque vous devez enregistrer ou transmettre des données sur le réseau. Étant donné que Parcelable peut être différent selon les versions d'Android, il n'est pas recommandé d'utiliser Parcelable pour la persistance des données. Parcelable ne peut pas être utilisé lorsque les données doivent être stockées sur disque, car Parcelable ne peut pas garantir la persistance des données lorsque le monde extérieur change. Bien que Serialisable soit moins efficace, il est toujours recommandé d'utiliser Serialisable pour le moment. Lors du passage de types de données complexes via intent, l'une des deux interfaces doit être implémentée en premier. Les méthodes correspondantes sont getSerializingExtra() et getParcelableExtra(). 17. Les propriétés statiques et les méthodes statiques peuvent-elles être héritées ? Peut-il être réécrit ? Et pourquoi ?
Les propriétés et méthodes statiques de la classe parent peuvent être héritées par la sous-classe
ne peuvent pas être remplacées par la sous-classe : Lorsque la référence de la classe parent pointe vers la sous-classe Lorsque vous utilisez un objet pour appeler une méthode statique ou une variable statique, la méthode ou la variable de la classe parent est appelée. Il n'est pas remplacé par les sous-classes.
Raison :
Parce que la méthode statique a alloué de la mémoire depuis le début de l'exécution du programme, ce qui signifie qu'elle a été codée en dur. Tous les objets qui font référence à cette méthode (soit les objets de la classe parent, soit les objets de la sous-classe) pointent vers la même donnée en mémoire, qui est la méthode statique. Si une méthode statique portant le même nom est définie dans une sous-classe, elle ne sera pas remplacée. Au lieu de cela, une autre méthode statique de la sous-classe doit être allouée en mémoire, et la substitution n'existe pas. 18. L'intention de conception des classes internes statiques en Java Classes internes Les classes internes sont des classes définies à l'intérieur d'une classe. Pourquoi y a-t-il des classes internes ? Nous savons qu'en Java, les classes sont à héritage unique et qu'une classe ne peut hériter qu'une autre classe concrète ou classe abstraite (qui peut implémenter plusieurs interfaces). Le but de cette conception est que dans l'héritage multiple, lorsqu'il y a des attributs ou des méthodes en double dans plusieurs classes parents, le résultat de l'appel de la sous-classe sera ambigu, donc un héritage unique est utilisé.
La raison de l'utilisation des classes internes est que chaque classe interne peut hériter indépendamment d'une implémentation (de l'interface), donc si la classe externe a hérité d'une implémentation (de l'interface), cela n'a aucun effet sur la classe interne.
Dans notre programmation, il existe parfois des problèmes difficiles à résoudre à l'aide d'interfaces. À l'heure actuelle, nous pouvons utiliser la capacité fournie par les classes internes d'hériter de plusieurs classes concrètes ou abstraites pour résoudre ces problèmes de conception. . On peut dire que les interfaces ne résolvent qu'une partie du problème et que les classes internes rendent la solution de l'héritage multiple plus complète.
Classes internes statiques
Avant de parler de classes internes statiques, comprenons d'abord les classes internes membres (classes internes non statiques).
Classe interne membre
La classe interne membre est également la classe interne la plus courante. Elle est membre de la classe externe, elle peut donc avoir un accès illimité à tous. classes externes. Bien que les propriétés et méthodes des membres soient privées, si la classe externe souhaite accéder aux propriétés et méthodes des membres de la classe interne, elle doit y accéder via l'instance de classe interne.
Deux points à noter dans les classes internes membres :
Il ne peut y avoir de variables ni de méthodes statiques dans les classes internes membres ;
La classe interne membre est attachée à la classe externe, donc la classe interne ne peut être créée qu'après la création préalable de la classe externe.
Classes internes statiques
Il existe une plus grande différence entre les classes internes statiques et les classes internes non statiques : les classes internes non statiques sont compilées après la compilation, une référence est alors implicitement liée au monde extérieur dans lequel elle a été créée, mais pas la classe interne statique.
L'absence de cette référence signifie :
Sa création n'a pas besoin de dépendre de la classe environnante.
Il ne peut pas utiliser de variables membres non statiques et de méthodes d'aucune classe périphérique.
Les deux autres classes internes : les classes internes locales et les classes internes anonymes
Les classes internes locales
Les classes internes locales sont Nichée dans des méthodes et des portées, l'utilisation de cette classe est principalement destinée à appliquer et à résoudre des problèmes plus complexes. Nous souhaitons créer une classe pour faciliter nos solutions, mais à ce stade, nous ne voulons pas que cette classe soit accessible au public, nous A. La classe interne locale est générée. La classe interne locale est compilée de la même manière que la classe interne membre, mais sa portée a changé. Elle ne peut être utilisée que dans cette méthode et cet attribut, et elle deviendra invalide en dehors de la méthode et de l'attribut.
Classes internes anonymes
Les classes internes anonymes n'ont aucun modificateur d'accès.
nouvelle classe interne anonyme, cette classe doit exister en premier.
Lorsque le paramètre formel de la méthode doit être utilisé par la classe interne anonyme, alors le paramètre formel doit être final.
Les classes internes anonymes n'ont pas de constructeur explicite et le compilateur générera automatiquement un constructeur qui fait référence à la classe externe.
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
