AT - PROGRAMMAZIONE

Linguaggio Macchina: È il linguaggio direttamente comprensibile dal processore, costituito da sequenze binarie di 0 e 1. Non è progettato per essere letto o scritto dagli esseri umani, rendendolo estremamente difficile da utilizzare senza l'ausilio di strumenti specializzati. La rappresentazione potrebbe apparire come una sequenza di bit come "10101001010..."

Linguaggio a basso livello: detto anche assembly, permette di codificare le istruzioni del linguaggio macchina con delle sigle mnemoniche. In Windows .exe

Problemi:

è comunque di difficile lettura e scrittura, ma in certi casi viene usato per programmare, come in operazioni basilari iniziali di un PC.
ogni processore ha le sue istruzioni, e quindi il programma funzionerà solo con alcuni processori.

Assembler: Si occupa di convertire il linguaggio a basso livello (assembly) in linguaggio macchina. Questo processo è reversibile, permettendo agli sviluppatori di modificare il codice originale.

Linguaggio ad alto livello: Più simile al linguaggio naturale, facilitando la lettura e la scrittura del codice da parte degli sviluppatori. Indipendente dalla CPU, il che significa che non è necessario conoscere le istruzioni specifiche di ogni processore. Istruzioni più astratte e semantiche semplificate, rendendo più agevole individuare errori e mantenere il codice.

Compilatore: converte il linguaggio di alto livello in linguaggio macchina per il processore. Ogni architettura di processore richiede il suo compilatore, e quindi il prodotto della compilazione (codice eseguibile) non è indipendente dalla CPU. Il processo di compilazione è reversibile, ma si ottiene solo del linguaggio di basso livello. Il compilatore si occupa anche di ottimizzare il codice, eliminando le operazioni inutili.

Linguaggio strutturato: C++, Pascal, Basic, Scratch..., è un linguaggio ad alto livello che utilizza tre componenti:

sequenza = una serie di istruzioni eseguite in un determinato ordine
condizioni o selezioni = sceglie quale sequenza eseguire in base a dei parametri
cicli o iterazione = ripete la stessa sequenza più volte

Linguaggi interpretati: non sempre i programmi vengono distribuiti come file compilati, alcuni linguaggi sono interpretati, e viene distribuito direttamente il codice sorgente, non riduce la sicurezza perché essa dipende soprattutto dalla logica. Su ogni singola macchina il programma viene compilato linea per linea (interpretato) e trasformato nel linguaggio macchina.

- Vantaggi: Vale per tutte le macchine, es: mac, Windows, 32 o 64 bit.
- Svantaggi: è più lento. Es: javascript, usato nei browser, fa impiegare molto tempo al pc per tradurre.

Offuscamento: Il codice sorgente viene notevolmente complicato e mascherato. Questo per evitare che quando vendo un programma, chiunque possa vedere come è fatto dentro e facilmente scoprire gli algoritmi. Quindi prima di compilare il codice sorgente, lo si fa processare da un programma che lo rende più complicato da leggere per un essere umano. Spesso si usa l’offuscamento anche per ridurre la dimensione del bytecode.

Macchine Virtuali: via di mezzo tra linguaggio compilato ed interpretato. Il codice viene compilato nel linguaggio macchina di un processore virtuale di fantasia, producendo un file chiamato “bytecode”, è il passaggio più lento. Per ogni architettura/ sistema operativo esiste poi un programma che trasforma il bytecode nel codice macchina reale. Es: Java Virtual Machine e .Net (.exe di oggi).

Linguaggio ad oggetti: raggruppa in un’unica entità sia le strutture dati o proprietà sia le funzioni, cioè i metodi che operano su di esse, le entità possono comunicare tra di loro facilmente, per esempio basta inserire la data di nascita e poi il pc elabora in automatico l'età, che si chiama metodo. E' più facile riprodurre il mondo reale, più facile gestire e mantenere il codice (es: 10 programmatori, ognuno lavora su di esso). Inoltre è più facile riciclare il codice.

Polimorfismo: Catene di arricchimento degli oggetti, si creano oggetti più grandi che includo altri oggetti. Crea oggetto forma e da li si divide in quadrato, triangolo, cerchio, e si arricchiscono per esempio calcolando l'area (lo devono fare da sole)... E' più facile riprodurre il mondo reale, più facile gestire e mantenere il codice (es: 10 programmatori, ognuno lavora su di esso). Inoltre è più facile riciclare il codice.

JAVA

E' un linguaggio di alto livello strutturato ad oggetti ed è stato sviluppato da Sun, è stato venduto con la multinazionale ad Oracle.

Nel 2020 è usato su circa 3 miliardi di dispositivi di vario tipo, Smart card, pc, stampanti, cellulari Android e server, tipo Twitter, LinkedIn e Google, infatti è specificamente progettato per essere il più possibile indipendente dalla piattaforma hardware. Esistono moltissime versioni che mantengono uno stesso linguaggio base.

Java Standard Edition: interprete per la Java Virtual Machine usato su pc con già incluse alcune librerie base, come per leggere/scrivere file...

Java Development Kit (JDK): è il compilatore della Java Virtual Machine, lo si invoca con il comando “javac nomeFile.java”, e produce il bytecode “nomeFile.class”.

Java Runtime Environment (JRE): interprete; è la macchina virtuale che traduce il bytecode java nel linguaggio specifico della piattaforma. Per eseguire un programma java occorre usare l’interprete, specificando come parametro il bytecode da caricare: “java nomeFile” (.class non occorre metterlo). Windows lo fa in automatico.

Netbeans: è un IDE, Integrated Development Environment, cioè un ambiente di sviluppo, un software che aiuta lo sviluppo del programma con scorciatoie con la tastiera, evidenziazione del codice. Cambiare grafica Netbeans: Tools--> option. Si possono tenete aperti schermate di codici in contemporanea, ma non è logico. Windows --> reset Windows – se qualcosa non funziona con la grafica.

Salvare il file in una cartella - Cartella NetBeansProjects

Src: sottocartelle del codice sorgente / Nbproject: del sistema / Classes-->sources-->contiene il programma / Lib: librerie aggiuntive

Compilazione: quando si salva il file, viene automaticamente compilato. La si può forzare cliccando sul simbolo del martello. Modificando e con run si salva in automatico ed esegue, o con F6.

Esecuzione (richiamare l’interprete): basta cliccare sulla freccia verde in alto. Il risultato apparirà nella parte bassa di Netbeans.

LIBRERIA

Parole chiave: sono parole riservate del linguaggio, che vanno scritte esattamente così come sono, in minuscolo, e non possono essere usate per altri scopi.

package helloWorld: è la prima cosa che viene specificata (opzionale, ma caldamente consigliata: ecco perché NetBeans la mette sempre). Serve ad organizzare il codice, nel computer ogni package (pacchetto) corrisponde ad una cartella.

Quando ci serve una libreria o del codice che risiede in un altro pacchetto, useremo l’istruzione “import” per dirgli di accedervi (se li leggessi sempre tutti, ci metterei una vita). Es: ogni studente potrebbe chiamare il package con nomeCognome (i package iniziano sempre con la minuscola); in questo modo, se si creano elementi aventi lo stesso nome questi non verranno confusi.

public class HelloWorld: definisce una nuova Classe. Per ora penseremo agli oggetti come elementi da manipolare in un programma Java, ed alla classe come una fabbrica di oggetti. Gli oggetti possono contenere dati (anche altri oggetti) ed operazioni. E' un array di stringhe. Qui ci sono due parole chiave:

public, a significare che la classe HelloWorld può essere usata da tutti
private class

class: che indica l’inizio della definizione di una classe. Ogni file sorgente (file .java) può contenere una sola classe pubblica, il cui nome deve coincidere con quello del file (attenzione alle maiuscole).public static void main(String[] args). Per ora diciamo solo che è si tratta di un metodo (contenitore di una sequenza di istruzioni) accessibile a tutti (“public” all’inizio). Ogni programma Java deve avere un metodo chiamato main: quando eseguo il programma l’interprete cerca un metodo così chiamato e da lì inizia l’esecuzione del programma.

Commenti: tutto quello che segue una doppia barra ( // ) viene ignorato. Se il commento sta su più righe /* commento */

Punto e Virgola: gli enunciati del corpo di un metodo, gli elementi della sequenza di istruzioni, vengono terminati con un punto e virgola.

Parentesi graffe: le sequenze di istruzioni vengono racchiuse all’interno di parentesi graffe.

Richiamare oggetti: la stringa “Ciao Mondo” viene inviata all’output standard, in Java, l’output standard è rappresentato dall’oggetto chiamato out. In particolare, l’oggetto out è inserito a sua volta in un’altra classe, System, che contiene gli oggetti ed i metodi necessari per accedere alle risorse di sistema. Per usare l’oggetto Y incluso nella classe X si scrive X.Y → System.out

Richiamare metodi: vogliamo usare un metodo dell’oggetto out chiamato println, che stampa una riga di testo. Per usare un metodo si usa sempre il punto, e tra parentesi si scrivono le informazioni necessarie per l’esecuzione del metodo (parametri). Le parentesi vanno scritte anche se il metodo non richiede parametri, se il metodo richiede più parametri, vanno separati l’uno dall’altro usando una virgola.

Stringa: una sequenza di caratteri racchiusa tra virgolette es: “Ciao Mondo”. Le virgolette servono a far capire al compilatore quale parte del codice è un comando e quale un parametro.

println(): permette anche di stampare numeri (scritti senza le “ ”) e quindi di eseguire operazioni. Esiste anche il metodo print(), che funziona come println() ma non va a capo. Scorciatoia di tastiera: sout e poi premere tab

"Testo" + "Testo"="Testo Testo"

13+12=25

"13"+"12"=1312

"Testo"+ 12 = Testo12 (12 diventa una stringa)

"Testo"+12+12 = Testo1212 = stringa

"Testo"+(12+12) = stringa24

Caratteri speciali: “\n” va a capo; “\t” inserisce una tabulazione; “\\” inserisce una barra; “\”” (barra virgolette) inserisce una virgoletta.

Leggibilità: in teoria si potrebbe scrivere tutto su una riga, ma sarebbe di difficile lettura. Lo standard prevede: due spazi di rientro, una riga per comando.

Andare su source-->format o Alt+Shift+F

VARIABILI

Le variabili sono spazi di memoria, identificati da un nome, che possono contenere valori di un determinato tipo.

Definizione: per essere usate, le variabili vanno definite indicandone il tipo ed il nome (nomeTipo nomeVariabile;). Una variabile può contenere solo informazioni del suo stesso tipo. Durante la definizione, alla variabile si può assegnare un valore iniziale.

String nome ="Pippo";

String: cosa posso mettere nel contenitore - nome: che etichetta metto nel contenitore

Ogni carattere è indicato con un numero in base alla posizione che occupa, 0123..., per selezionarlo quindi: char primoCarattere = carattere.charAt(0), vove primo carattere è la posizione che voglio evidenziare e carattere è il nome del contenitore di base.

Nomi delle variabili: può contenere lettere, numeri e “_”; deve iniziare con una lettera, e non può essere una parola riservata del linguaggio (es: class). Inoltre, non può contenere spazi. In Java le lettere maiuscole sono diverse dalle minuscole: la variabile “ferrari” è diversa dalla variabile “FERRARI”. Si deve dare nomi sensati alle variabili o si crea confusione. Non si possono usare i numeri come variabili, ne che inizi con un numero. Scorciatoia tastiera: variabile poi control + spazio. (Utile per importare librerie, e poi Netbeans fa da solo)

Camel Case: le parole si scrivono unite e si separano mettendo l’iniziale maiuscola (es: InizialeMaiuscola). Per convenzione, nel linguaggio Java:

le variabili ed i metodi iniziano con una lettera minuscola
i nomi delle classi iniziano con una lettera maiuscola

Assegnazione: Cambia il valore che ho in memoria. Per assegnare un valore, si usa il simbolo “=”. Quello che sta dopo il simbolo “=” può essere un nuovo valore, oppure il risultato di un’operazione; in certi casi, si può utilizzare il valore stesso della variabile: prezzo = prezzo + 1; viene letto da Java come “prendi il valore originale di prezzo, aggiungici 1 e scrivi il nuovo valore nella variabile prezzo).

ATTENZIONE: il simbolo “=” in Java non serve per vedere se due valori sono uguali, ma solo per assegnare valori ad una variabile. Il controllo dell’uguaglianza si fa in modo diverso, vedremo più in là.

Copiare valori: scrivendo a = b il valore della variabile b viene copiato in a. Le due variabili seguono poi una vita autonoma (se modifico a, non modifico b).

Tipi di Variabili

Le variabili possono contenere due tipi di valori: primitivi ed oggetti; per ora ci concentriamo sui primitivi. Tipi Primitivi: ce ne sono 8

byte 8 bit che rappresentano un numero intero in complemento a 2 → -128...+127
short 16 bit in complemento a 2 → -32.768...+32.767
int 32 bit in complemento a 2 → -2.147.483.648...+2.147.483.647
long 64 bit in complemento a 2: -9.223.372.036.854.775.808... 9.223.372.036.854.775.807
float 32 bit in floating point (numeri positivi e negativi, con decimali)
double 64 bit: floating point con precisione doppia (ricordo i problemi: 2.15 - 1.10 = ...) - double decimali = 2.30; (Se in una divisione non la uso java tronca il risultato, non arrotonda niente. Anche i numeri che devono essere divisi devono essere espressi in double oppure int/double =double o viceversa, quindi basta che uno dei due sia un double. Oppure si può convertire come A/2.0 oppure (A+0.0)/2 che è sono double o tramite casting)
boolean 1 bit circa: contiene solo l’informazione vero o falso
char: carattere Unicode a 16 bit (quindi dal carattere 0 al carattere 65.535). Un carattere si scrive con la virgoletta singola e non doppia. char carattere = 'C';

PER IMMAGINI: 100pixel, Rosso, Verde e Blu, cioè 100x100=30000 valori da salvare--> sistema long 64bit cioè 240000bit occupati oppure utilizzo più byte e risparmio spazio.

Valori di Default: non è necessario assegnare sempre un valore iniziale alla variabile, perché ne hanno uno di default: 0 per i numeri ed i caratteri, falso per i booleani. ATTENZIONE: le variabili definite nei metodi e non nelle classi non sono inizializzate. Una buona regola è inizializzarle sempre.

Copiare variabili: Quando si copia la variabile a in un altra b le due poi vivono di vita propria e quindi diventano indipendenti. Se in una variabile per un numero copio un carattere esso verrà trasformato secondo la tabella Unicode, java non usa UTF-8, ma i dati che salva nel pc si.

Promozione: in una variabile primitiva posso inserire il contenuto di un’altra primitiva, se di dimensioni minori e di tipo compatibile. Es: in una variabile int posso mettere il contenuto di una variabile byte; in una variabile double il contenuto di una float o di un int.

Casting: si usa per convertire un tipo di variabile verso un’altra, anche a capacità minore, se non va a buon fine, il risultato è spazzatura. Per forzare java si antepone alla variabile grande tra parentesi la dimensione della nuova variabile, tuttavia se è troppo piccola da come risultato zero (si perdono dei valori e non vengono fuori avvisi).

Aritmetica base: gli operatori sono quelli usati comunemente nelle espressioni: + (somma), - (sottrazione), * (moltiplicazione), / (divisione) e % (modulo o resto). Moltiplicazione e Divisione hanno la precedenza su Addizione e Sottrazione, le sotto-espressioni si indicano con parentesi tonde.

Modulo: Resto di A % B -->11%2=1

Costanti: sono variabili a cui viene assegnato un valore in sede di definizione, e non può più essere cambiato, per definirle, si scrive final davanti al tipo della variabile. Per convenzione: le costanti sono scritte tutte in maiuscolo, usando “_” per separare le parole.

Es: final double CM_PER_INCH = 2.54; long s= 1000*1000*1000; int q = (int) s;

La variabile funziona all'interno delle graffe e nei vari sotto blocchi, se si esce dalle graffe la variabile muore, non funziona più.

VERO O FALSO?

Logica booleana

Le operazioni booleane possono avere solo due risultati: vero (true) o falso (false). Tutte le operazioni che vedremo finora si applicano solo ai tipi primitivi.

Uguaglianza: per verificare se due valori (o variabili) sono uguali, si usa il comando “==”. Es: 13==13 restituirà true; 13 == 10 restituirà false.

Diversità: per verificare se due valori (o variabili) sono diversi, si usa il comando “!=”. Es: 13 != 13 restituirà false; 13 != 10 restituirà true.

Maggiore e minore: si usano i simboli <, > e = combinati:

> : maggiore di (es: 10 > 13 restituisce false)
< : minore di (es: 10 < 13 restituisce true)
>= : maggiore o uguale (es: 10 >= 10 restituisce true)
<= : minore o uguale (es: 10 <= 10 restituisce true)

Negazione: posso invertire il risultato usando il comando “!”. Es: !true restituisce false.

AND: è un’operazione booleana che restituisce true solo se tutti gli operandi sono true; in java si rappresenta con il comando “&&”. Es:

true && true → true;
(13==13)&&(10==10) → true && true → true;
(13==10)&&(10==10) → false && true → false;
(13==13)&&(10==10)&&(13==10) → true && true && false → false;

OR: è un’operazione booleana che restituisce true se almeno uno degli operandi è true; in java si rappresenta con il comando “||” (due simboli pipe, ovvero shift+simbolo di barra a sinistra della tastiera). Es:

true || true → true;
false || false || true → true;
false || false || false → false;
(13==13)||(10==10) → true || true → true;
(13==10)||(10==10) → false || true → true;
(13==13)||(10==10)||(13==10) → true || true || false → true;
(13!=13)||(10==13)||(13==12) → false || false || false → false;

Variabili booleane: i valori booleani ed i risultati delle operazioni booleane possono essere salvati in variabili del tipo primitivo boolean.

Uguaglianza di stringhe: non posso usare ==; per vedere se la stringa s1 è uguale alla stringa s2 devo usare il comando A.equals(B)

Uguaglianza tra numeri in virgola mobile: molti numeri razionali in base 10 non sono rappresentabili in base 2 perché diventano periodici.

Es: 2.15 - 1.10 == 1.05? Se lo chiediamo al calcolatore, risponderà di no. La soluzione è quella di verificare se i due valori double da confrontare sono vicini: decidiamo che A == B se |A-B|<ε con ε fissato a priori (es: 0.00001).

CONDIZIONI O SELEZIONE

scegliere cosa fare in base al risultato di un’operazione booleana. Le graffe possono non essere necessarie se si scrive solo una riga, ma non si fa mai. Posso anche combinare questi blocchi e poi quando arriva alla prima vera il codice si blocca e non continua.

IF-THEN: il comando per definire una sequenza di condizioni è “IF-THEN”

IF-THEN-ELSE: posso anche dire che cosa deve fare il programma se l’espressione ritorna, oltre che vera, false

CICLI

While: permette di ripetere una sequenza di operazioni finché la condizione resta vera.

se la condizione è vera, esegui le istruzioni
quando le hai eseguite tutte, torna alla riga del while e ricontrolla la condizione:
se è ancora vera, esegui nuovamente / se non è più vera, non eseguirla più

Ciclo infinito: se la condizione è sempre vera, il ciclo verrà ripetuto all’infinito. Questo può accadere volutamente (es: antivirus che per sempre controlla i file scaricati da Internet) oppure per errore nello scrivere la condizione.

Break: istruzione che esce da un ciclo. In genere si usa in un if. Il comando esce dal ciclo non dal programma. Si può realizzare un contatore. Senza scrivere variabile=variabile +1; si può usare variabile++ . Deriva dal linguaggio c.

Ripetere il ciclo è scomodo, se metto un numero falso il ciclo non viene eseguito. La prima verifica deve essere eseguita in questo caso e quindi sprechiamo tempo.

Do: simile al while, ma la condizione viene verificata DOPO aver eseguito le istruzioni almeno una volta. Con questo codice si dice a Java:

esegui queste istruzioni
se la condizione è vera, eseguile nuovamente

For: permette di scrivere lo stesso codice del while in modo molto più sintetico, utile quando la condizione richiede la verifica di un contatore. Con questo codice si dice Java:

1. assegna il valoreIniziale alla variabileContatore

2. controlla la condizione: se è vera, esegui queste istruzioni

3. dopo aver eseguito le istruzioni, modifica il valore della variabileContatore come specificato in modificaValore

4. ritorna al punto

Le variabili definite all'interno del ciclo for non valgono fuori da esso, come con if. Però posso definirlo prima e così rimane.

ARITMETICA

Operatori: usati comunemente nelle espressioni: +, - , * , / e % (resto).

Divisioni tra interi: viene calcolato il quoziente, scartando il resto. Es: 7 / 4 = 1 (resto 3). Per fare le operazioni ed ottenere numeri razionali, almeno un operando deve essere un numero razionale, double. Es: 7 / 4.0 = 1.75

Combinare assegnazione ed aritmetica: per compattare l’istruzione a = a +b si usa il comando “+=”. Es: a += b. Una cosa analoga si può fare anche per sottrazione (-=), moltiplicazione (*=) e divisione (/=).

Incrementare una variabile: per incrementare di 1 il valore di una variabile si può scrivere a=a+1, oppure a += 1 o scrivere a++. Analogamente per decrementarla di 1: a--. Se volgiamo prima incrementare e poi usare la variabile allora ++a.

Formattazione: è possibile formattare il testo usando il comando System.out.format().

Il primo parametro contiene del testo normale assieme a dei caratteri di controllo, ed i parametri successivi (1 o più) gli elementi da inserire nel testo. I caratteri di controllo sono così costruiti: %[opzioni][numeroCifre][tipoDato]

Il comando % serve ad inserire una celletta dove posso inserire il valore (per stampare “%”, basta scrivere “%%”). Se più valori li si scrive in ordine e separati da una virgola.

tipoDato: s per le stringhe, f per i numeri razionali (arrotonda e non tronca), d per i numeri interi. Ma può essere usato anche per date e cose più complicate.
opzioni: sono alcuni caratteri che permettono di modificare altri dettagli, es:

+: fa stampare sempre il segno, anche se il numero è positivo
0: aggiungere 0 all’inizio fino al raggiungimento del numero di cifre richiesto per la parte intera
, : inserisci i separatori di migliaia (Nel sistema italiano apparirà un punto)

numeroCifre:

numeroDecimali: si usa con numeri razionali, indica quante cifre decimali si vogliono avere, si usa il punto (es .2 per avere due decimali)
numeroParteIntera: usato per gli interi (es: per inserire degli 0 davanti al numero)
numeroParteIntera.numeroDecimali: per casi più complicati (es: incolonnare i numeri \t a sinistra o per destra y.x= y caratteri per far vedere il punto e usa x decimali es: 6.2 lascia sei spazi e il numero avrà due cifre decimali)

LIBRERIA MATH

Pensata per operazioni più complesse ed è già inclusa in java.

abs(valore): valore assoluto ( non serve per esempio usare un if)
round(valore): arrotonda un numero decimale ad intero
ceil(valore): Per arrotondare, intero più grande e più vicino al valore
floor(valore): Per arrotondare, numero intero più piccolo e più vicino al valore
cos(valore), sin(valore), : coseno, seno, tangente, arcsin ... (valore in radianti)
pow(a, b): potenza, restituisce a^b
log(a): logaritmo in base 10 o e
sqrt(a): radice quadrata di a
min(a,b): valore minimo tra a e b
max(a,b): valore massimo tra a e b

STRINGHE

Le stringhe sono gestite in modo molto strano da Java; sono degli oggetti, ma di solito vengono definiti in modo molto semplice, come se fossero una normale variabile. Questo perché le stringhe si usano spessissimo, e chi ha scritto il linguaggio Java voleva aiutare gli sviluppatori. es: String primaStringa = “Ciao Mondo”;

Concatenazione di Stringhe: più stringhe possono essere unite usando il segno “+”. Es: String pippo = “ciao” + “ come va?”;

Metodi: le stringhe sono oggetti, e quindi al loro interno hanno dei metodi. Quelli più usati sono:

toLowerCase() e toUpperCase(): converte tutto in maiuscole e minuscole
length(): lunghezza della stringa
s1.equals(s2): Prima controlla se hanno la stessa lunghezza e poi confronta ogni singolo carattere se è uguale tra le due stringhe.
charAt(int posizione): carattere presente nella posizione data (si inizia a contare da 0).
indexOf(testoDaCercare): restituisce la prima posizione di “testoDaCercare” (Se non lo trova scrive -1)
substring(int fromIndex): restituisce quello che c’è a partire dall’elemento fromIndex (compreso) in poi. Si inizia a contare da 0. Es: "unhappy".substring(2) ritorna "happy"
s1.startsWith("lettereDaCercare"): restituisce vero se la parola selezionata inizia con le lettere scirtte.
replace(testoDaCercare, testoDaCambiare): cerca il testo richiesto nella stringa e lo cambia con quello desiderato. Attenzione: cambia tutte le occorrenze del testo. Es: “ciaa, come va?”.replace(“a”, “$”) → ci$$, come v$
stringa1.compareTo(altraStringa): ritorna un valore numerico pari a

0 → le due stringhe sono uguali;
negativo → l’altra stringa viene dopo nel dizionario rispetto a quella da cui la funzione è richiamata; Es: “a”.compareTo(“b”) → -1
Positivo → l’altra stringa viene prima nel dizionario rispetto a quella da cui la funzione è richiamata; Es: “b”.compareTo(“a”) → 1

ARRAY

Non va bene, dovrei far inserire all'utente i vari dati Troppo lungo da fare

Non funziona, non può capire

cosa sia votoi

Adesso la variabile voto non esiste, l'unica soluzione è scrivere a mano come sommare tutte le

variabili

Se faccio un esame in più, o faccio meno esami-->il codice deve essere

modificato

Un array è un oggetto, una collezione, che contiene un numero predeterminato di variabili dello stesso tipo. Prenoto un'area di memoria che contiene variabili dello stesso tipo. Ogni variabile si indica da 0 a n-1.

Definizione: tipoVariabile[ ] nomeVariabile = new tipoVariabile[dimensioneArray];

tipoVariabile può essere sia un tipo primitivo come byte, int, double, float che un oggetto (es: String)
la dimensione dell’array può essere indicata anche con una variabile, ma una volta definita non può più cambiare.
Si può variare con new il tipo
Infine si inserisce la dimensione, il numero di cellette da creare

Es: int[ ] primoArra

y = new int[5];

Lunghezza Array

Dimensione a run-time: spesso non si conosce la dimensione dell’array al momento della scrittura del codice, perché è un parametro che viene definito durante l’esecuzione del programma e può cambiare ad ogni suo avvio. La dimensione viene definita durante l’esecuzione del codice. Per farlo basta definire la dimensione dell’oggetto con una variabile.

Es: chiedere la dimensione all’utente. variabile.length;

-->Visto che la dimensione dell'arrey è statica e non può variare, per incrementare posso realizzare un altro array più grande e poi copiare li i valori e poi cambiare il nome dell'etichetta.

Accesso: per accedere all’elemento in posizione “indice” si usa il comando primoArray[indice]; il primo elemento ha indice pari a 0, l’ultimo pari a dimesioneArray-1. È così possibile:

assegnare un valore, per esempio primoArray[0] = 5 assegna il valore 5 al primo elemento dell’array.
leggere un valore, per esempio int valoreSingolo = primoArray[0] copia nella variabile valoreSingolo il contenuto del primo elemento dell’array Es: definire ed inizializzare un array.

Inizializzazione: volendo in fase di definizione si possono già specificare i contenuti dell’array; per farlo, al posto di usare il comando “new” si usa la sintassi seguente:

int[ ] primoArray = {100, 200, 300, 400, 500};

String[] giorni = {“Lunedì”, “Martedì”, “Mercoledì”, “Giovedì”, “Venerdì”, “Sabato”, “Domenica”}

Lunghezza: per sapere la lunghezza dell’array si accede al valore “length” che sta al suo interno. Es: primoArray.length;

È una variabile, non un metodo (caso delle stringhe); me ne accorgo perché non ci sono le parentesi tonde.

Attenzione: è una variabile speciale; non può essere modificata. Se scrivo arr.length = 10 riceverò un messaggio di errore.

Stinga vuota e stringa null()

Cicli ed array: possiamo usare i cicli per accedere agli elementi di un array; quasi sempre saranno dei cicli FOR. Es:

int dimensione = LibreriaFondamenti.leggiIntero();

int[] primoArray = new int[dimensione];

int[] primoArray = new int[5];

primoArray[0] = 100;

primoArray[1] = 200;

primoArray[2] = 300;

primoArray[3] = 400;

primoArray[4] = 500;

System.out.println("Valore 0: " + primoArray[0]);

System.out.println("Valore 1: " + primoArray[1]);

System.out.println("Valore 2: " + primoArray[2]);

System.out.println("Valore 3: " + primoArray[3]);

System.out.println("Valore 4: " + primoArray[4]);

for (int i = 0; i < primoArray.length; i++) {

System.out.println("Valore "+ i +": "+primoArray[i]);

}

Cicli compatti: poiché il codice viene scritto spessissimo, esiste anche una scrittura più compatta: L’unico svantaggio è che non si ha la variabile contatore. Solo per leggere i valori, non per cambiarli.

Per stampare valori array, in

genere si usa un ciclo

Copio la variabile in un punto temporaneo e po

i verrà cancellato

Cicli normale e compatto

Array multidirezionale: gli array possono essere anche multidimensionali.

Per definire un array bidimensionale, si usa la sintassi: int[ ][ ] bidimensionale = new int[numeroRighe][numeroColonne]. Un array bidimensionale è un array di array, per noi una tabella, per il pc no, salva valori in memoria in modo continuo e separati. (immagine biaco-nero array bidimensionale, immagine a colori RGB array tridimensionale)

Es voti dei sei esami, 3 per anno

Analogo al precedente

Punto di rottura: attraverso gli array si possono tagliare le stringhe, si inseriscono dei punti di interruzione. Comando .split

ERRORI e DEBUG

Nelle navi militari, inizialmente si attribuivano gli errori ai problemi causati dalle mosche che entravano a bordo. Tuttavia, con il progresso tecnologico, si è compreso che la complessità delle operazioni richiedeva un costante aggiornamento dei software di controllo.

Durante un periodo di aggiornamenti, si verificarono fenomeni di panico in cui molte persone ritiravano i loro soldi dalle banche, generando difficoltà nel valutare correttamente i conti finanziari. Questa situazione evidenziò l'importanza di una comunicazione chiara e di una gestione efficiente delle informazioni durante i processi di aggiornamento. Nel 2038, si presentarono ulteriori sfide legate al problema del Tempo in Unix e alla rappresentazione a 32 bit in complemento a 2. Non solo i sistemi operativi DOS necessitavano di aggiornamenti, ma anche i satelliti GPS, il cui corretto funzionamento è fondamentale per molteplici settori, potevano subire conseguenze significative.

Risolvere questi problemi diventò essenziale per evitare danni potenziali. L'industria dovette collaborare per sviluppare soluzioni tempestive e mitigare i rischi associati a errori e bug nei sistemi critici. La lezione imparata fu quella di investire nella ricerca continua e nella manutenzione preventiva per garantire la stabilità e l'affidabilità dei sistemi tecnologici fondamentali per la società.

I russinel 1983 rilevarono un lancio da parte degli USA, ma si pensò ad un errore, altrimenti si sarebbe stata una guerra nucleare, il sistema satellitare russo ha scambiato i raggi solari, per missili. Poi era poco probabile che i statunitensi avessero lanciato un attacco nucleare con sole 5 testate, e le indagini successivamente rivelarono che si trattava di un errore nei dati del sistema satellitare russo. Si scoprì che il software utilizzato per interpretare le informazioni provenienti dai satelliti aveva erroneamente scambiato i riflessi dei raggi solari con un possibile lancio di missili.

Fortunatamente, prima che si potessero scatenare reazioni irreversibili, furono attivati i protocolli di verifica e comunicazione tra le nazioni coinvolte. In un clima di tensione internazionale, le parti interessate collaborarono per risolvere il problema e migliorare i protocolli di sicurezza.

Operatore inserisce uno zero al denominatore in una divisione

Non hanno usato le parentesi graffe e un codice si verificava in continuo. Bastava formattare per accorgersi dell'errore

Errori di programmazione

Errori di Sintassi: vengono trovati dal compilatore (es: System.aut.println); il compilatore dice la riga in cui si trova l’errore. In genere evidenziati in rosso e con segni d'errore.

Errori di RunTime: avvengono durante l’esecuzione del programma (es: cerco di accedere ad un file che non esiste). Quando capitano, viene generata una Eccezione, cioè un messaggio di errore che può essere letto ed interpretato via codice, inoltre indica la riga. TRY-CATCH se non gestite dal codice le eccezioni bloccano l’esecuzione del programma.

Errori logici: non vengono individuati dal compilatore (Es: “Hell, world”) e non generano messaggi di avviso, o non scrivo == invece di =.

Debugging: cercare gli errori. Inserisco il codice e vedo cosa succede. Aggiungo un print che stampa a schermo cosa succede, o eseguo passo-passo o fermo ad un punto.

Debug: è possibile eseguire il programma un pezzetto alla volta, così ogni volta che ci si ferma, si possono leggere i valori che hanno le variabili.

Breakpoint: permette di eseguire il programma fino al punto specificato, per quando non si vuole eseguire tutto il programma passo per passo, ma andare direttamente al punto problematico. Basta cliccare sul numero della riga.

FILE

Per realizzare un file su java:

String nomeFile;
String contnuto;
LibreriaFondamenti.scriviStringaSuFile (nomeFile, contenuto);

Per capire dove è stato salvato basta andare nella cartella principale del progetto.

Per leggerlo si usa:

String letto = LibreriaFondamenti.caricaiStringaDalFile (nomeFile);

Andando in file--> new-->other-->empity file

I messaggi in rosso vengono visualizzati a caso, quando il calcolatore ha tempo

METODI

sono le operazioni che un oggetto può compiere:

permettono di richiamare più volte lo stesso codice, senza riscriverlo
permettono ai vari oggetti di comunicare tra loro
nascondono i dettagli di implementazione del codice all’utente-programmatore
le variabili definite all’interno di un metodo sono visibili solo all’interno di esso

Il metodo deve essere scritto all'interno delle prime graffe ed è indipendente se è prima o dopo di public static void main…. In genere alla fine e in modo ordinato. Si richiama il codice con nomeMetodo()=...

Un metodo può richiamare un altro metodo.

PUBLIC STATIC VOID nomeMetodo () {

codice

}

Sintassi: per definire un metodo è:

visibilità: chi può accedere al metodo (es: public, private) e quando. Per capire come funziona questo punto occorre conoscere gli oggetti.
tipoDatoRitornato: se il metodo ritorna un valore, qui si specifica il tipo, mentre se il metodo non ritorna un valore, bisogna scrive void
nomeMetodo: nome del metodo (come per le variabili)
tipoParametro1 nomeParametro1, tipoParametro2 nome parametro2...: zero o più parametri. Se il metodo non richiede parametri, le parentesi tonde vanno messe comunque

Restituire valori: si usa il comando return seguito dal valore da restituire. Quando in un punto del codice si scrive “ return valore; ”, si esce, si interrompe, dal metodo (eventuale altro codice scritto sotto non viene eseguito).Se il metodo è void (cioè non ritorna valori), si può usare il comando return; per uscire immediatamente dal metodo. Es: public static int nomeMetodo () oppure public static string nomeMetodo ()

Parametri dei metodi: vengono passati copiandoli nelle variabili dei metodi (“=”); quindi i valori originali non vengono modificati. Questa è una approssimazione, passando agli oggetti la cosa è un po’ diversa.

Firma del metodo: la firma del metodo è data da: <nomeMetodo, tipo parametro 1, tipo parametro 2, ... ecc.>Quindi in una classe si può avere due metodi con lo stesso nome, ma è necessario che i tipi dei parametri richiesti siano diversi. Nel considerare se due metodi sono uguali o no, vengono ignorati i nomi dei parametri e il tipo di dato ritornato.

OGGETTI

Classe: schema con cui si generano gli oggetti, cioè un manuale di istruzioni che spiegano a java come fare. Le classi possono essere scritte da noi, oppure prese da altre sorgenti (librerie).Per crearla su NetBeans si va a sinistra e tasto destro--> new java class

Oggetti: istanze della classe. Es:

Classe: Studenti; Oggetto: Pippo, Oggetto: Paperino
Classe: Edificio (rappresenta l'idea dell'edificio); Oggetto: Tutankamon, Oggetto: H3
Classe: Strada; Oggetto: Via Fabio Severo, Oggetto: Via Monte Valerio

Contenuto classi: una classe contiene dati (o proprietà o campi) e metodi (o funzioni o procedure).

Dati: possono essere tipi primitivi (numero di piani dell’edificio, int) oppure altri oggetti (es: aule presenti nell’edificio)

Metodi: operazioni che l’oggetto può compiere (es: calcola quante persone possono stare in tutte le aule dell’edificio, stampa a video la pianta dell’edificio…). In generale, le classi ed i dati sono di solito i NOMI nella descrizione di un problema (aula, edificio, piano, posti nell’aula) mentre i metodi sono i VERBI (calcola somma posti, stampa edificio…).

Definire una classe: la classe deve avere lo stesso nome del file che la contiene. Tecnicamente ogni file potrebbe avere più classi, ma solo una può essere visibile all’esterno.

Dati: bisogna scrivere il tipo della variabile ed il suo nome all’interno della classe; anche se il linguaggio permette di farne a meno, è bene specificare sempre la visibilità (v. sotto) di ogni dato inserito nella classe.

Visibilità: lo scopo delle classi è nascondere all’utente-programmatore i dettagli dell’implementazione. Per ogni dato e metodo di una classe occorre specificare chi potrà accedervi e ci sono tre opzioni da scrivere davanti a int, Sting…:

public: chiunque può accedervi e usarlo
protected: solo altri oggetti della stessa famiglia (pacchetto, package) potranno accedervi
private: può essere usato solo da questo oggetto (non da altre istanze della stessa classe, proprio solo dall’oggetto corrente)

Creare un oggetto: in gergo “istanziare un oggetto” e lo si fa come per gli array: si usa il comando new seguito dal nome della classe e da una coppia di parentesi tonde.

Import: a volte vogliamo usare delle classi che si trovano in pacchetti diversi da quello corrente; per farlo bisogna usare il comando import all’inizio del codice (prima della definizione della classe), seguito dal nome del pacchetto. Quando la classe che si vuole importare esiste in un solo pacchetto, Netbeans aggiunge automaticamente l’import del pacchetto. Es: import it.units.LibreriaFondamenti;

Richiamare metodi nella classe: un metodo può richiamare facilmente un altro metodo della stessa classe; basta scrivere il nome del metodo seguito dagli eventuali parametri tra parentesi (che ricordo vanno sempre messe, anche se non ci sono parametri)

Vita delle variabili: una variabile definita come dato di una classe è sempre accessibile da tutti i metodi della stessa classe; una variabile definita all’interno di una sequenza vive solo al suo interno, ed è accessibile solo dalla sequenza stessa e dalle altre sequenze contenute in essa. Le sequenze sono racchiuse dalle famose coppie di parentesi graffe.

Valori iniziali

Valore iniziale tipi primitivi: le variabili di tipo primitivo definite come dati (campi, proprietà) di una classe hanno un valore predefinito (0 e false per le booleane). Il problema è che questo non accade per le variabili definite nei metodi: lì bisogna specificare un valore iniziale, oppure il codice non è compilabile.

È buona norma stabilire sempre il valore iniziale, anche se la variabile viene definita come campo di una classe.

Valore iniziale oggetti e null: un oggetto definito e non inizializzato con il comando new avrà il valore speciale null; fino a quando l’oggetto non sarà creato non sarà possibile accedere ai suoi campi e metodi. Per vedere se un oggetto è null, posso usare il comando “nomeOggetto == null” in un IF.

La stessa cosa si applica alle stringhe; è importante capire che c’è una differenza tra la stringa vuota (“”) e la stringa non inizializzata (null). Es: il boss deve decidere chi uccidere, il nome sta in una stringa. Stringa nulla: non ho ancora chiesto al boss; stringa vuota: ho chiesto, ed il boss non ha fatto nomi; stringa con un valore: sfortunato che verrà ucciso.

Elementi Statici

Sono dati e metodi che possono essere richiamati direttamente dalla classe, senza istanziare l’oggetto; sono definiti dal comando static. Il linguaggio permette di richiamarli anche dagli oggetti (quindi dalle istanze della classe), ma è una cosa da evitare. --> public final int PIGRACO=3.14;

dati statici: variabili che possono essere richiamate senza prima aver creato l’oggetto, per Costanti. Es: la costante Math.PI è statica e richiamabile dalla classe Math senza istanziarla
metodi statici: non possono accedere né in lettura né in scrittura ai dati dell’oggetto, a meno che non siano statici anche questi. Es: il metodo Math.pow(x,y) eleva x alla y; non utilizza nel calcolo alcun valore se non quelli passati, e può pertanto essere statico.

Invece di stampare l'indirizzo stampa la stringa, si può mo

Costruttori

I costruttori sono dei metodi speciali che vengono richiamati alla creazione (istanziazione) dell’oggetto; come ogni altro metodo, i costruttori possono ricevere dei parametri in ingresso.

Differenze dai metodi: i costruttori sono definiti come i metodi, si differenziano per:

nome: il nome del costruttore deve essere esattamente uguale al nome della classe
tipo ritornato: non si deve dichiarare il tipo di dato ritornato (nemmeno con void)
return: non occorre scrivere alcun return

Costruttori impliciti: ogni classe ha sempre al suo interno un costruttore che non fa nulla, anche se non dichiarato.

Richiamare un costruttore: sappiamo già farlo; basta scrivere “new NomeClasse()”; ecco tra l’altro il motivo per cui si usano le parentesi tonde: di fatto stiamo invocando un metodo.

This: spesso nei costruttori si vogliono passare dei valori con cui inizializzare campi interni. Volendo si può usare lo stesso nome del campo: per accedere alla variabile della classe e non al parametro del costruttore basta usare il comando “this”.

RIFERIMENTI

Gli array sono oggetti ed essi sono strutture complesse, che non possono essere contenute nella memoria veloce usata da java per i tipi primitivi (detta HEAP). Quando si definisce una variabile non primitiva, nello HEAP non si scrive quindi il valore dell’oggetto, ma l’indirizzo di memoria (riferimento) alla memoria lenta, ma più grande di Java (stack). (print oggetto-->stampa nome e indirizzo oggetto dove si trova)

Il simbolo “=” copia il valore contenuto nello HEAP, quindi fa due cose diverse:

se le variabili sono tipi primitivi, copia il valore di una variabile nell’altra
se le variabili sono oggetti, copia l’indirizzo di memoria che punta allo stack e quindi crea semplicemente un altro riferimento allo stesso oggetto in memoria.

RICERCA

Ci sono tanti algoritmi per cercare informazioni all’interno di un array.

1) Ricerca esaustiva: nel caso peggiore ispeziona tutti gli elementi dell’array. L’algoritmo scandisce l’array confrontando gli elementi con quello da cercare fino a quando non trova l’elemento cercato (o fino a quando non ha vagliato tutti gli elementi nel caso in cui non sia presente). È un algoritmo a complessità lineare: se il numero di elementi raddoppia, raddoppia anche il tempo richiesto nel caso peggiore. La complessità è in funzione del numero di elementi, e si indica con O(N).

Si carica il dizionario e si stampa il numero di parole al suo interno. Poi si fa un metodo e dentro un ciclo si controllano tutte le parole e se non la trova esce -1

2) Ricerca non esaustiva: algoritmo che nel caso peggiore non ispeziona comunque tutti gli elementi dell’array. Per poter essere utilizzata, l’array deve essere ordinato.

Ricerca a balzi: è un esempio di ricerca non esaustiva su un array ordinato. Non controllo ogni elemento, ma procedo di due in due. Se sono andato oltre, torno indietro di uno (avevamo visto il comando compareTo). Anche questo è lineare, ma si dimezza il numero di tentativi massimi → O(N/2).

Contando il tempo, nel caso peggiore guadagno molto, se però, la parola è vicina allora è meno vantaggioso.

Ricerca Divide et Impera: o Dicotomica o binaria. E' un altro esempio di ricerca non esaustiva su un array ordinato. In ogni step l’algoritmo compara il valore con quello che si trova in centro all’array. Se sono uguali, il valore è stato trovato; altrimenti:

se il valore dell’array è maggiore di quello cercato, si passa ad ispezionare il lato a destra dell’array
se il valore dell’array è minore di quello cercato, si passa ad ispezionare il lato a sinistra dell’array
se la dimensione dell’array da ispezionare è 0, allora il valore non è stato trovato.

Ogni iterazione elimina metà degli elementi da cercare: la complessità è del tipo O(log N).

Il tempo viene ridotto notevolmente, soprattutto per file di grandi dimensioni. Tuttavia il codice da scrivere è più complicato. In questo caso con una parola che inizia con f il tempo guadagnato è di 10 volte.

ORDINAMENTO

Molto spesso è necessario ordinare un array (es: per poter applicare un algoritmo di ricerca astuto).

Scambiare due valori: per ordinare un array dovrò spesso invertire due valori. Per farlo devo usare una variabile temporanea in cui conservare uno dei due valori durante lo scambio.

Selection sort: molto semplice da realizzare, ma richiede molto tempo (durata deterministica e il tempo su un array disordinato è uguale a quello ordinato), ha complessità O(N^2). Sono due cicli annidati e dovendo ordinare un array A di lunghezza n:

si fa scorrere l’indice i su tutti gli elementi tranne l’ultimo
per ogni iterazione, cerco il valore più piccolo che sia minore di A[i] nella sottosequenza A[i+1..n].
Se trovato, viene invertito con l’elemento i-esimo.

Per funzionare mentre scambio due valori ne devo salvare uno in una variabile temporanea.

Non stampa niente ma modifica l'area di memoria in cui si trovano

Bubble sort: L'algoritmo Bubble Sort prende il nome dalla modalità con cui gli elementi più piccoli "affiorano" verso l'inizio dell'array, come bolle che salgono in superficie. Tuttavia, è generalmente considerato inefficiente per grandi insiemi di dati, specialmente in confronto ad algoritmi più avanzati (come Quicksort o Mergesort, sono spesso preferiti per operazioni di ordinamento su larga scala). L'efficienza dell'algoritmo è influenzata dalla sua complessità (ma molto più efficiente se l’array è già parzialmente ordinato) nel caso peggiore, che è di O(N^2). Ciò significa che, in presenza di un grande numero di elementi, il tempo richiesto per ordinare l'array cresce quadraticamente. Tale complessità deriva dal fatto che l'algoritmo confronta e scambia gli elementi ripetutamente fino a raggiungere l'ordinamento completo.

Il procedimento operativo dell'algoritmo può essere riassunto come segue:

L'array viene percorso iterativamente, confrontando ogni elemento con il successivo.
Se l'elemento corrente è maggiore di quello successivo, avviene uno scambio tra i due.
L'algoritmo continua questo processo fino a quando non vengono più effettuati scambi durante una singola iterazione, indicando che l'array è stato completamente ordinato.

Page updated

Google Sites

Report abuse