Share
In questo laboratorio di codice testeremo la tua conoscenza delle stringhe Java. All'interno del codice di esempio, le variabili String verranno elaborate all'interno di una classe Java, che a sua volta ha una classe interna. Per capire con successo che cosa accadrà quando il codice viene eseguito, è necessario comprendere non solo le basi della stringa, ma anche i principi di oggetti e classi, nonché strutture di controllo che includono metodi, cicli e condizioni.
Quando lavori attraverso il codice, ricorda che il programmatore che lo ha scritto potrebbe avere degli errori nella loro logica. Il codice non contiene errori di sintassi che generano eccezioni in fase di esecuzione, ma il risultato potrebbe non essere necessariamente quello che il programmatore intendeva. Quando lavori su qualsiasi progetto di programmazione, c'è una forte possibilità che tu finisca per lavorare con il codice di qualcun altro, o il codice che hai scritto tu stesso in un dato momento nel passato e che riesci a malapena a ricordare. Sfortunatamente, noi esseri umani tendiamo a non produrre codice perfetto molto spesso, quindi leggere con un occhio critico è essenziale.
Il seguente codice Java rappresenta un file di classe Java con una classe interna in esso. Nel codice, le variabili String di testo vengono sottoposte a diversi processi. Cosa succede quando viene eseguito il metodo del costruttore StringFun? Lavora attraverso il codice e prendi nota di ciò che pensi verrà scritto attraverso le istruzioni di uscita del sistema nei punti A, B, C, D, E e F, tenendo presente che ognuna di queste può essere eseguita più di una volta. Potresti trovare più facile usare una matita e un foglio per annotare cosa succede mentre il codice progredisce.
Accentsconagua
public class StringFun public StringFun () String initString = "abcdefghij"; StringWorker strWorker = new StringWorker (initString); String theStr = strWorker.getText (); System.out.println ("POINT A:" + theStr); strWorker.setText (strWorker.multiplyText (1, theStr)); System.out.println ("POINT B:" + strWorker.getText ()); int endPosn = initString.length () / 2; String endString = (theStr.length ()> endPosn? TheStr.substring (0, endPosn): theStr); System.out.println ("POINT C:" + endString); String anotherString = endString.concat (strWorker.getText ()); System.out.println ("POINT D:" + anotherString); public class StringWorker private String theText; private int maxLength; public StringWorker (String initText) theText = initText; maxLength = 5; shortenString (); multiplyText (2, theText); System.out.println ("POINT E:" + theText); private void shortenString () if (theText.length ()> maxLength) theText.substring (0, maxLength); public String multiplyText (int multBy, String multText) StringBuilder sBuild = new StringBuilder (multText); per (int i = 0; i
La soluzione
Questo è l'output quando viene eseguito il metodo del costruttore StringFun:
PUNTO F: abcdefghij PUNTO E: abcdefghij PUNTO A: abcdefghij PUNTO F: abcdefghij PUNTO B: abcdefghijabcdefghij PUNTO C: abcde PUNTO D: abcdeabcdefghijabcdefghij
Si noti quale variabile String viene scritta in ogni istruzione, a volte è la variabile di istanza e talvolta è una variabile locale. Se questo non corrisponde a quello che pensavi sarebbe stato prodotto, non preoccuparti. Il codice è intenzionalmente difficile. Se hai ottenuto l'output corretto, ben fatto!
Note e spiegazioni
Il file sorgente allegato contiene il codice completo con annotazioni che spiegano cosa succede durante l'esecuzione. È possibile ottenere una migliore comprensione compilando ed eseguendo il programma e aggiungendo ulteriori istruzioni di traccia se si trova che aiuta (aggiungere il file di classe Java di origine a un progetto e creare un'istanza di oggetto della classe StringFun per iniziare).
Andiamo oltre alcuni dei punti problematici qui.
Immutabilità
Nel metodo di costruzione StringWorker, viene chiamato il metodo "shortenString". Sebbene questo metodo richiami il metodo della sottostringa sulla variabile di istanza String, in realtà non ne modifica il valore. In Java, le stringhe sono immutabili. Ciò significa che quando si modifica una stringa, Java crea effettivamente una nuova stringa. Il metodo della sottostringa non altera la stringa su cui è chiamato, ma copia il suo contenuto in una nuova stringa con l'alterazione della sottostringa applicata, restituendo questo nuovo valore di stringa. Se la chiamata al metodo di sottostringa è stata modificata come segue:
theText = theText.substring (0, maxLength);
Il risultato sarebbe diverso, poiché la variabile di istanza verrebbe aggiornata per contenere la nuova sottostringa. Mentre il codice è valido, il metodo restituisce "abcde" ma non fa nulla con esso.
Parametri e resi
Un'altra parte potenzialmente ingannevole del codice è il metodo "multiplyText". La confusione qui è causata dal fatto che il metodo ha un nome inappropriato e non viene usato in modo appropriato. Se, invece di lavorare attraverso il contenuto del metodo, hai interpretato in modo intuitivo questo metodo, dovresti assumere lo scopo di moltiplicare il testo per il numero passato come parametro intero. In realtà, il metodo aggiunge il testo a se stesso più volte, il che significa che si traduce in un "" numero "di volte maggiore di quanto ci si potrebbe aspettare. I nomi dei metodi possono avere un enorme impatto sull'utilizzabilità di una libreria o programma Java, come pure dei nomi di variabili e classi.
Il metodo "multiplyText" viene chiamato due volte nel codice, una volta nel costruttore StringFun e una volta nel costruttore StringWorker. Nel costruttore StringWorker, il codice non fa nulla con la stringa restituita e quindi la chiamata al metodo non fa nulla. Il metodo "multiplyText" non altera la variabile di istanza String. Esegue modifiche su una stringa passata, restituendo il risultato come una nuova stringa. Quando il metodo "multiplyText" viene chiamato nel costruttore StringFun, questa volta il codice esegue qualcosa con il risultato - imposta la variabile di istanza StringWorker sulla stringa restituita, utilizzando il metodo "setText".
Queste confusioni non sono solo un indicatore dell'uso improprio di un metodo, ma un segno che il metodo stesso è probabilmente progettato e nominato male. Il metodo "shortenString" altera la variabile di istanza della classe, mentre il metodo "multiplyText" non ha alcun effetto sulla variabile di istanza. Se uno o entrambi questi sono appropriati dipende dallo scopo della classe all'interno dell'applicazione, ma i loro nomi devono riflettere il loro scopo in un modo intuitivo per capire.
Quale variabile?
L'altra fonte generale di confusione nel codice è il fatto che abbiamo a che fare con diverse variabili di classe e locali. Ad esempio, se si esamina la sezione del costruttore StringFun in cui viene creata una nuova variabile locale denominata "endString", si noterà che esegue l'elaborazione su una variabile denominata "theStr", creata prima con poche righe. Data l'elaborazione che avviene tra queste due sezioni, è probabile che la sezione "endString" elabori la variabile di istanza dell'oggetto StringWorker appena modificata anziché una variabile locale precedente. Il codice sembra quindi contro-intuitivo, ma, di nuovo, tali interpretazioni sono ostacolate dalla mancanza di commenti che indicano lo scopo di una delle due classi o di una qualsiasi delle variabili.
Conclusione
OK, quindi il codice aveva alcuni trucchi. Tuttavia, questo è per riflettere la realtà di lavorare su molti progetti Java. Anche con le migliori intenzioni, la maggior parte del codice contiene errori. I progetti di programmazione sono spesso soggetti a modifiche del piano che si traducono in una logica fuorviante e in nomi di variabili e metodi che sembrano confusi. Se il codice è mal commentato, o non commentato affatto come nell'esempio sopra, ciò rende le cose ancora peggiori.
Avere la capacità di leggere il codice realisticamente e di utilizzare misure pratiche come le istruzioni di tracciamento per vedere cosa succede in diversi punti durante l'esecuzione è una vera risorsa in qualsiasi progetto di programmazione, come lo è capire le strutture linguistiche.
