Introduction à plusieurs erreurs courantes en Java

Erreurs Java courantes :

1. Erreur de pointeur nul

Dans l'utilisation de tableaux Java, il est parfois nécessaire de modifier les éléments du tableau de chaînes Faire des comparaisons. Ensuite, lorsque l'élément n'est pas nul, le programme s'exécutera normalement ; cependant, une fois que l'élément comparé est nul, une erreur de pointeur nul se produira dans le programme.

Solution : Ajoutez une protection et portez un jugement lorsque l'élément n'est pas nul.

public static void main(Sring[] args){
　　String [] sums = "adfafA";
　　for(int i=0;i<sums.length;i++){
　　　　if(sums[]!=null && sums[i].equals(sr)){
　　　　　　System.out.println("找到元素"+sums[i]);
　　　　　　break;
　　　　}
　　}
}

2. Plage de précision des données et conversion de type

Il existe 4 types de données de base en Java :

Type entier : -1 2 3 4…

Type à virgule flottante : float 1.3f ; double 3.2 3.5d (type non spécifié, précision la plus élevée par défaut)

Type de caractère : encodage Unicode, 2 octets

Type booléen : les plages de précision du quatre types de données de base, vrais et faux

, sont différents et sont améliorés étape par étape.

Si vous ne faites pas attention à la plage de précision lors de l'utilisation des types de données, un débordement de données se produira, entraînant des erreurs de calcul.

Parmi les quatre types de base, les données entières, à virgule flottante et caractères peuvent être converties entre elles.

Les règles de conversion sont les suivantes :

①Conversion invisible : les valeurs de données avec une petite précision sont affectées à des valeurs avec une haute précision et peuvent être automatiquement converties. (De bas niveau à haut niveau)

②Conversion forcée : valeurs de données avec une large plage, (de haut niveau à bas niveau)

③Règles de promotion automatique de fonctionnement : pendant le fonctionnement, il est automatiquement converti en un type de données de haute précision.

3. L'utilisation de trois types de boucles

① pour la boucle : C'est une boucle avec un nombre de fois limité. Avant la boucle, le nombre de boucles est précisé.

for(表达式；表达式；表达式){
      　 循环体
　}

instruction break : après l'exécution, sortez immédiatement de la boucle, n'exécutez pas les instructions suivantes et terminez toutes les boucles.

instruction continue : après l'exécution, sortez immédiatement de la boucle de mots actuelle et jugez à nouveau si la condition continue de boucler.

②Instruction de boucle While : convient aux boucles d'un nombre de fois inconnu.

while(条件表达式){
　　语句
　}；

③do-While loop : C'est aussi une boucle d'un nombre de fois inconnu. L'ordonnance doit être exécutée au moins une fois avant de rendre un jugement. Si while est vrai, continuez la boucle, sinon terminez la boucle.

do {
　语句
　}while(条件表达式)；

4. Copier la chaîne plusieurs fois

Une erreur qui ne peut pas être trouvée par les tests génère plusieurs copies d'un objet immuable. Un objet immuable ne peut pas être modifié, il n'est donc pas nécessaire de le copier. L’objet immuable le plus couramment utilisé est String.

Si vous devez modifier le contenu d'un objet String, vous devez utiliser StringBuffer. Le code suivant fonctionnera correctement :

String s = new String ("Text here");

Cependant, ce code a de mauvaises performances et est inutilement complexe. Vous pouvez également réécrire le code ci-dessus de la manière suivante :

String temp = "Text here";
String s = new String (temp);

Mais ce code contient une chaîne supplémentaire, ce qui n'est pas complètement nécessaire. Le meilleur code est :

String s = "Text here";

5. Aucun objet n'est renvoyé par clone (clone)

L'encapsulation est un concept important dans la programmation orientée objet. Malheureusement, Java facilite la rupture accidentelle de l'encapsulation - Java permet de renvoyer des références à des données privées. Le code suivant révèle ceci :

import java.awt.Dimension;
　　/***Example class.The x and y values should never*be negative.*/
　　public class Example{
　　private Dimension d = new Dimension (0, 0);
　　public Example (){ }
　　/*** Set height and width. Both height and width must be nonnegative * or an exception is thrown.*/
　　public synchronized void setValues (int height,int width) throws IllegalArgumentException{
　　if (height <0 || width <0)
　　throw new IllegalArgumentException();
　　d.height = height;
　　d.width = width;
　　}
　　public synchronized Dimension getValues(){
　　// Ooops! Breaks encapsulation
　　return d;
　　}
　　}

La classe Exemple garantit que les valeurs de hauteur et de largeur qu'elle stocke sont toujours non négatives. Essayer d'utiliser la méthode setValues() pour définir des valeurs négatives déclenchera un message. exception. Malheureusement, puisque getValues() renvoie une référence à d, pas une copie de d, vous pouvez écrire du code destructeur comme celui-ci :

　　Example ex = new Example();
　　Dimension d = ex.getValues();
　　d.height = -5;
　　d.width = -10;

Maintenant, l'objet Exemple a une valeur négative si l'appel à getValues() ! Si l'utilisateur ne définit jamais les valeurs de largeur et de hauteur de l'objet Dimension renvoyé, il est impossible de détecter de telles erreurs par des tests seuls.

Malheureusement, au fil du temps, le code client peut modifier la valeur de l'objet Dimension renvoyé. À l'heure actuelle, retrouver la source de l'erreur est fastidieux et prend du temps, en particulier dans un environnement multithread.

Une meilleure façon est de laisser getValues() renvoyer une copie :

　　public synchronized Dimension getValues(){
　　return new Dimension (d.x, d.y);
　　}

6 Copie de mauvaises données

Parfois, les programmeurs savent qu'ils doivent renvoyer une copie, mais ne le font pas. t Faites attention à ne pas copier les mauvaises données. Puisque seule une partie du travail de copie des données est effectuée, le code suivant s'écarte de l'intention du programmeur :

import java.awt.Dimension;
　　/*** Example class. The height and width values should never * be
　　negative. */
　　public class Example{
　　static final public int TOTAL_VALUES = 10;
　　private Dimension[] d = new Dimension[TOTAL_VALUES];
　　public Example (){ }
　　/*** Set height and width. Both height and width must be nonnegative * or an exception will be thrown. */
　　public synchronized void setValues (int index, int height, int width) throws IllegalArgumentException{
　　if (height <0 || width <0)
　　throw new IllegalArgumentException();
　　if (d[index] == null)
　　d[index] = new Dimension();
　　d[index].height = height;
　　d[index].width = width;
　　}
　　public synchronized Dimension[] getValues()
　　throws CloneNotSupportedException{
　　return (Dimension[])d.clone();
　　}
　　}

Le problème ici est que la méthode getValues() clone uniquement le tableau, mais ne clone pas l'objet Dimension contenu Dans le tableau,Par conséquent, bien que l'appelant ne puisse pas modifier le tableau interne afin que ses éléments pointent vers différents objets Dimension, l'appelant peut modifier le contenu des éléments du tableau interne (c'est-à-dire l'objet Dimension). Une meilleure version de la méthode getValues() est :

　public synchronized Dimension[] getValues() throws CloneNotSupportedException{
　　Dimension[] copy = (Dimension[])d.clone();
　　for (int i = 0; i
　　// NOTE: Dimension isn’t cloneable.
　　if (d != null)
　　copy[i] = new Dimension (d[i].height, d[i].width);
　　}
　　return copy;
　　}

Des erreurs similaires seront commises lors du clonage de tableaux multidimensionnels de données de type atomique. Les types atomiques incluent int, float, etc. Un simple clone d'un tableau unidimensionnel de type int est correct, comme indiqué ci-dessous :

　public void store (int[] data) throws CloneNotSupportedException{
　　this.data = (int[])data.clone();
　　// OK
　　}

Copier un tableau bidimensionnel de type int est plus compliqué. Java n'a pas de tableau bidimensionnel de type int, donc un tableau bidimensionnel de type int est en fait un tableau unidimensionnel : son type est int[]. Le simple clonage d'un tableau de type int[][] fera la même erreur que la première version de la méthode getValues() dans l'exemple ci-dessus, cela doit donc être évité. L'exemple suivant montre les méthodes incorrectes et correctes lors du clonage d'un tableau int bidimensionnel :

public void wrongStore (int[][] data) throws CloneNotSupportedException{
　　this.data = (int[][])data.clone(); // Not OK!
　　}
　　public void rightStore (int[][] data){
　　// OK!
　　this.data = (int[][])data.clone();
　　for (int i = 0; i
　　if (data != null)
　　this.data[i] = (int[])data[i].clone();
　　}
　　}

Pour plus de connaissances sur Java, veuillez faire attention à la colonne Tutoriel de base Java.

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!