Schede

# Java Base

## Introduzione a Java
Introduzione al linguaggio ad oggetti JAVA, e
preparazione ambiente di sviluppo con jdk e IDE.

## Primi Concetti di Programmazione Object Oriented
Concetto di classe, oggetto, variabile, proprietà,
metodo, costruttore e package. Reference this per
l’utilizzo nei metodi con i parametri. Implementazione
dei metodi accessor e mutator.

## Tipi di Dati e Casting
Tipi di dati primitivi e reference. Concetti di cast e
promotion.

## Iterazioni e strutture di controllo
Implementazione di algoritmi in java utilizzando
assegnazioni, cicli, condizioni.

## Enumerazioni, Array e String
Altre tipologie di dati: enumerazioni, Array,
ArrayList, String e StringBuilder

## Programmazione avanzata Object Oriented
Analisi e Test dei tre principi fondamentali della
Programmazione ad Oggetti: incapsulamento,
ereditarietà e polimorfismo. Reference super.

## Modificatori Java
Spiegazione dettagliata dei modificatori public, private,
protected, default, final e static.

## Classi Astratte ed Interfacce
Implementazione ed utilizzo di classi astratte ed
interfacce.

## Modellazione UML OO
Descrizione dei CLASS DIAGRAM utili nella
progettazione del software.

## . Gestione delle Eccezioni
Eccezioni, errori ed asserzioni. Utilizzo del
blocco try – catch – finally e metodo di
propagazione delle eccezioni.


I principali componenti della libreria Swing.


Certificazione Oracle OCA Oracle Certified
Associate, Java SE ## Programmer
Esame ## ## ## 3
Le classi in Java


concetti che sono alla base di un programma Java:
classe
Nel mondo reale, una classe indicherebbe un concetto, un'idea, un modello.
oggetto
Un oggetto è un'istanza (cioè una creazione fisica) di una classe.

Una classe può contenere (dichiarare) un numero variabile di
attributi
metodi
costruttori
package
altri oggetti

Una classe è il modello astratto da cui creare oggetti.
Una classe si limita a definire la struttura che avranno gli oggetti creati
a partire da essa stessa.
Una classe è la rappresentazione generale di una certa
tipologia di oggetti ed è usata, al momento dell'esecuzione del programma, per
realizzare istanze della classe stessa: gli oggetti.

DICHIARAZIONE CLASSE In Java una classe viene dichiarata in questo modo.

public class NomeClasse { // dichiarazione variabili // dichiarazione metodi }


Il corpo della classe (tra parentesi graffe) contiene tutto il codice che
determina il ciclo di vita degli oggetti creati dalla classe stessa:

costruttori,
dichiarazioni delle variabili
dichiarazioni dei metodi.

In un approccio object oriented, una classe dovrebbe limitarsi a definire
la struttura comune di un insieme di oggetti e non dovrebbe mai possedere
né variabili né metodi.

DICHIARAZIONE E CREAZIONE OGGETTO
La creazione di un oggetto può avvenire in modi diversi.

Si può dichiarare e istanziare un oggetto in diverse righe di codice

NomeClasse NomeOggetto;
NomeOggetto = new NomeClasse();

Oppure accorpando dichiarazione e creazione nella stessa riga di codice.

NomeClasse NomeOggetto = new NomeClasse();

Solo dopo l'istanziazione (la creazione) dell'oggetto è possibile utilizzarlo.
I membri della classe Object.
--------------------------------------
Costruttori pubblici:
Object()
--------------------------------------
Metodi protetti:
Object clone()
void finalize()
--------------------------------------
Metodi pubblici:
boolean equals(Object obj)
final Class getClass()
int hashCode()
final void notify()
final void notifyAll()
String toString()
final void wait()
final void wait(int millis)
final void wait(int millis, int nanos)
I membri della classe System.
----------------------------------------------------------------------------
Costanti pubbliche statiche:
java.io.PrintStream err
java.io.InputStream in
java.io.PrintStream out
----------------------------------------------------------------------------
Metodi pubblici statici:
void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
long currentTimeMillis()
void exit(int status)
void gc()
java.util.Properties getProperties()
String getProperty(String key)
String getProperty(String key, String default) SecurityManager
getSecurityManager()
void runFinalization()
void setErr(java.io.PrintStream err)
void setIn(java.io.InputStream in)
void setOut(java.io.PrintStream out)
void setProperties(java.util.Properties properties) String
setProperty(String key, String value)
void setSecurityManager(SecurityManager s)
I membri della classe Math.
--------------------------------------
Costanti pubbliche statiche:
double E
double PI
--------------------------------------
Metodi pubblici statici:
double abs(double a)
float abs(float a)
int abs(int a)
long abs(long a)
double acos(double a)
double asin(double a)
double atan(double a)
double atan2(double y, double x)
double ceil(double a)
double cos(double a)
double exp(double a)
double floor(double a)
double log(double a)
double max(double a, double b)
float max(float a, float b)
int max(int a, int b)
long max(long a, long b)
double min(double a, double b)
float min(float a, float b)
int min(int a, int b)
long min(long a, long b)
double pow(double a, double b)
double random()
double rint(double a)
long round(double a)
int round(float a)
double sin(double a)
double sqrt(double a)
double tan(double a)
double toDegrees(double angrad)
double toRadians(double angdeg)
I membri della classe Random.
--------------------------------------------------------------
Costruttori pubblici:
Random() Costruisce un nuovo generatore
di numeri pseudo-casuali,
usando la data e l'ora
correnti come seme.
Random(int seed) Costruisce un nuovo generatore
di numeri pseudo-casuali,
usando il seme specificato.
--------------------------------------------------------------
Metodi pubblici:
boolean nextBoolean() Restituisce il boolean
successivo nella sequenza
pseudo-casuale.
void nextBytes(bytes[] b) Registra sull'argomento
fornito una sequenza di
b.length numeri
pseudo-casuali, in formato
byte.
double nextDouble() Restituisce il double
successivo nella sequenza
pseudo-casuale, compreso tra 0
(incluso) ed 1 (escluso).
float nextFloat() Restituisce il float
successivo nella sequenza
pseudo-casuale, compreso tra 0
(incluso) ed 1 (escluso).
double nextGaussian() Restituisce il double
gaussiano successivo nella
sequenza pseudo-casuale,
compreso tra 0 (incluso) ed 1
(escluso).
int nextInt() Restituisce l'int successivo
nella sequenza pseudo-casuale.
int nextInt(int n) Restituisce l'int successivo
nella sequenza pseudo-casuale,
compreso tra 0 (incluso) ed n
(escluso).
long nextLong() Restituisce il long successivo
nella sequenza pseudo-casuale.
void setSeed(long seed) Reimposta il seme della
sequenza.
I membri della classe ArrayList.
--------------------------------------------------------------
Costruttori pubblici:
ArrayList() Costruisce una lista di tipo
ArrayList inizialmente vuota.
--------------------------------------------------------------
Metodi pubblici:
void add(int i, Object o) Aggiunge l'oggetto o alla
lista, disponendolo alla
posizione i. Se la posizione
è già occupata, l'elemento
corrispondente e tutti i suoi
successivi verranno avanzati
di un posto.
boolean add(Object o) Aggiunge l'oggetto o in coda
alla lista.
void clear() Ripulisce la lista, eliminando
tutti i suoi elementi.
Object clone() Clona l'oggetto. ArrayList
implementa l'interfaccia
cloneable.
boolean contains(Object o) Restituisce true se la lista
contiene l'oggetto o.
boolean equals(Object o) Restituisce true se o è una
lista dal contenuto identico
all'oggetto di invocazione.
Object get(int i) Restituisce l'elemento alla
posizione i.
int indexOf(Object o) Restituisce l'indice
dell'elemento o, o -1 se
l'elemento non compare nella
lista.
boolean isEmpty() Restituisce true se la lista
è vuota.
Object remove(int i) Individua l'elemento alla
posizione i, lo rimuove dalla
lista e lo restituisce al
codice chiamante. Tutti gli
elementi successivi saranno
arretrati di una posizione.
Object set(int i, Object o) Sostituisce con o l'elemento
alla posizione i. Restituisce
l'elemento rimpiazzato.
int size() Restituisce il numero di
elementi nella lista.
Object[] toArray() Converte la lista in un
array.
I membri resi disponibili dalla classe Date.
--------------------------------------------------------------
Costruttori pubblici:
Date() Costruisce un oggetto Date che incapsula la data
e l'ora correnti.
Date(long t) Costruisce un oggetto Date che
incapsula la data e l'ora
espressi dall'argomento t.
L'argomento è un long che
riporta i millisecondi
trascorsi dal 1 Gennaio 1970
sino alla data rappresentata.
--------------------------------------------------------------
Metodi pubblici:
boolean after(Date d) Restituisce true se la data di
invocazione è successiva alla
data d.
boolean before(Date d) Restituisce true se la data di
invocazione è precedente alla
data d.
Object clone() Clona l'oggetto. Date
implementa l'interfaccia
Cloneable.
int compareTo(Date d) Compara la data di invocazione
con d. Restituisce 0 se le due
date sono uguali, un valore
negativo se la data di
invocazione precede la data d
o un valore positivo se la
data di invocazione è
successiva alla data d.
int compareTo(Object) Se l'argomento fornito è una
istanza di Date, agisce come
compareTo(Date d). In caso
contrario, propaga una
ClassCastException.
boolean equals(Object o) Restituisce true se
l'argomento è una data
equivalente a quella di
invocazione.
long getTime() Restituisce la data
dell'oggetto sotto forma di
valore long, che esprime i
millisecondi trascorsi dal 1
Gennaio 1970 sino alla data
rappresentata.
int hashCode() Calcola un codice hash per
l'oggetto.
void setTime(long t) Imposta la data rappresentata
con un argomento di tipo long,
che esprime i millisecondi
trascorsi dal 1 Gennaio 1970
sino alla data rappresentata.
String toString() Fornisce una rappresentazione
in stringa della data.
I membri pi� importanti classe GregorianCalendar.
--------------------------------------------------------------
Costruttori pubblici:
GregorianCalendar Costruisce un
GregorianCalendar che
rappresenta la data e l'ora
correnti.
GregorianCalendar(int Costruisce un
year, int month, int date) GregorianCalendar che
rappresenta la data espressa
mediante gli argomenti
forniti.
GregorianCalendar(int Costruisce un
year, int month, int date, GregorianCalendar che
int hour, int minute) rappresenta la data e l'ora
espressa mediante gli
argomenti forniti.
--------------------------------------------------------------
Metodi pubblici:
boolean after(Object o) Restutuisce true se la data
rappresentata è successiva
alla data espressa
dall'oggetto o, che deve
essere istanza di Calendar.
boolean before(Object o) Restutuisce true se la data
rappresentata è precedente
alla data espressa
dall'oggetto o, che deve
essere istanza di Calendar.
Object clone() Clona l'oggetto.
GregorianCalendar implementa
l'interfaccia Cloneable.
booleans equals(Object o) Restituisce true se
l'argomento rappresenta una
data equivalente a quella
rappresentata dall'oggetto
di invocazione.
int get(int field) Recupera il valore di uno
dei campi della data
rappresentata. L'argomento
specifica il campo di
interesse.
Date getTime() Restituisce un oggetto Date
che rappresenta la data
incapsulata dall'oggetto di
invocazione.
long getTimeInMillis() Restituisce la data
rappresentata dall'oggetto
sotto forma di valore long,
che esprime i millisecondi
trascorsi dal 1 Gennaio
1970 sino alla data
rappresentata.
int hashCode() Calcola un codice hash per
l'oggetto.
void set(int field, int value) Imposta su value il valore
del campo rappresentato
dall'intero field.
void setTime(Date d) Imposta la data rappresentata
prelevando il suo valore
all'argomento d.
void SetTimeInMillis(long l) Imposta la data rappresentata
mediante un argomento di tipo
long, che esprime i
millisecondi trascorsi dal 1
Gennaio 1970 sino alla data
rappresentata.
String toString() Fornisce una rappresentazione
in stringa della data.
rappresentata.
--------------------------------------------------------------
Costanti statiche:
AM_PM Il campo che informa se l'ora
espressa è prima o dopo
mezzogiorno.
DAY_OF_MONTH Il campo che riporta il giorno
del mese.
DAY_OF_WEEK Il campo che riporta il giorno
della settimana.
DAY_OF_YEAR Il campo che riporta il giorno
dell'anno.
HOUR Il campo che riporta l'ora del
mattino o del pomeriggio, a
seconda del contenuto del
campo AM_PM:
HOUR_OF_DAY Il campo che riporta l'ora del
giorno, in un intervallo tra
0 e 23.
MILLISECOND Il campo che riporta i
millisecondi.
MINUTE Il campo che riporta i minuti.
MONTH Il campo che riporta il mese.
SECOND Il campo che riporta i
secondi.
WEEK_OF_MONTH Il campo che riporta la
settimana del mese.
WEEK_OF_YEAR Il campo che riporta la
settimana dell'anno.
YEAR Il campo che riporta l'anno.
I membri di InputStream.
--------------------------------------------------------------
Metodi pubblici:
int available() Restituisce il numero di byte
che ancora devono essere
letti.
void close() Chiude lo stream.
void mark(int readlimit) Memorizza l'attuale posizione
dello stream, in modo che poi
sia possibile tornarci
chiamando reset(). Dopo
readlimit byte letti,
comunque, la posizione viene
dimenticata.
boolean markSupported() Restituisce true se lo stream
corrente supporta la
funzionalità offerta da
mark() e reset().
int read() Legge un byte dallo stream, e
lo restituisce come valore
int. Restituisce -1 se lo
stream ha raggiunto il
termine.
int read(byte[] b) Come read(b, 0, b.length).
int read(byte[] b, int off, Legge len byte dallo stream,
int len) salvandoli nell'array b, a
partire dalla posizione off.
Restituisce il numero di byte
effettivamente letti, o -1 se
la fine dello stream è stata
raggiunta.
void reset() Torna al punto raggiunto
nello stream l'ultima volta
che è stato chiamato mark().
long skip(long n) Avanza di n byte nello
stream, senza leggerli.
Restituisce il numero dei
byte effettivamente saltati.
I membri di OutputStream.
--------------------------------------------------------------
Metodi pubblici:
void close() Chiude lo stream.
void flush() Scrive il buffer nello stream.
void write(int b) Scrive un byte nel buffer o
nello stream.
void write(byte[] b) Scrive tutti i byte di b nel
buffer o nello stream.
void write(byte[] b, int off, Scrive len byte nel buffer o
int len) nello stream, prelevandoli
dall'array b a partire dalla
posizione off.
 In Java esistono diversi modi per leggere da standard input.

Il più generico (e più complesso) BufferedReader:

package letturatastiera;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LetturaDaTastiera {

public static void main(String[] args) throws IOException {

InputStreamReader is = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(is);

System.out.println("Inserire una stringa:");
String letta = br.readLine();

System.out.println("Stringa letta: " +letta);
}
}

Con questo codice possiamo gestire qualunque tipo di input,
non solo quello da tastiera ( File, stream di dati dalla rete, ecc, ecc...).


Metodologie più compatte e rapide per un linguaggio come Java.

-------------
Scanner:
-------------

package letturatastiera;

import java.util.Scanner;

public class LetturaScanner {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("Inserisci una stringa:");
String letta = sc.next();

System.out.println("Ho letto: " + letta);
}
}


Da notare che per leggere un altro tipo di dato, ad esempio un intero,
avremmo dovuto scrivere:

String letta = sc.nextInt();


--------------------
JOptionPane:
--------------------

package letturatastiera;

import javax.swing.JOptionPane;

public class LetturaJOptionPane {

public static void main(String[] args) {

String letta =
JOptionPane.showInputDialog("Inserisci una stringa:");
System.out.println("Ho letto: " + letta);
}
}

In questo caso avremmo potuto mostrare la stringa letta in un JOptionPane,
invece che sullo standard output, semplicemente con:

JOptionPane.showMessageDialog(null, letta);



In tutti e tre i casi possiamo convertire la stringa letta in un intero
(o altri formati), utilizzando le classi di parsing di Java:

int numeroLetto = Integer.parseInt(letta);



La classe principale per trattare date ed ore in Java è 
java.util.GregorianCalendar che estende la classe astratta java.util.Calendar
e sostituisce la ormai deprecata classe java.util.Date.

Per creare un oggetto di classe GregorianCalendar che contenga
la data e l'ora corrente, basta richiamare il costruttore senza parametri.

GregorianCalendar dataAttuale=new GregorianCalendar();

Per ottenere informazioni sull'ANNO, MESE, GIORNO e ORA si utilizza
il metodo get() passandogli come paramentro
le costanti statiche definite nella classe (YEAR, MONTH, DAY, ...)


int anno = dataAttuale.get(GregorianCalendar.YEAR);

int mese = dataAttuale.get(GregorianCalendar.MONTH) + 1; //i mesi partono da 0

int giorno = dataAttuale.get(GregorianCalendar.DATE);

int ore = dataAttuale.get(GregorianCalendar.HOUR);

int minuti = dataAttuale.get(GregorianCalendar.MINUTE);

int secondi = dataAttuale.get(GregorianCalendar.SECOND);

La classe GregorianCalendar implementa dei metodi per effettuare confronti
ed operazioni con le date.

---------------------
Confronto di due date
---------------------

GregorianCalendar data1 = new GregorianCalendar(2008, 11, 18);
GregorianCalendar data2 = new GregorianCalendar(2007, 11, 10);
if ( data1.before(data2) ) {
System.out.println("data 1 precede data 2");
} else if ( data1.after(data2) ) {
System.out.println("dati 2 precede data 1");
} else {
System.out.println("Le date sono uguali");
}

--------------------------
Somma sottrazione di Date
--------------------------

GregorianCalendar data = new GregorianCalendar(2008, 11, 18);
data.add(GregorianCalendar.DATE, +33); // Aggiungo 33 giorni
data.add(GregorianCalendar.YEAR, -1); // Tolgo 1 anno
//Come Add, ma non modifica altri campi come DAY e YEAR
data.roll(GregorianCalendar.MONTH, +1);

---------------------------------
Differenza in giorni tra due date
---------------------------------

GregorianCalendar data1 = new GregorianCalendar(2008, 11, 18);
GregorianCalendar data2 = new GregorianCalendar(2007, 11, 10);
long milliseconds1 = data1.getTimeInMillis();
long milliseconds2 = data1.getTimeInMillis();
long diff = milliseconds2 - milliseconds1;
long diffSeconds = diff / 1000; //differenza in secondi
long diffMinutes = diff / (60 * 1000); //differenza in minuti
long diffHours = diff / (60 * 60 * 1000); //differenza in ore
long diffDays = diff / (24 * 60 * 60 * 1000); //differenza in giorni

------------------
Formattazione Date
------------------

Per formattare l'output degli oggetti Calendar si può utilizzare la classe
java.text.SimpleDateFormat .

SimpleDateFormat sdf =
new SimpleDateFormat("dd/MM/yyyy - HH:mm:ss");
System.out.println( sdf.format( data.getTime() ) );

Parsing Date
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy - HH:mm:ss");
String mydata = "02/03/2008";
Calendar c = (sdf.parse(myData)).getCalendar();



-------------------------
In una pagina JSP
-------------------------

<%@page import="java.util.GregorianCalendar"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Hello World!</h1>
<% GregorianCalendar d = new GregorianCalendar();%>
<%= "Oggi è il giorno "+ d.get(GregorianCalendar.DATE) +"/"+ (d.get(GregorianCalendar.MONTH)+1) %>

<% GregorianCalendar natale = new GregorianCalendar(2017,11,25);

long msec1 = d.getTimeInMillis();
long msec2 = natale.getTimeInMillis();
long diffDays = (msec2-msec1) / (24 * 60 * 60 * 1000); //differenza in giorni
%>


<%= "Mancano "+ diffDays + " giorni a Natale" %>

</body>
</html>



-------------------------
Riferimenti Bibliografici
-------------------------
• http://java.sun.com/j2se/1.5.0/docs/api/java/util/GregorianCalendar.html
• http://java.sun.com/j2se/1.5.0/docs/api/java/text/SimpleDateFormat.html

Corso Java Base - JCF
corso-java-base-2
Corso Java Base

Java Collection Framework

snippet code

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

public class List {

public static void main (String[] args) {



//primo array

String[] moto =

{

"Moto Guzzi V35 Imola",

"Yamaha Tenerè XTZ 600",

"Yamaha XT600",

"BMW K100RS",

"BMW R1150GS" };



//stampo primo array

System.out.println("Primo array");

for (String x: moto)

System.out.println(x);



//istanzio un oggetto di tipo list

List<String> lista1 = new ArrayList<String>();



//aggiungo a lista1 gli elementi di primo array: metodo add();

for(String x: moto)

lista1.add(x);



//secondo array

String[] motoVorrei =

{ "Suzuki GSR750", "Tenerè XTZ 600", "Honda NC750X" };



//stampo primo array

System.out.println("Secondo array");

for (String z: motoVorrei)

System.out.println(z);



//nuovo oggetto di tipo list

List<String> lista2 = new ArrayList<String>();



System.out.println("Aggiungo elementi a lista 2");



//add per aggiungere elementi

for(String y: motoVorrei)

lista2.add(y);



System.out.println("Stampo elementi a lista 2 usendo il metodo size() e get()");

//get per conoscere il valore dell'i-esimo elemento, size() metodo che restituisce la dimensione dell'oggetto

for (int i = 0; i<lista2.size();i++){

System.out.printf("%s \n", lista2.get(i));

}



System.out.println("Poi aggiungo lista2 a lista1 metodo addAll");



//addAll() : metodo per aggiungere tutti i valori dell'oggetto lista2 all'oggetto lista1

lista1.addAll(lista2);

System.out.println("Stampo la nuova Lista1");



for (int i = 0; i<lista1.size();i++){

System.out.printf("%s \n", lista1.get(i));

}



System.out.println("Lista1 modificata con tutti i valori di lista2 aggiunti");



//

for (int i = 0; i<lista1.size();i++){

System.out.printf("%s %s \n", i, lista1.get(i));

}



System.out.println("Lista2 è rimasta uguale: ");

//lista2=null;

for (int i = 0; i<lista2.size();i++){

System.out.printf("%s \t", lista2.get(i));

}



//metodo editlist

editlist(lista1,lista2);

System.out.println("confronto le stringhe e le modifico col metodo editlist");

for (int i = 0; i<lista1.size();i++){

System.out.printf("%s %s \n", i, lista1.get(i));

}



}



private static void editlist(Collection<String> lista1, Collection<String> lista2) {

Iterator<String> it = lista1.iterator();

while (it.hasNext()){

if (lista2.contains(it.next()))

it.remove();

}

}

}




/** JCF: alcuni metodi collection e interfaccia Iterator */



import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;



public class ListEstesa {



public static void main(String[] args) {



// primo array

String[] moto = { "1Guzzi V35 Imola", "2Tenerè XTZ 600", "3XT600",

"4BMW K100", "5BMW R1150 GS" };

// secondo array

String[] motoVorrei = { "6Suzuki GSR750", "7Tenerè XTZ 600",

"8Honda NC750X" };



// istanzio oggetto di tipo list

List lista1 = new ArrayList();

// nuovo oggetto di tipo list

List lista2 = new ArrayList();



// aggiungo elementi del primo array a lista1: metodo add();

for (String x : moto)

lista1.add(x);



// uso add per aggiungere elementi a lista 2

for (String x : moto)

lista2.add(x);

printme(lista1);

// addAll() : metodo per aggiungere tutti i valori dell'oggetto lista2

// all'oggetto lista1

lista1.addAll(lista2);



printme(lista1);

rimuoviDaLista(lista1, 3, 5);

printme(lista1);

reverseLista(lista1);



}



// stampare i valori

private static void printme(List l) {

System.out.println("metodo printme");

for (String a : l)

System.out.printf("%s \n", a);

System.out.println();

}



// rimuovere elementi

private static void rimuoviDaLista(List l, int from, int to) {

System.out.println("metodo rimuovi");

l.subList(from, to).clear();

}



// reverse list

private static void reverseLista(List l) {

System.out.println("metodo reverse");

ListIterator lista = l.listIterator(l.size());

while (lista.hasPrevious())

System.out.printf("%s \n", lista.previous());

}



}





/** JCF: convertire list in array e viceversa */



import java.util.Arrays;

import java.util.LinkedList;

public class Main {

public static void main (String[] args) {



String[] film = { "Pulp Fiction", "Le iene", "Kill Bill" };

LinkedList<String> thelist = new LinkedList<String>(Arrays.asList(film));



thelist.add("Django Unchained");

thelist.addFirst("Jackie Brown");



//riconverti ad array

film = thelist.toArray(new String[thelist.size()]);



for (String x: film)

System.out.printf("%s \n", x);



}



}





/** JCF: collections metodi sort() e overload con reverseOrder() */



import java.util.Arrays;

import java.util.Collections;

import java.util.List;





public class Main {



public static void main (String[] args) {





String[] film = { "Pulp Fiction", "Le iene", "Kill Bill" };

List lista1 = Arrays.asList(film);



//ordina coi metodi collections

Collections.sort(lista1);



for (String x: lista1)

System.out.printf("%s \n", x);



//overload del metodo, 2 parametri

//ordina coi metodi collections

Collections.sort(lista1, Collections.reverseOrder());



for (String x: lista1)

System.out.printf("%s \n", x);

}



}



Corso Java Base
corso-java-base
Corso Java Base

Appunti del corso Java Base - Introduzione alla programmazione a oggetti
Torino, marso-maggio 2014, Pier della Francesca, Corso di formazione aziendale
Come testo principale abbiamo adottato il Manuale di Java 7, di Claudio De Sio Cesari, edito da Hoepli
Programma del corso

Argomenti

Introduzione a Java


Introduzione

Compilazione ed esecuzione

Sintassi e programmazione strutturata

variabili e metodi

tipi di dati, array

operatori di controllo flusso


Sintassi e programmazione OO


Object Oriented fondamenti

Ereditarieta, Incapsulamento, Polimorfismo

sintassi e pratica OO

Accesso database

accesso a DB via JDBC



Object Relation Mapping

Eccezioni

Classe Exception

Try e catch

Generazione di eccezioni

Creazione di nuove eccezioni




Core libraries


collezioni e iteratori

input/output

gestione delle date, numeri complessi e formattazione

networking di base


Unità didattiche


Installazione ambiente di sviluppo

Introduzione linguaggio Java

Compilazione ed esecuzione

Compilazione ed esecuzione

Sintassi java

Basi della programmazione


variabili e metodi


Operatori di assegnazione, relazionali e booleani

Operatori aritmetici

Pre/post incremento e concatenazione stringhe

Variabili locali

Metodi

Il metodo Main ed i sottoprogrammi

Metodi di classe: La parola chiave Static

Passaggio dei parametri per riferimento e per valore

Modificatori

Gestione e importazione dei package


tipi di dati, array


Scope delle variabili

Tipi di dato primitivi

Caso particolare: la classe String

Casting

Input/Output utente

Array monodimensionali

Array multidimensionali


operatori di controllo flusso


Istruzione If-Else e operatore ternario

IF annidati

Istruzione Switch - case

Ciclo While

Ciclo Do-While

Ciclo For

Cicli annidati

Cicli infiniti


Object Oriented fondamenti


Labels, Break e Continue

Programmazione ad oggetti

La programmazione ad oggetti

Progettare una Classe

Istanziare un Oggetto: il costruttore

Variabili d’istanza e incapsulamento

Visibilità dei membri di una classe

Il reference This

Ereditarietà , Incapsulamento, Polimorfismo

La parola riservata null

EreditarietÃ

Il concetto di ereditarietÃ

Strutture ereditarie


Dalla teoria alla pratica: EreditarietÃ


La parola riservata super

La classe Object

Impedire l'ereditarietà : la parola riservata final

sintassi e pratica Object Oriented

Membri statici e membri dinamici

Polimorfismo

Overloading e Overriding

Binding dinamico

Casting con oggetti

Cast e instanceof

Interfacce, classi astratte e classi innestate

Interfacce

Ereditarietà e polimorfismo nelle interfacce

Classi astratte

Classi innestate

Classi anonime




accesso al DataBase via JDBC


Introduzione a JDBC

Convenzioni JDBC URL Naming

Gestione dei driver: il DriverManager

Gestione degli errori

Le SQLException

Supporto per i tipi di dati

Estensioni standard di JDBC

Connection Pooling

Object Relation Mapping

Gestione dei dati: JDBC

DataBase


Classe Exception


Eccezioni

Errori ed eccezioni

Il costrutto TRY-CATCH-FINALLY

Tipi di eccezione ed il costrutto Throws

Try e catch

Lanciare un’eccezione: il costrutto Throw

Eccezioni personalizzate

Generazione di eccezioni

Creazione di nuove eccezioni


collezioni e iteratori


Il Framework Collections

Framework Collections

Foreach ed Iterator

Implementazioni di Set e SortedSet

input/output

Implementazioni di List

Implementazioni di Queue

Implementazioni di Map e SortedMap

Tipi Generics


gestione delle date, numeri complessi e formattazione


Input/Output

Introduzione all’I/O: input da tastiera

Java.io: Leggere un file

Java.io: Scrivere su un file

networking di base

Java.io:Operazioni su file

Networking: Socket