Η εξαίρεση NullPointerException είναι μία από τις πιο συνηθισμένες αιτίες αποτυχίας των προγραμμάτων Java.
Στις πιο απλές περιπτώσεις ο μεταγλωττιστής μπορεί να σας προειδοποιήσει άμεσα ότι
εντοπίζει κώδικα όπως τον παρακάτω:
Object o = null;
String s = o.toString();
Για τη δημιουργία κλάδων και βρόχων καθώς και για τη δημιουργία εξαιρέσεων, χρειάζεται μια αρκετά σύνθετη ανάλυση ροής για να εξακριβωθεί αν μια μεταβλητή η παραπομπή της οποίας αναλύεται αντιστοιχεί σε τιμή null ή μη null σε ορισμένες ή σε όλες τις διαδρομές του προγράμματος.
Λόγω της εγγενούς πολυπλοκότητας, η ανάλυση ροής εκτελείται καλύτερα σε μικρά τμήματα. Παρ' όλο που η ανάλυση ολόκληρου του συστήματος είναι εκτός της εμβέλειας του μεταγλωττιστή Eclipse Java, η ανάλυση μιας μεθόδου μπορεί να εκτελείται κάθε φορά με καλή απόδοση του εργαλείου. Το πλεονέκτημα είναι ότι η ανάλυση εκτελείται γρήγορα και κατά τρόπο αυξητικό έτσι ώστε ο μεταγλωττιστής να σας προειδοποιεί άμεσα καθώς πληκτρολογείτε. Το μειονέκτημα είναι ότι η ανάλυση δεν μπορεί να εντοπίσει ποιες τιμές (null ή μη null) ανταλλάσσονται μεταξύ των μεθόδων (με τη μορφή παραμέτρων και επιστρεφόμενων τιμών).
Σε αυτό το σημείο αρχίζουν να αξιοποιούνται οι σημειώσεις null.
Αν ορίσετε μια παράμετρο μεθόδου ως
@NonNull,
μπορείτε να δώσετε εντολή στον μεταγλωττιστή ότι δεν επιθυμείτε να ορίσετε τιμή
null σε αυτή τη θέση.
String capitalize(@NonNull String in) {
return in.toUpperCase(); // δεν απαιτείται έλεγχος null
}
void caller(String s) {
if (s != null)
System.out.println(capitalize(s)); // απαιτείται προηγούμενος έλεγχος null
}
Στο πλαίσιο της Σχεδίασης βάσει συμβολαίου, το παραπάνω έχει δύο πτυχές:
capitalize
εξασφαλίζει ότι το όρισμα in δεν έχει τιμή null και,
συνεπώς, η ανάλυση παραπομπής χωρίς έλεγχο null είναι αποδεκτή σε αυτή την περίπτωση.
Για τιμές επιστροφής μεθόδου η κατάσταση είναι συμμετρική:
@NonNull String getString(String maybeString) {
if (maybeString != null)
return maybeString; // απαιτείται ο παραπάνω έλεγχος null
else
return "<n/a>";
}
void caller(String s) {
System.out.println(getString(s).toUpperCase()); // δεν απαιτείται έλεγχος null
}
Ο μεταγλωττιστής Eclipse Java μπορεί να ρυθμιστεί ώστε να χρησιμοποιεί τρία διακριτά είδη σημειώσεων για τη βελτίωση της ανάλυσης null που εκτελεί (η οποία είναι ενεργοποιημένη από προεπιλογή):
@NonNull: η τιμή null δεν είναι έγκυρη@Nullable: η τιμή null επιτρέπεται και πρέπει αναμένεται@NonNullByDefault: τα είδη στις μεθόδους υπογραφής που δεν περιέχουν
σημείωση null θεωρείται ότι έχουν τιμή μη null.Οι σημειώσεις @NonNull και @Nullable υποστηρίζονται στις
παρακάτω θέσεις:
Η σημείωση @NonNullByDefault υποστηρίζεται για
package-info.java) - για να επηρεάζει όλα τα είδη στο
πακέτο
Έχετε υπόψη ότι ακόμα και τα πραγματικά πλήρη ονόματα αυτών των σημειώσεων
μπορούν
να ρυθμιστούν,
ωστόσο χρησιμοποιούνται απο προεπιλογή οι παραπάνω σημειώσεις (από το πακέτο
org.eclipse.jdt.annotation).
Ένα JAR με προεπιλεγμένες σημειώσεις null παρέχεται με το Eclipse στο αρχείο eclipse/plugins/org.eclipse.jdt.annotation_*.jar. Αυτό το αρχείο JAR πρέπει να βρίσκεται στη διαδρομή δόμησης κατά τον χρόνο μεταγλώττισης αλλά όχι απαραίτητα κατά τον χρόνο εκτέλεσης (επομένως, δεν χρειάζεται να το αποστείλετε στους χρήστες του μεταγλωττισμένου κώδικά σας).
Υπάρχουν δύο ταχείες επιδιορθώσεις για μη αναλυμένες παραπομπές σε σημειώσεις
@NonNull, @Nullable ή @NonNullByDefault που ενσωματώνουν το αρχείο JAR στη διαδρομή δόμησης:


Σε αυτό το σημείο, πρέπει να διευκρινιστεί ότι οι σημειώσεις null προσθέτουν περισσότερες πληροφορίες στο πρόγραμμα Java (οι οποίες μπορούν να χρησιμοποιηθούν από τον μεταγλωττιστή ώστε να λαμβάνετε καλύτερες προειδοποιήσεις). Ποιες πληροφορίες επιθυμούμε να περιέχουν οι σημειώσεις; Ουσιαστικά, τα επίπεδα πληροφορίων που επιθυμούμε να περιέχουν οι σημειώσεις είναι τουλάχιστον τρία:
Στην περίπτωση (1), μπορείτε να αρχίσετε να χρησιμοποιείτε αμέσως σημείωσεις null και χωρίς περαιτέρω ανάγνωση, ωστόσο θα σας εμφανίζεται σποραδικά μόνο μια μικρή υπόδειξη. Για τα άλλα επίπεδα χρειάζονται ορισμένες περαιτέρω διευκρινίσεις.
Εκ πρώτης όψεως, η χρήση σημειώσεων null για προδιαγραφές API στο πλαίσιο σχεδίασης
βάσει συμβολαίου σημαίνει απλώς ότι οι υπογραφές όλων των μεθόδων API πρέπει να έχουν
πλήρεις σημειώσεις, δηλαδή, εκτός από τα στοιχειώδη είδη όπως το int, κάθε
παράμετρος και κάθε είδος επιστροφής πρέπει να επισημαίνεται είτε ως
@NonNull είτε ως @Nullable.
Δεδομένου ότι αυτό συνεπάγεται την εισαγωγή πάρα πολλών σημειώσεων null, πρέπει να
γνωρίζουμε ότι σε έναν καλοσχεδιασμένο κώδικα (ιδιαίτερα στις μεθόδους API) η σημείωση
@NonNull συναντάται πολύ πιο συχνά απ' ό,τι η σημείωση
@Nullable. Συνεπώς ο αριθμός των σημειώσεων μπορεί να μειωθεί ορίζοντας τη
σημείωση @NonNull ως προεπιλογή με τη χρήση μιας σημείωσης
@NonNullByDefault στο επίπεδο του πακέτου.
Πρέπει να επισημανθεί η σημαντική διαφορά μεταξύ της σημείωσης @Nullable και
της
παράλειψης μιας σημείωσης null: στην πρώτη περίπτωση, η σημείωση δηλώνει ρητά ότι η σημείωση
null είναι αποδεκτή και πρέπει να αναμένεται.
Αντιθέτως, η έλλειψη σημείωσης σημαίνει απλώς ότι δεν γνωρίζουμε την πρόθεση.
Αυτή είναι η συνήθης περίπτωση όπου ορισμένες φορές και οι δύο πλευρές (το στοιχείο κλήσης
και το καλούμενο στοιχείο) διεξάγουν πλεονάζων έλεγχο για σημειώσεις και κάποιες φορές και
οι δύο πλευρές υποθέτουν εσφαλμένα ότι η άλλη πλευρά θα διεξαγάγει τον έλεγχο.
Κατά αυτόν τον τρόπο, προκύπτουν οι εξαιρέσεις NullPointerExceptions.
Χωρίς σημείωση, ο μεταγλωττιστής δεν θα παράσχει συγκεκριμένη συμβουλή αλλά με μια σημείωση
@Nullable θα επισημαίνεται κάθε μη ελεγμένη ανάλυση παραπομπής.
Με αυτά τα βασικά στοιχεία, μπορούμε να αντιστοιχίσουμε άμεσα όλες τις σημειώσεις παραμέτρων με προκαταρκτικές συνθήκες και να ερμηνεύσουμε τις σημειώσεις επιστροφής ως συνθήκες λήξης της μεθόδου.
Στον αντικειμενοστρεφή προγραμματισμό η έννοια της σχεδίασης βάσει συμβολαίου πρέπει να
καλύπτει ακόμα μία διάσταση:
τη δημιουργία υποειδών και την αντικατάσταση (συνακόλουθα ο όρος "αντικαθιστώ" θα
χρησιμοποιείται υπό την έννοια της σημείωσης
@Override στο Java 6: οι μέθοδοι που αντικαθιστούν ή υλοποιούν
άλλη μέθοδο από ένα υπερ-είδος). Ένας πελάτης που καλεί μια μέθοδο παρόμοια με την
παρακάτω:
@NonNull String checkedString(@Nullable String in)
πρέπει να έχει το δικαίωμα να θεωρεί ότι όλες οι υλοποιήσεις αυτής της
μεθόδου πληρούν τους όρους του συμβολαίου.
Επομένως, όταν η δήλωση μεθόδου βρίσκεται σε μια διεπαφή I1,
πρέπει να εξασφαλίζουμε ότι οποιαδήποτε κλάση Cn που
υλοποιεί τη διεπαφή I1 δεν θα παρέχει ασύμβατη υλοποίηση. Πιο
συγκεκριμένα, δεν επιτρέπεται οποιαδήποτε κλάση Cn να προσπαθεί να
αντικαταστήσει αυτή τη μέθοδο με μια υλοποίηση που δηλώνει την παράμετρο ως
@NonNull.
Αν επιτρέπαμε να συμβεί αυτό , μια λειτουργική μονάδα πελάτη η οποία έχει
προγραμματιστεί για τη διεπαφή I1 θα μπορούσε νόμιμα να μεταβιβάσει την
τιμή null ως όρισμα αλλά η υλοποίηση θα υπέθετε μια τιμή μη null - η μη ελεγμένη ανάλυση
παραπομπής εντός της υλοποίησης μεθόδου θα επιτρεπόταν αλλά στο περιβάλλον εκτέλεσης θα
προκαλούσε σφάλμα.
Συνεπώς, μια προδιαγραφή παραμέτρου @Nullable υποχρεώνει όλες τις
αντικαταστάσεις να αποδέχονται την τιμή null ως αναμενόμενη και νόμιμη.
Αντιθέτως, μια προδιαγραφή επιστροφής @NonNull
υποχρεώνει όλες τις αντικαταστάσεις να εξασφαλίζουν ότι η τιμή null δεν θα
επιστραφεί ποτέ.
Επομένως, ο μεταγλωττιστής πρέπει να ελέγχει ότι καμία αντικατάσταση δεν
προσθέτει σημείωση παραμέτρου @NonNull (ή σημείωση επιστροφής
@Nullable) που δεν υπάρχει στο υπερ-είδος.
Ενδιαφέρον είναι το γεγονός ότι οι αντίστροφοι ανακαθορισμοί είναι έγκυροι: η
προσθήκη μιας σημείωσης παραμέτρου @Nullable ή μιας σημείωσης επιστροφής
@NonNull
(μπορεί να θεωρήσετε ότι πρόκειται για "βελτιώσεις" της μεθόδου) δέχεται περισσότερες
τιμές και παράγει μια πιο συγκεκριμένη επιστρεφόμενη τιμή).
Τα παραπάνω θέματα αυξάνουν τον δείκτη δυσκολίας όταν ένας κώδικας με σημειώσεις
εγγράφεται ως υπερ-είδος παλαιότερου (δηλαδή χωρίς σημείωση) είδους (το οποίο μπορεί
να προέρχεται από βιβλιοθήκη τρίτου μέρους και κατά συνέπεια δεν μπορεί να αλλάξει).
-Αν διαβάσατε πολύ προσεκτικά την τελευταία ενότητα ενδεχομένως να παρατηρήσατε ότι δεν
μπορούμε να
αποδεχτούμε την αντικατάσταση μιας παλαιότερης μεθόδου από μια μέθοδο με παράμετρο
@NonNull
(δεδομένου ότι οι πελάτες που δεν χρησιμοποιούν το υπερ-είδος δεν αντιλαμβάνονται την
υποχρέωση @NonNull).
Σε αυτή την περίπτωση θα αναγκαστείτε να αφαιρέσετε τις σημειώσεις null (υπάρχουν σχέδια ώστε να υποστηρίζεται στο μέλλον η εκ των υστέρων προσθήκη σημειώσεων σε βιβλιοθήκες, ωστόσο δεν μπορούμε να υποσχεθούμε ακόμα τίποτα σχετικά με το αν και το πώς θα καταστεί διαθέσιμη μια τέτοια λειτουργία).).
Η κατάσταση γίνεται πιο περίπλοκη αν ένα υποείδος παλαιότερου είδους βρίσκεται σε ένα
πακέτο για το οποίο έχει οριστεί σημείωση
@NonNullByDefault. Σε αυτή την περίπτωση, ένα είδος με υπερ-είδος χωρίς
σημειώσεις θα πρέπει να επισημάνει όλες τις παραμέτρους στις μεθόδους αντικατάστασης ως
@Nullable:
ακόμα και η αφαίρεση των σημειώσεων παραμέτρων δεν επιτρέπεται γιατί αυτό θα ερμηνευόταν
ως παράμετρος @NonNull, κάτι το οποίο απαγορεύεται σε αυτή τη θέση.
Για αυτόν τον λόγο, ο μεταγλωττιστής Eclipse Java υποστηρίζει την ακύρωση μιας προεπιλογής
nullness: με την προσθήκη σε μέθοδο ή σε είδος
σημειώσεων @NonNullByDefault(false)
η εφαρμόσιμη προεπιλογή θα ακυρωθεί για αυτό το στοιχείο και οι παράμετροι χωρίς
σημειώσεις θα ερμηνεύονται και πάλι ως απροσδιόριστες. Πλέον, η δημιουργία υποειδών
είναι και πάλι αποδεκτή χωρίς την προσθήκη μη επιθυμητών σημειώσεων
@Nullable:
class LegacyClass {
String enhance (String in) { // οι πελάτες δεν αναγκάζονται να μεταβιβάσουν την τιμή
μη null.
return in.toUpperCase();
}
}
@NonNullByDefault
class MyClass extends LegacyClass {
// ... μέθοδοι με προεπιλογή @NonNull ...
@Override
@NonNullByDefault(false)
String enhance(String in) { // δεν θα ήταν έγκυρο αν εδώ ίσχυε η σημείωση @NonNullByDefault
return super.enhance(in);
}
}
Η χρήση σημειώσεων null στο πλαίσιο της σχεδίασης βάσει συμβολαίου όπως περιγράφεται παραπάνω συμβάλλει στη βελτίωση της ποιότητας του κώδικα Java με διάφορους τρόπους: στη διεπαφή μεταξύ μεθόδων καθίσταται σαφές ποιες παράμετροι/επιστροφές αποδέχονται μια τιμή null και ποιες όχι. Έτσι καταγράφονται οι αποφάσεις σχεδίασης, οι οποίες αφορούν σε μεγάλο βαθμό τους προγραμματιστές, κατά τρόπο που ελέγχεται επίσης από τον μεταγλωττιστή.
Επιπλέον, βάσει αυτής της προδιαγραφής διεπαφής, η ανάλυση ροής μεταξύ διαδικασιών μπορεί να συλλέξει διαθέσιμες πληροφορίες και να παράσχει πολύ περισσότερα σφάλματα/προειδοποιήσεις. Χωρίς σημειώσεις, οποιαδήποτε τιμή ρέει προς μια μέθοδο ή έξω από αυτήν έχει άγνωστη τιμή nullness και, συνεπώς, η ανάλυση null δεν παρέχει κανένα μήνυμα σχετικά με τη χρήση τους. Με σημειώσεις null επιπέδου API, η σημείωση nullness των περισσότερων τιμών είναι γνωστή και είναι πολύ λιγότερα τα NPE που δεν θα παρατηρήσει ο μεταγλωττιστής. Ωστόσο, πρέπει να γνωρίζετε ότι ακόμα υπάρχουν ορισμένες αδυναμίες, όταν απροσδιόριστες τιμές αποστέλλονται στην ανάλυση μη επιτρέποντας έτσι να καθοριστεί πλήρως αν τα NPE μπορούν να συμβούν στο περιβάλλον εκτέλεσης.
Η υποστήριξη που παρέχεται για σημειώσεις null έχει σχεδιαστεί έτσι ώστε να επιτρέπει τη μελλοντική επέκταση μέσω της οποίας ο μεταγλωττιστής θα μπορεί να εξασφαλίζει ότι ένα πιστοποιημένο πρόγραμμα δεν θα δημιουργήσει ποτέ μια εξαίρεση NullPointerException στο περιβάλλον εργασίας (με τους συνήθεις κινδύνους για τα μη ελεγμένα τμήματα, όπως η στοχαστική ανάλυση). Ενώ δεν μπορούμε να υποσχεθούμε τίποτα ακόμα σχετικά με μια μελλοντική επέκταση, η βασική ιδέα είναι απλώς μια διαφορετική ερμηνεία αυτών που ήδη διαθέτουμε.
Θεωρώντας ότι όλες τις σημειώσεις null αποτελούν μέρος του συστήματος είδους,
διπλασιάζουμε τον αριθμό των ειδών σε ένα συγκεκριμένο πρόγραμμα: για οποιαδήποτε
συγκεκριμένη κλάση Cn, αυτή καθαυτή η κλάση δεν θεωρείται πλέον ως έγκυρο
είδος, αλλά μόνο οι κλάσεις "@NonNull Cn" και
"@Nullable Cn" αποτελούν χρήσιμα είδη. Επομένως, σε ιδανικές συνθήκες, για
κάθε τιμή σε κάποιο πρόγραμμα θα γνωρίζουμε αν μπορεί να είναι null (και αν πρέπει να
ελέγχεται πριν από την ανάλυση της παραπομπής) ή όχι.
Αν εξαιρέσουμε την τρίτη επιλογή (είδη χωρίς σημειώσεις), ο μεταγλωττιστής μπορεί να
επισημαίνει έντονα κάθε μη ασφαλή χρήση.
Η τρέχουσα υλοποίηση υπόκειται σε δύο βασικούς περιορισμούς όσον αφορά αυτόν τον στόχο:
Μέχρι στιγμής και παρά τους τρέχοντες περιορισμούς, το όραμα για πλήρως καθορισμένα και ελεγμένα προγράμματα έχει ήδη επιφέρει ορισμένα αποτελέσματα βάσει των οποίων διαμορφώθηκε η τρέχουσα ανάλυση και δημιουργήθηκαν τα σφάλματα/προειδοποιήσεις που εμφανίζει ο μεταγλωττιστής. Οι λεπτομέρειες θα διευκρινιστούν με την εξήγηση των κανόνων που ελέγχει ο μεταγλωττιστής και των μηνυμάτων που δημιουργεί σε περίπτωση παραβίασης ενός κανόνα.
Στην αντίστοιχη σελίδα προτιμήσεων οι μεμονωμένοι κανόνες που ελέγχονται από τον μεταγλωττιστή βρίσκονται κάτω από τις εξής κεφαλίδες:
Ως παραβίαση προδιαγραφής νοείται οποιαδήποτε κατάσταση όπου η σημείωση null δηλώνει
ότι παραβιάζεται από την τρέχουσα υλοποίηση. Αυτό οφείλεται συνήθως στο γεγονός ότι
ορίζεται μια τιμή (τοπικό στοιχείο, όρισμα, επιστροφή μεθόδου) ως @NonNull
ενώ η υλοποίηση παρέχει ουσιαστικά τιμή nullable. Σε αυτή την περίπτωση, μια έκφραση
θεωρείται ως
nullable είτε αν είναι στατικά γνωστό ότι έχει οριστεί με τιμή null είτε αν έχει
δηλωθεί με σημείωση @Nullable.
Δεύτερον, αυτή η κατηγορία περιλαμβάνει επίσης κανόνες για την αντικατάσταση μεθόδου
όπως αναφέρθηκε παραπάνω.
Στην προκειμένη περίπτωση, μια υπερ-μέθοδος υποβάλλει ένα αίτημα (π.χ. ότι η τιμή null είναι
έγκυρο όρισμα)
ενώ μια αντικατάσταση προσπαθεί να παρακάμψει αυτό το αίτημα (θεωρώντας ότι η τιμή null
δεν είναι έγκυρο όρισμα).
Όπως ήδη αναφέρθηκε, ακόμα και η εξειδίκευση ενός ορίσματος χωρίς σημειώσεις σε όρισμα
@NonNull συνιστά παραβίαση προδιαγραφής, καθώς εισάγει συμβόλαιο που θα
πρέπει να δεσμεύει τον πελάτη (να μην μεταβιβάζει τιμές null) αλλά ο πελάτης που
χρησιμοποιεί το υπερ-είδος δεν θα αντιληφθεί αυτό το συμβόλαιο και, συνεπώς, δεν θα
γνωρίζει πώς πρέπει να ενεργήσει.
Όσον αφορά τις παραβιάσεις προδιαγραφών, μπορείτε να βρείτε
εδώ
τον πλήρη κατάλογο των περιπτώσεων.
Πρέπει να γίνει κατανοητό ότι τα σφάλματα σε αυτή την κατηγορία
δεν πρέπει ποτέ να αγνοούνται,
διότι διαφορετικά ολόκληρη η ανάλυση null θα εκτελεστεί βάσει εσφαλμένων υποθέσεων.
Πιο συγκεκριμένα, όταν ο μεταγλωττιστής εντοπίζει μια τιμή με σημείωση
@NonNull λαμβάνει ως δεδομένο ότι η τιμή null δεν θα εμφανιστεί στο
περιβάλλον εκτέλεσης.
Οι κανόνες για τις παραβιάσεις προδιαγραφών είναι εκείνοι που εξασφαλίζουν ότι ο
συλλογισμός είναι βάσιμος.
Συνεπώς, συνιστάται να διατηρήσετε αυτό το πρόβλημα ως σφάλμα.
Ομοίως, αυτή η κατηγορία κανόνων ελέγχει την πλήρωση των προδιαγραφών null.
Ωστόσο, σε αυτή την περίπτωση δεν πρόκειται για τιμές που έχουν δηλωθεί ως
@Nullable
(ούτε έχει οριστεί η τιμή null αυτή καθαυτή), αλλά για τιμές στις οποίες η
η ανάλυση ροής μεταξύ διαδικασιών συμπεραίνει ότι η τιμή null είναι
πιθανόν να εμφανιστεί σε κάποια διαδρομή εκτέλεσης.
Αυτή η κατάσταση οφείλεται στο γεγονός ότι για τις τοπικές μεταβλητές που δεν περιέχουν σημειώσεις ο μεταγλωττιστής θα συμπεράνει μέσω της ανάλυσης ροής αν η τιμή null είναι πιθανόν να εμφανιστεί. Υποθέτοντας ότι αυτή η ανάλυση είναι ακριβής, εάν εντοπίσει κάποιο πρόβλημα αυτό θα είναι εξίσου σοβαρό με τις άμεσες παραβιάσεις μιας προδιαγραφής null. Επομένως, συνιστάται και σε αυτή την περίπτωση να διατηρήσετε αυτά τα προβλήματα ως σφάλματα και να μην αγνοείτε αυτά τα μηνύματα.
Η δημιουργία ξεχωριστής κατηγορίας για αυτά τα προβλήματα εξυπηρετεί δύο σκοπούς: να τεκμηριώνεται ότι ένα συγκεκριμένο πρόβλημα προκλήθηκε με τη βοήθεια της ανάλυσης ροής και να εκτελούνται οι κατάλληλες ενέργειες σε περίπτωση που αυτή η ανάλυση ροής είναι εσφαλμένη (λόγω σφάλματος κατά την υλοποίηση). Σε περίπτωση αναγνωρισμένου σφάλματος εκτέλεσης, μόνο σε ειδικές περιστάσεις είναι αποδεκτή η απόκρυψη ενός μηνύματος σφάλματος αυτού του είδους.
Δεδομένης της φύσης κάθε στατικής ανάλυσης, η ανάλυση ροής μπορεί να μη εντοπίσει ότι ορισμένοι συνδυασμοί διαδρομών εκτέλεσης και τιμών δεν είναι εφικτοί. Για παράδειγμα, η συσχέτιση μεταβλητής:
String flatten(String[] inputs1, String[] inputs2) {
StringBuffer sb1 = null, sb2 = null;
int len = Math.min(inputs1.length, inputs2.length);
for (int i=0; i<len; i++) {
if (sb1 == null) {
sb1 = new StringBuffer();
\ sb2 = new StringBuffer();
}
sb1.append(inputs1[i]);
sb2.append(inputs2[i]); // εδώ υπάρχει προειδοποίηση
}
if (sb1 != null) return sb1.append(sb2).toString();
return "";
}
Ο μεταγλωττιστής θα αναφέρει μια πιθανή ενέργεια πρόσβασης μέσω δείκτη null στην κλήση
sb2.append(..).
Ο χρήστης αντιλαμβάνεται ότι δεν υπάρχει κίνδυνος καθώς οι μεταβλητές
sb1 και sb2 ουσιαστικά συσχετίζονται κατά τρόπο που τόσο η μία
όσο και η άλλη έχουν τιμή null ή μη null.
Στην προκειμένη περίπτωση, γνωρίζουμε ότι η μεταβλητή sb1 δεν έχει τιμή
null και συνακόλουθα ούτε και η μεταβλητή sb2. Χωρίς να αναλύσουμε
περαιτέρω τους λόγους για τους οποίους αυτή η ανάλυση συσχετισμού είναι πέραν των
δυνατοτήτων του μεταγλωττιστή Eclipse Java, έχετε υπόψη ότι αυτή η ανάλυση δεν ισοδυναμεί
με εργαλείο απόδειξης θεωρημάτων και, συνεπώς, αναφέρει απλώς
ορισμένα προβλήματα που μια πιο προχωρημένη ανάλυση θα τα αναγνώριζε ως εσφαλμένες
προειδοποιήσεις.
Εάν επιθυμείτε να επωφεληθείτε από την ανάλυση ροής, συνιστάται να διευκολύνετε τον
μεταγλωττιστή ώστε να αντιλαμβάνεται τα προβλήματά σας. Αυτή η βοήθεια μπορεί να
συνίσταται απλώς στον διαχωρισμό του if (sb1 == null)
σε δύο ξεχωριστά if, ένα για κάθε τοπική μεταβλητή, συμβολή που είναι ελάχιστη σε
σχέση με το κέρδος που θα αποκομίσετε αφού ο μεταγλωττιστής θα μπορεί να αντιλαμβάνεται
ακριβώς τι συμβαίνει και να ελέγχει αντίστοιχα τον κώδικά σας.
Θα ακολουθήσουν περισσότερες λεπτομέρειες για το θέμα
παρακάτω.
Αυτή η κατηγορία προβλημάτων βασίζεται στην εξής αναλογία: σε ένα πρόγραμμα που χρησιμοποιεί γενικά είδη Java 5 οποιαδήποτε κλήση σε βιβλιοθήκες Java προγενέστερες της έκδοσης 5 μπορεί να εκθέσει αδιαμόρφωτα είδη, δηλαδή εφαρμογές ενός γενικού είδους το οποίο δεν μπορεί να προσδιορίσει συγκεκριμένα ορίσματα είδους. Για να ταιριάξουν αυτές οι τιμές σε κάποιο πρόγραμμα που χρησιμοποιεί γενικά είδη, ο μεταγλωττιστής μπορεί να προσθέσει μια έμμεση μετατροπή υποθέτοντας ότι τα ορίσματα είδους προσδιορίστηκαν όπως ανέμενε το τμήμα του κώδικα που αφορά τον πελάτη. Ο μεταγλωττιστής θα δημιουργήσει μια προειδοποίηση σχετικά με τη χρήση αυτής της μετατροπής και θα προβεί στον έλεγχο του είδους υποθέτοντας ότι η βιβλιοθήκη λειτουργεί σωστά. Ακριβώς με τον ίδιο τρόπο, ένα είδος επιστροφής χωρίς σημειώσεις μιας μεθόδου βιβλιοθήκης μπορεί να θεωρηθεί ως "αδιαμόρφωτο" ή ως "παλαιότερο" είδος. Again an implicit conversion can optimistically assume the expected specification. Δημιουργείται και πάλι προειδοποίηση και η ανάλυση συνεχίζει να θεωρεί ότι η βιβλιοθήκη ενεργεί σωστά.
Σε θεωρητικό επίπεδο, η ανάγκη για τέτοιες έμμεσες μετατροπές υποδεικνύει επίσης παραβίαση προδιαγραφής. Ωστόσο, σε αυτή την περίπτωση, η παραβίαση της προδιαγραφής που αναμένει ο κώδικάς μας μπορεί να πραγματοποιείται από κώδικα άλλου προμηθευτή. Ή ενδεχομένως, (όπως εμείς πιστεύουμε), ο κώδικας κάποιου τρίτου μέρους όντως πληροί τους όρους του συμβολαίου αλλά δεν το δηλώνει (διότι δεν χρησιμοποιεί σημειώσεις null). Σε αυτές τις περιπτώσεις μπορεί να μην είμαστε σε θέση να διορθώσουμε επακριβώς το πρόβλημα για οργανωτικούς λόγους.
@SuppressWarnings("null")
@NonNull Foo foo = Library.getFoo(); // έμμεση μετρατροπή
foo.bar();
Το παραπάνω τμήμα κώδικα θεωρεί ότι το στοιχείο
Library.getFoo() επιστρέφει ένα στοιχείο
Foo χωρίς να ορίζει μια σημείωση null. Μπορούμε να ενσωματώσουμε την τιμή
επιστροφής στο πρόγραμμα με σημειώσεις μέσω της αντιστοίχισης σε μια τοπική μεταβλητή
@NonNull, η οποία επιστρέφει μια προειδοποίηση σχετικά με μια μη ελεγμένη
μετατροπή.
Με την προσθήκη μιας αντίστοιχης προειδοποίησης SuppressWarnings("null") σε
αυτή τη
δήλωση αναγνωρίζουμε τον εγγενή κίνδυνο και αποδεχόμαστε την ευθύνη ότι έχουμε ελέγξει
ότι η βιβλιοθήκη λειτουργεί όπως επιθυμούμε.
Αν η ανάλυση ροής δεν μπορεί να αντιληφθεί ότι η τιμή δεν είναι στην πραγματικότητα null,
η πιο απλή στρατηγική είναι να προσθέσετε μια νέα τοπική μεταβλητή εμβέλειας με
σημείωση @NonNull.
Στη συνέχεια, αν είστε βέβαιοι ότι η τιμή που αποδίδεται σε αυτή την τοπική μεταβλητή δεν
θα είναι ποτέ null στο περιβάλλον εκτέλεσης, μπορείτε να χρησιμοποιήσετε μεθόδους
βοήθειας όπως:
static @NonNull <T> T assertNonNull(@Nullable T value, @Nullable String msg) {
if (value == null) throw new AssertionError(msg);
return value;
}
@NonNull MyType foo() {
if (isInitialized()) {
MyType couldBeNull = getObjectOrNull();
@NonNull MyType theValue = assertNonNull(couldBeNull,
"value should not be null because application " +
"is fully initialized at this point.");
return theValue;
}
return new MyTypeImpl();
}
Έχετε υπόψη ότι, χρησιμοποιώντας την παραπάνω μέθοδο
assertNonNull(),
αποδέχεστε την ευθύνη ότι αυτή η πρόταση επαλήθευσης δεν θα προκαλέσει ποτέ σφάλμα στο περιβάλλον εκτέλεσης.
Εάν δεν επιθυμείτε κάτι τέτοιο, οι τοπικές μεταβλητές που περιέχουν σημειώσεις θα
συνεχίσουν να βοηθούν στον ακριβέστερο προσδιορισμό των σημείων στα οποία η
ανάλυση διαπιστώνει ότι υπάρχει δυνατότητα αποστολής τιμών null σε συγκεκριμένη θέση καθώς και
των λόγων.
Κατά την κυκλοφορία της έκδοσης JDT 3.8.0, η συγκέντρωση συμβουλών για την υιοθέτηση σημειώσεων null βρισκόταν ακόμα υπό εξέλιξη. Για αυτόν τον λόγο, αυτές οι πληροφορίες βρίσκονται επί του παρόντος στο wiki του Eclipse.