Scopriamo uno degli approcci per inserire i dati dal flusso standard attraverso una classe java.util.Scanner... Facciamolo usando l'esempio di un semplice compito dall'utilissimo sito e-olimp.com

Compito

Inserisci un numero dal flusso standard. Supponendo che si tratti di un intero positivo a due cifre, stampa ogni cifra separatamente (separata da uno spazio) nel flusso di output standard. L'ordine dei numeri non deve essere modificato.

test

Nell'algoritmo non vengono assunti casi specifici. Eseguiamo tre test: il numero più piccolo dell'intervallo valido, il più grande e un valore al centro dell'intervallo.

Entrata	Uscita
10	1 0
99	9 9
54	5 4

Soluzione

Usiamo la classe java.util.Scanner, per inserire i dati in formato intero. E calcoliamo entrambi i suoi numeri.

Visualizzazione delle cifre di un intero a due cifre

Giava

class Main (public static void main (String args) genera java.lang.Exception (java.util.Scanner i = new java.util.Scanner (System.in); int n = i.nextInt (); System.out. println (n / 10 + "" + n% 10);))

classe principale ( public static void main (String args) lancia java. lang. Eccezione ( Giava. utile. Scanner i = nuovo java. utile. Scanner (Sistema. In); int n = io. nextInt (); Sistema. fuori. println (n / 10 + "" + n% 10);

Spiegazioni

1. Descriviamo la variabile io genere java.util.Scanner e assegnargli immediatamente il valore di un nuovo oggetto di questa classe. Il costruttore realizza l'oggetto Scanner«Ma da stdin. Quelli. io diventa una sovrastruttura sopra flusso standard ingresso. Questo ci permette di leggere un intero e non solo di leggerlo con il metodo leggere() un byte alla volta.
2. Usando il metodo successivoInt() legge una sequenza di numeri e la converte in un numero intero. Memorizziamo il numero nella variabile n.
3. n/ 10 - il numero di decine nel numero. Le decine saranno dieci volte inferiori al numero stesso. Viene eseguita la divisione intera - divisione intera.
4. n% 10 - calcola il resto della divisione per dieci - il numero di unità - il più cifra destra numeri.
5. n/ 10 + "" + n% 10 - inserisce una singola linea di spazio tra due interi. In questo caso, anche i numeri vengono convertiti in rappresentazione di stringhe e tutte e tre le stringhe vengono concatenate, chiamata concatenazione di stringhe. Ecco come funziona l'operazione "+" con i dati di stringa.

Velocizza I/O

Con tutta la comodità di questo approccio, è piuttosto lento e talvolta le attività non vengono eseguite in tempo. Puoi velocizzare notevolmente il lavoro utilizzando StreamTokenizer e PrintWriter.
Ciò aumenterà la quantità di codice, ma farà risparmiare tempo.

Velocizzare I/O

Giava

import java.io.*; import java.util.*; class Main (static StreamTokenizer in = new StreamTokenizer (new BufferedReader (new InputStreamReader (System.in))); statico PrintWriter out = new PrintWriter (System.out); statico int nextInt () genera IOException (in.nextToken (); return (int) in.nval;) public static void main (String args) genera java.lang.Exception (int n = nextInt (); out.println (n / 10 + "" + n% 10); out.flush ( );))

importa java. io. *; importa java. utile. *; classe principale ( static StreamTokenizer in = new StreamTokenizer (nuovo BufferedReader (nuovo InputStreamReader (System. in))); static PrintWriter out = new PrintWriter (System. out); static int nextInt() genera IOException (

Studiare come "sviluppatore di giochi" + impiego

Operatori Java

Per indicare operazioni di addizione, sottrazione, moltiplicazione e divisione in linguaggio Java il solito operatori aritmetici + - * /.

L'operatore / indica la divisione intera se entrambi i suoi argomenti sono interi. In caso contrario, questo operatore indica la divisione in virgola mobile. Il resto della divisione di numeri interi (cioè la funzione mod) è indicato dal simbolo%.
Ad esempio, 15/2 è 7, 15% 2 è 1 e 15. 0/2 è uguale a 7. 5.

Nota che la divisione intera per 0 dà luogo a situazione eccezionale, mentre la divisione per 0 dei numeri in virgola mobile è infinito o NaN.

Gli operatori aritmetici possono essere utilizzati per inizializzare le variabili.

intn = 5;
intero a = 2 *n; // Il valore della variabile a è 10.

È conveniente usare operatori aritmetici binari abbreviati negli operatori di assegnazione.

Ad esempio, l'operatore
x + = 4;
equivalente a operatore
x = x + 4;

(Gli operatori di assegnazione abbreviata vengono generati anteponendo un carattere di operazione aritmetica, ad esempio * o%, al carattere =, ad esempio * = o% =.)

Uno degli obiettivi dichiarati del linguaggio Java è l'indipendenza dalla macchina.

I calcoli dovrebbero portare a lo stesso risultato, indipendentemente dalla macchina virtuale che li esegue. Per calcoli aritmetici su numeri in virgola mobile, questo è stato inaspettatamente difficile. Doppio tipo utilizza 64 bit per memorizzare valori numerici, ma alcuni processori utilizzano registri a virgola mobile a 80 bit. Questi registri forniscono ulteriore precisione nelle fasi intermedie di calcolo. Prendiamo come esempio la seguente espressione:

doppia w = x * y / z;

Molti processori Intel calcola l'espressione x * y e memorizza questo risultato intermedio in un registro a 80 bit, quindi dividilo per il valore della variabile z e alla fine arrotonda il risultato a 64 bit. Ciò può migliorare l'accuratezza dei calcoli ed evitare gli overflow. Tuttavia, questo risultato potrebbe essere diverso se in tutti i calcoli viene utilizzato un processore a 64 bit.

Per questo, nella descrizione originale del virtual macchine Javaè stato evidenziato che tutti i calcoli intermedi devono essere arrotondati. Questo fece arrabbiare la comunità informatica. Non sono solo i calcoli arrotondati che possono causare overflow. Sono infatti più lenti di calcoli più accurati, poiché le operazioni di arrotondamento richiedono certo tempo... Di conseguenza, gli sviluppatori del linguaggio Java hanno cambiato idea, cercando di risolvere il conflitto tra prestazioni ottimali ed eccellente riproducibilità dei risultati.

Sviluppatori predefiniti macchina virtuale ora consentono di utilizzare una precisione estesa nei calcoli intermedi. Tuttavia, i metodi contrassegnati con la parola chiave strictfp devono utilizzare precise operazioni in virgola mobile per garantire risultati riproducibili. Ad esempio, il metodo principale può essere taggato con parole chiave come mostrato di seguito:
public static strictfp void main (String args)

In questo caso, tutti i comandi all'interno del metodo principale eseguiranno operazioni esatte sui numeri in virgola mobile.

I dettagli di queste operazioni sono strettamente correlati al modo in cui funzionano i processori Intel. Per impostazione predefinita, i risultati intermedi possono utilizzare la metrica estesa, ma non la mantissa estesa. (I chip Intel supportano l'arrotondamento della mantissa senza sacrificare le prestazioni.) Pertanto, l'unica differenza tra il calcolo predefinito e il calcolo esatto è che il calcolo preciso può traboccare, mentre il calcolo predefinito no.

Se il tuo sguardo si affievolisce durante la lettura di questa nota, non preoccuparti. Per la maggior parte dei programmatori, questa domanda è completamente irrilevante. Nella maggior parte dei casi, gli overflow in virgola mobile non si verificano. In questo libro, non useremo parola chiave rigoroso.

Operatori di incremento e decremento

I programmatori, ovviamente, sanno che una delle operazioni più comuni sulle variabili numeriche è l'aggiunta o la sottrazione di una. Nel linguaggio Java, come nei linguaggi C e C++, esistono operatori di incremento e decremento: l'operatore x++ aggiunge uno al valore corrente della variabile x, e l'operatore x- ne sottrae uno.

Ad esempio il codice
intn = 12;
n++;
rende il valore della variabile n uguale a 13.

Poiché questi operatori modificano il valore di una variabile, non possono essere applicati ai numeri stessi. Ad esempio, l'operatore 4++ non è valido.

Esistono due tipi di questi operatori. Quanto sopra mostra la forma "suffisso" dell'operatore, in cui i caratteri dell'operatore sono posti dopo l'operando. Esiste anche un modulo "prefisso" - ++ n.
Entrambi questi operatori incrementano di uno il valore della variabile. La differenza tra i due appare solo quando questi operatori vengono utilizzati all'interno delle espressioni. La forma del prefisso dell'operatore di incremento prima aggiunge uno al valore di una variabile, mentre la forma del suffisso usa il vecchio valore di quella variabile.

intm = 7;
intn = 7;
int a = 2 * ++ m; // Ora a è 16 e m è 8.
int b = 2 * n++; // Ora b è 14 e n è 8.

(Poiché è stato l'operatore ++ a dare il nome al linguaggio C++, questo è stato il motivo della prima battuta su di esso. I malviventi fanno notare che anche il nome di questo linguaggio contiene un errore: "Tra l'altro , questo linguaggio dovrebbe essere chiamato ++ C, perché vogliamo usare questo linguaggio solo dopo averlo migliorato. ")

La maggior parte delle operazioni su tipi primitivi si fa non con metodi, ma con personaggi speciali chiamato segno di operazione.

Operazione di assegnazione

Incarico valore variabile costanti, viene chiamata un'altra variabile o espressione (variabili e/o costanti separate da segni di operazione) operazione di assegnazione ed è indicato dal cartello " = ", ad esempio: x = 3; y = x; z = x; In Java è possibile riutilizzare l'operazione di assegnazione in un'espressione, ad esempio: x1 = x2 = x3 = 0; Questa operazione viene eseguita da destra a sinistra, cioè prima alla variabile x3 viene assegnato il valore 0, poi alla variabile x2 viene assegnato il valore della variabile x3 (0) e infine alla variabile x1 viene assegnato il valore della variabile x2 (0). i segni di operazioni i cui argomenti sono numeri rientrano in due categorie: unario token (unari) per operazioni a argomento singolo e binario(binario) con due argomenti.

operazioni unarie

Le seguenti operazioni unarie sono definite in Java:

• unario meno "-" - cambia il segno di un numero o di un'espressione al contrario;
• unario più "+" - non esegue alcuna azione su un numero o un'espressione;
• complemento bit a bit "~" (solo per numeri interi) - inverte tutti i bit del campo numerico (cambia da 0 a 1 e da 1 a 0);
• incremento "++" (solo per numeri interi) - aumenta il valore della variabile di 1;
• decremento "-" (solo per numeri interi) - diminuisce il valore della variabile di 1.

Esempi di operazioni unarie"+" e "-": int i = 3, j, k; j = - io; //j = -3 k = + io; // k = 3 Un esempio di operazione di complemento bit a bit: int a = 15; int b; b = ~ a; // b = -16 I numeri a e b sono int, cioè sono rappresentati internamente come interi binari con segno a 32 bit, quindi rappresentazione binaria i numeri a e b avranno questo aspetto: a = 00000000 00000000 00000000 00001111 b = 11111111 11111111 11111111 11110000 Come puoi vedere da questa rappresentazione, tutti i bit zero nel numero a vengono cambiati in uno nel numero b, e i bit uno in a vengono cambiati a zero bit... La rappresentazione decimale di b è –16. I segni delle operazioni di incremento e decremento possono essere posti prima o dopo la variabile. Queste opzioni sono denominate di conseguenza prefisso e suffisso registrando queste operazioni. Il segno dell'operatore nella notazione del prefisso restituisce il valore del suo operando dopo valutare un'espressione Per la notazione postfissa, il segno di operazione primo restituisce il valore del suo operando e solo dopo calcola l'incremento o il decremento, ad esempio: int x = 1, y, z; y = ++ x; z = x++; Alla variabile y verrà assegnato il valore 2, perché prima il valore di x verrà incrementato di 1, quindi il risultato verrà assegnato alla variabile y. Alla variabile z verrà assegnato il valore 1, perché prima verrà assegnato un valore alla variabile z, quindi il valore di x verrà incrementato di 1. In entrambi i casi, il nuovo valore di x sarà 2. Da notare che in Java, a differenza del C, le operazioni di decremento e incremento possono essere applicate anche a variabili reali ( galleggiante e doppio). Segni di operazione binaria si suddividono in operazioni con risultato numerico e operazioni di confronto il cui risultato è un valore booleano.

Operazioni binarie aritmetiche

Java definisce quanto segue operazioni binarie aritmetiche:

• addizione "+";
• sottrazione "-";
• moltiplicazione " * ";
• divisione "/";
• calcolando il resto della divisione degli interi "%" (restituisce il resto della divisione del primo numero per il secondo e il risultato avrà lo stesso segno del dividendo), ad esempio, il risultato dell'operazione 5% 3 sarà 2 e il risultato dell'operazione (-7) % (- 4) sarà -3. V Operazione Java può essere utilizzato per variabili reali (float o double).

Esempi binari operazioni aritmetiche: int x = 7, x1, x2, x3, x4, x5; x1 = x + 10; // x1 = 17 x2 = x - 8; // x2 = -1 x3 = x2 * x; // x3 = -7 x4 = x / 4; // x4 = 1 (quando si dividono interi // frazione scartato) x5 = x% 4 // x5 = 3 (resto della divisione// 7 per 4)

Operazioni bit a bit

• Le operazioni bit a bit considerano l'originale valori numerici come campi di bit ed eseguire su di essi le seguenti azioni:
• impostando il bit su io-esima posizione del campo risultato a 1, se entrambi i bit sono in io-esima posizione degli operandi uguale a 1, o 0, altrimenti - AND bit per bit ("&");
• impostando il bit su io-esima posizione del campo risultato a 1, se almeno un bit in io-esima posizione degli operandi è uguale a 1, oa 0, altrimenti - OR bit a bit ("|");
• impostando il bit su io-esima posizione del campo risultato a 1, se i bit in io-esima posizione degli operandi non uguale tra loro, o uguale a 0, altrimenti - OR esclusivo bit a bit ("^");
• spostamento a sinistra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (il bit di segno del numero non cambia in questo caso) - spostamento bit per bit a sinistra, tenendo conto del segno "<< ";
• sposta a destra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (il bit di segno del numero non cambia in questo caso) - sposta a destra per bit, tenendo conto del " >>" segno;
• spostamento a destra dei bit del campo del primo operando per il numero di bit determinato dal secondo operando (in questo caso viene spostato anche il bit di segno del numero) - spostamento bit per bit a destra senza tenere conto del " >>>" segno.

Esempi di operazioni bit a bit:

1. AND . bit a bit

   intero x = 112; int y = 94; int z; z = x & y; //z = 80: 00000000 00000000 00000000 01010000

2. OR bit a bit

   intero x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x | si; //z = 126: 00000000 00000000 00000000 01111110

3. OR esclusivo bit a bit

   intero x = 112; // x: 00000000 00000000 00000000 01110000 int y = 94; // y: 00000000 00000000 00000000 01011110 int z; z = x ^ y; //z = 46: 00000000 00000000 00000000 00101110

4. Spostati a sinistra, tenendo conto del segno

   int x = 31, z; // x: 00000000 00000000 00000000 00011111 z = x<< 2 ; //z = 124: 00000000 00000000 00000000 01111100

5. Spostati a destra, tenendo conto del segno

   int x = - 17, z; z = x >> 2; //z = -5: 11111111 11111111 11111111 11111011

6. Sposta a destra senza riguardo al segno

   int x = - 17, z; // x: 11111111 11111111 11111111 11101111 z = x >>> 2; //z = 1073741819 // z: 00111111 11111111 11111111 11111011

Operazioni combinate

In Java per operazioni aritmetiche binarie si può usare combinato token operazione (composti): identificatore operazione = espressione Equivale alla seguente operazione: identificatore = identificatore operazione espressione Esempi:

1. L'espressione x + = b significa x = x + b.
2. L'espressione x - = b significa x = x - b.
3. L'espressione x * = b significa x = x * b.
4. L'espressione x / = b significa x = x / b.
5. L'espressione x% = b significa x = x% b.
6. L'espressione x & = b significa x = x & b.
7. L'espressione x | = b significa x = x | B.
8. L'espressione x ^ = b significa x = x ^ b.
9. Espressione x<<= b означает x = x << b .
10. L'espressione x >> = b significa x = x >> b.
11. L'espressione x >>> = b significa x = x >>> b.

Operazioni di confronto

Java definisce i seguenti operatori di confronto:

• "==" (uguale), "! =" (non uguale),
• ">" (maggiore di), "> =" (maggiore o uguale),
• " < " (меньше) " <= " (меньше или равно)

hanno due operandi e restituiscono un valore booleano corrispondente al risultato del confronto ( falso o vero). Nota che quando si confrontano due valori per l'uguaglianza in Java, come in C e C ++, i simboli " == "(due segni di uguale senza spazio), in contrasto con l'operatore di assegnazione, che utilizza il" = ". L'utilizzo del simbolo" = "quando si confrontano due valori provoca un errore di compilazione o produce un risultato errato. Esempi di operazioni di confronto: booleano isEqual, isNonEqual, isGreater, isGreaterOrEqual, isLess, isLessOrEqual; int x1 = 5, x2 = 5, x3 = 3, x4 = 7; èuguale = x1 == x2; // isEqual = true isNonEqual = x1! = x2; // isNonEqual = false isGreater = x1> x3; // isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2> = x3; è minore = x3< x1; // isLess = true isLessOrEqual = x1 <= x3; // isLessOrEqual = false

Operazioni booleane

Operazioni booleane vengono eseguiti su variabili booleane e il loro risultato è anche un valore di tipo booleano... Le seguenti operazioni booleane sono definite in Java:

• negazione "!" - sostituire falso con vero, o viceversa;
• Operazione AND "&" - il risultato è vero solo se entrambi gli operandi sono veri, altrimenti il ​​risultato è falso;
• Operazione OR "|" - il risultato è vero solo se almeno uno degli operandi è vero, altrimenti il ​​risultato è falso.
• l'operazione OR esclusivo "^" - il risultato è vero solo se gli operandi non sono uguali tra loro, altrimenti il ​​risultato è falso.

Gli operatori "&", "|" e "^", così come i corrispondenti operatori bit per bit, possono essere utilizzati negli operatori di assegnazione composti: "& =", "| =" e "^ =" Inoltre, le operazioni " = sono applicabili agli operandi booleani. = "(uguale) e"! = "(non uguale). Come puoi vedere dalla definizione di OR e AND, l'operazione OR restituisce true quando il primo operando è vero, indipendentemente dal valore del secondo operando, e l'operatore AND restituisce false quando il primo operando è falso, indipendentemente da il valore del secondo operando. Java definisce altre due operazioni booleane: la seconda versione dell'AND booleano e dell'OR, note come operazioni logiche di cortocircuito: l'AND corto "&&" e l'OR corto "||". Quando si utilizzano queste operazioni, il secondo operando non verrà affatto valutato, il che è utile nei casi in cui l'operazione corretta dell'operando destro dipende dal fatto che l'operando sinistro sia vero o falso. Esempi di operazioni booleane: booleano isInRange, isValid, isNotValid, isEqual, isNotEqual; intero x = 8; isInRange = x> 0 && x< 5 ; // isInRange = false isValid = x >0 || x> 5; // isValid = true isNotValid =! è valido; // isNotValid = false isEqual = isInRange == isValid; // isEqual = false // isNotEqual = true isNotEqual = isInRange! = isValid

Operazione condizionale

Un'operazione condizionale è scritta nella forma espressione-1?espressione-2:espressione-3. In questo caso, viene valutata prima l'espressione-1, che dovrebbe fornire un valore booleano, quindi, se l'espressione-1 è vera, l'espressione-2 viene valutata e restituita come risultato dell'operazione, oppure (se l'espressione-1 è falsa ) e l'espressione-3 viene restituita come risultato dell'operazione. Un esempio di operazione condizionale: x = n> 1? 0: 1; Alla variabile x verrà assegnato il valore 0 se n> 1 (l'espressione n> 1 è vera) o 1 se n≤1 (l'espressione n> 1 è falsa).

Anzianità delle operazioni

Le operazioni nelle espressioni vengono tuttavia eseguite da sinistra a destra, in base alla loro priorità. Quindi operazioni di moltiplicazione nell'espressione y = x + z * 5; verrà eseguito prima dell'operazione di addizione perché la priorità dell'operazione di moltiplicazione è maggiore della priorità dell'operazione di addizione. Le priorità delle operazioni (in ordine decrescente di priorità) in Java sono mostrate nella Tabella. uno.
Le parentesi aumentano la precedenza delle operazioni che si trovano al loro interno. Quindi, se inserisci parentesi nell'espressione sopra: y = (x + z) * 5; quindi verrà eseguita prima l'operazione di addizione, quindi l'operazione di moltiplicazione. A volte le parentesi vengono usate semplicemente per rendere più leggibile l'espressione, ad esempio: (x> 1) && (x<= 5 ) ;

Digitare la conversione e il casting durante l'esecuzione delle operazioni

Nelle espressioni di assegnazione e aritmetiche si possono utilizzare letterali, variabili ed espressioni di diverso tipo, ad esempio: double y; byte x; y = x + 5; Questo esempio aggiunge la variabile byte x al letterale 5 (int) e assegna il risultato alla doppia variabile y. In Java, come nel linguaggio C, le conversioni di tipo nella valutazione delle espressioni possono essere eseguite automaticamente o utilizzando un operatore di cast. Tuttavia, le regole di casting sono in qualche modo diverse da quelle del linguaggio C, e in generale sono più rigide rispetto al linguaggio C. Quando si esegue un'operazione di assegnazione, la conversione del tipo avviene automaticamente se ampliamento trasformare(conversione allargata) e i due tipi sono compatibili... Le trasformazioni in ampliamento sono trasformazioni byte® breve® int® lungo® galleggiante® Doppio... Per le conversioni di ampliamento, i tipi numerici, inclusi interi e in virgola mobile, sono compatibili tra loro. Tuttavia, i tipi numerici non sono compatibili con i tipi char e booleani. Neanche i tipi char e boolean sono compatibili tra loro. Java esegue anche la conversione automatica del tipo quando memorizza una costante letterale intera (che è di tipo int per impostazione predefinita) in variabili di tipo byte, short o long (tuttavia, se il letterale ha un valore al di fuori dell'intervallo di valori validi per questo tipo, viene visualizzato un messaggio di errore: possibile perdita di precisione). Se la conversione è una conversione restrittiva, ovvero viene eseguita una conversione byte ¬ short ¬ char ¬ int ¬ long ¬ float ¬ double, tale conversione può portare a perdita di precisione o distorsione del numero. Pertanto, con le conversioni restringenti, quando il programma viene compilato, viene visualizzato un messaggio di diagnostica sull'incompatibilità di tipo e i file di classe non vengono creati. Questo messaggio verrà visualizzato anche quando si tenta di convertire espressioni di tipo byte o short in una variabile di tipo char. Se è comunque necessario eseguire tali conversioni, viene utilizzata un'operazione di cast, che ha il seguente formato: ( tipo di conversione) senso, dove tipo di conversione definisce il tipo in cui il dato dovrebbe essere convertito senso, ad esempio, come risultato dell'esecuzione di operatori: byte x = 71; simbolo carattere = (carattere) x; la variabile simbolo sarà impostata su "G". Se un valore a virgola mobile è assegnato a un tipo intero, allora (se il valore a virgola mobile ha una parte frazionaria), si verifica anche una conversione di tipo esplicita troncamento(troncamento) numeri. Quindi, come risultato dell'esecuzione dell'operatore int x = (int) 77,85; la variabile x sarà impostata su 77. Se il valore assegnato è fuori intervallo conversioni di tipo , quindi il risultato della conversione sarà il resto della divisione del valore per il modulo dell'intervallo del tipo assegnato (per i numeri di tipo byte, il modulo dell'intervallo sarà 256, in breve - 65536, per int - 4294967296 , e a lungo - 18446744073709551616). Ad esempio, come risultato dell'istruzione byte x = (byte) 514; la variabile x sarà impostata su 2. Quando si convertono numeri interi o reali in dati di tipo char, la conversione in un carattere avviene se il numero originale è compreso tra 0 e 127, altrimenti il ​​carattere assume il valore "?". Quando si eseguono conversioni aritmetiche e bit per bit, tutti i valori byte e short, nonché char, vengono espansi in int, (mentre il valore numerico del codice carattere viene utilizzato nei calcoli per char) quindi, se almeno un operando è di tipo long , il tipo dell'espressione intera viene esteso a long. Se uno degli operandi è di tipo float, il tipo dell'espressione completa viene espanso in float e se uno degli operandi è di tipo double, il tipo del risultato sarà double. Quindi, se le variabili sono dichiarate byte a, c; b breve; quindi nell'espressione a + b * c - 15 L + 1.5F + 1.08 - 10; prima, prima di calcolare a + b * c, i valori delle variabili verranno espansi a int, quindi, poiché la costante 15 è di tipo long, il risultato del calcolo verrà aumentato a long prima della sottrazione. Successivamente, poiché il letterale 1.5 è di tipo float, il risultato del calcolo di a + b * c - 15L verrà espanso in float prima di essere aggiunto a questo letterale. Prima di eseguire l'addizione con il numero 1.08, il risultato dei calcoli precedenti verrà espanso a double (poiché le costanti reali sono di tipo double di default) e, infine, prima di eseguire l'ultima addizione, sarà letterale 10 (int di default) ampliato al doppio. Pertanto, il risultato della valutazione dell'espressione sarà di tipo double. Le estensioni automatiche di tipo (in particolare le estensioni short e byte di int) possono causare errori in fase di compilazione non riconosciuti. Ad esempio, negli operatori: byte x = 30, y = 5; x = x + y; prima che venga eseguita l'addizione, il valore delle variabili x e y verrà espanso in int, quindi verrà visualizzato un messaggio di errore quando si tenta di assegnare il risultato di un calcolo di tipo int a una variabile di tipo byte. Per evitare ciò è necessario utilizzare una conversione di tipo esplicita nel secondo operatore: x = (byte) (x + y); È necessario racchiudere l'espressione x + y tra parentesi perché la priorità del cast racchiuso tra parentesi è maggiore della priorità dell'operazione di addizione. A proposito, se scrivi il secondo operatore come: x + = y; non ci sarà alcun messaggio di errore. Link al primo

1. Operazioni aritmetiche di base

La tabella seguente elenca le operazioni aritmetiche di base utilizzate nel linguaggio Java:

Consideriamo alcune regole per lavorare con le operazioni aritmetiche:

• Le espressioni vengono valutate da sinistra a destra, a meno che non vengano aggiunte parentesi o alcune operazioni abbiano la precedenza.
• Le operazioni *, / e% hanno la precedenza su + e -.

Esempio 1. Operazioni aritmetiche su valori interi

Ad esempio, in questo codice, le variabili un e B avrà significati diversi:

Classe pubblica BasicIntMath (public static void main (String args) (int a = 4 + 5 - 2 * 3; int b = 4 + (5 - 2) * 3; System.out.println ("a =" + a) ; System.out.println ("b =" + b);))

Risultato dell'esecuzione:

A = 3 b = 13

• L'operazione di sottrazione unaria cambia il segno del suo unico operando.
• Un'operazione di addizione unaria restituisce semplicemente il valore del suo operando. In linea di principio non è necessario, ma possibile.

Esempio 2. Operazioni unarie di addizione e sottrazione

public class UnarySignOperation ( public static void main (String args) (doppia a = -6; doppia b = +6; System.out.println (a); System.out.println (b);))

• Quando viene eseguita un'operazione di divisione su un tipo di dati intero, il risultato non conterrà un componente frazionario.

Esempio 3. Divisione di numeri interi

public class IntDivision (public static void main (String args) (int a = 16/5; System.out.println (a);))

Il risultato dell'esecuzione di questo programma:

• Gli operandi per le operazioni aritmetiche devono essere di tipo numerico. Le operazioni aritmetiche non possono essere eseguite su tipi di dati booleani, ma possono essere eseguite su tipi di dati char poiché in Java questo tipo è essenzialmente una variazione del tipo int.

Esempio 4. Operazioni aritmetiche su variabili di tipo char

public class BasicCharMath1 (public static void main (String args) (char c = "n"; System.out.println (c); System.out.println (c + 1); System.out.println (c / 5) ;))

Risultato dell'esecuzione:

N 111 22

Esempio 5. Operazioni aritmetiche su variabili di tipo char

public class BasicCharMath2 (public static void main (String args) (char c1 = "1"; char c2 = "\ u0031"; char c3 = 49; System.out.println (c1 + c2 + c3);))

Risultato dell'esecuzione:

Operatore modulo - indicato con%. Questo operatore restituisce il resto del primo numero diviso il secondo. Quando si divide un numero intero, anche il risultato è un numero intero.

Esempio 6. Divisione modulo

public class DivisionByModule (public static void main (String args) (int a = 6% 5; double b = 6,2% 5,0; System.out.println (a); System.out.println (b);))

Risultato dell'esecuzione:

1 1.2000000000000002

2. Operazioni aritmetiche composte con assegnazione

Java ha operazioni speciali che combinano l'aritmetica con l'assegnazione. Considera la seguente espressione:

A = a + 4;

In Java, questa operazione può essere scritta come segue:

A + = 4;

Le operazioni di assegnazione composita non solo consentono di ridurre la quantità di codice, ma consentono anche di eseguire la conversione automatica, che non viene eseguita dalle operazioni convenzionali.

Esempio 5. Operazioni di assegnazione aritmetica composita

public class CompoundOperations (public static void main (String args) (int a = 1; int b = 2; int c = 3; a + = 3; b * = 2; c + = a * b; System.out.println (a); System.out.println (b); System.out.println (c);))