java

Java Base
Cristiano Bellucci
Argomenti
• 1- Caratteristiche del linguaggio Java
• 2 - Software
• 3 - Sintassi
1 – Caratteristiche del linguaggio Java
Cos’è java ?
Un linguaggio semplice, objectoriented, interpretato, robusto,
sicuro, portabile, multithreaded,
dinamico.
Storia
•Un team della Sun guidato
da James Gosling
•Java nel 1990 si chiamava
Oak
•Doveva servire come
linguaggio di
programmazione per device
elettronici
Java è semplice
•Nessuna aritmetica dei puntatori
•Garbage collection (memoria)
automatica
•Molto simile al C
Java è object oriented
•O.O. è naturale
•Supporta l’ereditarietà
•Supporta il polimorfismo
•Supporta l’incapsulamento (information
hiding)
•Interfacce
•Non supporta la ereditarietà multipla
•Tutti gli oggetti sono manipolati per reference
Java è distribuito
•Disegnato per lavorare in rete
•Supporta vari livelli di connettività in rete
Java è interpretato
•Il compilatore genera il bytecode
•Il bytecode è indipendente dall’architettura
su cui viene generato
•Il bytecode viene poi interpretato
Java è robusto
•Dimensioni del linguaggio minori di altri
linguaggi
•Il programmatore non si deve preoccupare
della memoria
Java è sicuro
•Il bytecode è sottoposto ad un processo di
verifica
•Il bytecode gira nell'ambiente della Java
Virtual Machine e non può accedere ad
aree protette della memoria.
•Security Manager
Java è portabile
•Il bytecode è indipendente dall’architettura
•Write once, run everywhere
Java è multithread
•Supporto per i thread
•Supporto a metodi synchronized
Java è dinamico
•Dinamicamente carica classi
quando ne ha bisogno
2 – Software
Java Software Development Kit
Le API della piattaforma Java:
– Java Standard Edition
Ultima versione: JDK 6.0
– Java Enterprise Edition
Ultima versione: Java EE 5 SDK
– Java Micro Edition
Tool di sviluppo
•javac compilatore
•java interprete
•appletviewer visualizzatore di applet
•javadoc.exe. Permette di generare
documentazione dei programmi java in
formato html estraendo tutto ciò che si trova
commentato tra i simboli /** ..... */
CLASSPATH
E’ la variabile di ambiente che contiene gli identificativi di
tutte le directory a partire dalle quali la JVM cerca le classi
che le occorrono
Esempio per ambiente Windows:
set
classpath=.;c:\unpathdelleclassi\mieclassi.jar;c:\ilpathdialtr
eclassi
Esempio per ambiente Unix:
export
classpath=.:usr/local/unpathdelleclassi/mieclassi.zip:usr/loc
al/ilpathdialtreclassi
3 – Sintassi
Hello World!
/**
* The HelloWorldApp class implements an application that
* simply prints "Hello World!" to standard output.
*/
public class HelloWorldApp {
/** Creates a new instance of HelloWorldApp */
public HelloWorldApp() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
System.out.println("Hello World!"); // Display the string.
}
}
La prima cosa che viene eseguita dal computer è:
public static void main(String[] args){}
Classe
public class Bicycle {
Dichiariazione variabile:
tipo_variabile nome_variabile;
// stato = variabili
int cadence;
int speed = 0;
int gear = 1;
// comportamento = metodi
// metodo per cambiare la frequenza della pedalata
void changeCadence(int newValue) {
cadence = newValue;
}
// metodo per cambiare marcia
void changeGear(int newValue) {
gear = newValue;
}
Dichiariazione + assegnazione variabile:
tipo_variabile nome_variabile = valore;
Definizione metodo:
tipo_restituito nome_metodo (tipo_parametro parametro){
istruzioni;
}
// metodo per aumentare la velocità
void speedUp(int increment) {
speed = speed + increment;
}
// metodo per diminuire la velocità
void applyBrakes(int decrement) {
speed = speed - decrement;
}
// metodo di utilità per stampare lo stato (variabili)
void printStates() {
System.out.println("cadence:"+cadence+" speed:"+speed+" gear:"+gear);
}
}
Istanza
public class BicycleDemo {
public static void main(String[] args) {
// Crea 2 differenti biciclette
Bicycle bike1 = new Bicycle();
Bicycle bike2 = new Bicycle();
// Invoca i metodi di queste classi
bike1.changeCadence(50);
bike1.speedUp(10);
bike1.changeGear(2);
bike1.printStates();
bike2.changeCadence(50);
bike2.speedUp(10);
bike2.changeGear(2);
bike2.changeCadence(40);
bike2.speedUp(10);
bike2.changeGear(3);
bike2.printStates();
}
}
Creazione nuova istanza della classe
tipo_varibile nome variabile =
new tipo_variabile();
Invocazione metodi di una classe
istanza.nome_metodo
Costruttore
Ha lo stesso nome della classe e public class Bicycle {
// stato = variabili
non ritorna alcun tipo
int cadence = 0;
int speed = 0;
Se non ce ne sono scritti nella
int gear = 1;
classe, java comunque da quello di
// comportamento = metodi
// metodo per cambiare la frequenza della pedalata
void changeCadence(int newValue) {
default (= a 0 argomenti)
cadence = newValue;
}
Ce ne possono essere in numero
// costruttore a 0 argomenti
public Bicycle(){
qualsiasi, basta che siano differenti
}
per numero o tipo di parametri
// costruttore a 3 argomenti
public Bicycle(int cad, int spe, int ge){
passati
cadence = cad;
speed = spe;
Viene invocato quando si usa new
gear = ge;
}
es.: Bicycle b = new Bycicle();
// metodo per cambiare marcia
Bicycle b1 = new Bicycle(25, 30, 2);
void changeGear(int newValue) {
gear = newValue;
}
…
}
Stato = variabili
TipoDatoPrimitivo nomeVar = valore;
Tipo di dato
Vaore di
default
Dimensione
Predefinito
byte
0
8-bit
Si
short
0
16-bit
Si
int
0
32-bit
Si
long
0L
64-bit
Si
float
0.0f
32-bit
Si
double
0.0d
64-bit
Si
char
'\u0000'
16-bit
Si
boolean
false
1-bit
Si
String (altri
oggetti)
Null
No
Bicycle
Null
No
TipoDatoOggetto nomeVar =
new TipoDatoOggetto(parametri);
int mioPrimoIntero = 100;
double mioPrimoDecimale = 1.23;
boolean mioPrimoBoolean = true;
String miaPrimaStringa = new String(“Hello”);
Bicycle bicycle = new Bicycle();
Operatori
Operatori
Funzioni
Tipo dato
a+b
+-*/
Aritmetiche
Numerico
== !=
(Dis)Uguaglianza
Numerico e booleano
&&
AND
booleano
||
OR
booleano
true || false
!
NOT
booleano
!b
=
Assegnazione
Tutti
b == c
b != c
true && false
mioPrimoIntero = 100;
Assegnazione
public class AssegnazioneDemo {
public static void main (String[] args){
int cadence;
cadence = 0;
int speed;
speed = 0;
int gear;
gear = 1;
double d;
d = 3.14;
boolean b;
b = false;
b = true;
String miaPrimaStringa;
miaPrimaStringa = new String(“Hello”);
Bycicle b;
b = new Bicycle();
}
Aritmetiche
class ArithmeticDemo {
public static void main (String[] args){
int result = 1 + 2; // risultato è 3
System.out.println(result);
result = result - 1; // risultato è 2
System.out.println(result);
result = result * 2; // risultato è 4
System.out.println(result);
result = result / 2; // risultato è 2
System.out.println(result);
result = result + 8; // risultato è 10
result = result % 7; // risultato è 3
System.out.println(result);
}
}
Not
class UnaryDemo {
public static void main(String[] args){
boolean success = false;
System.out.println(success); // false
System.out.println(!success); // true
}
}
Istruzioni per controllo flusso
Istruzione
Descrizione
if
Esegue o no un blocco di codice a seconda del valore restituito da una espressione booleana.
if-else
Esegue permette di selezionare tra due blocchi di codice quello da eseguire a seconda del valore restituito da
una espressione booleana.
while
Esegue ripetutamente un blocco di codice controllando il valore di una espressione booleana.
for
Esegue ripetutamente un blocco di codice.
if
if (espressione_booleana){
[istruzione]
}
// classe per verificare il ciclo if
class IfDemo {
public static void main(String[] args) {
// variabile di test
int x;
// assegnazione variabile
x = 20;
// controllo del valore della variabile
if(x>10){
System.out.println(“x è maggiore di 10”);
x=0;
}
System.out.println(“Il valore di x è:” + x);
}
if - else
if (espressione_booleana){
[istruzione]
} else {
[istruzione]
}
// classe per verificare il ciclo if - else
class IfElseDemo {
public static void main(String[] args) {
int testscore = 76;
char grade;
if (testscore >= 60) {
grade = 'D';
} else {
System.out.println("testscore è minore di 60");
}
if (testscore >= 70) {
grade = 'C';
} else {
System.out.println("testscore è minore di 70");
}
if (testscore >= 80) {
grade = 'B';
} else {
System.out.println("testscore è minore di 80");
}
if (testscore >= 90) {
grade = 'A';
}
System.out.println("Grade = " + grade);
}
}
while
while (espressione_booleana){
[istruzione]
}
// classe per verificare il ciclo while
class WhileDemo {
public static void main(String[] args){
int count = 1;
while (count < 11) {
System.out.println("Il valore di Count è: " + count);
count++; // equivale a count = count + 1;
}
}
}
for
for (istruzione; espressione_booleana; iterazione){
[istruzione]
}
// classe per verificare il ciclo for
class ForDemo {
public static void main(String[] args){
for(int i=1; i<11; i++){
System.out.println("Il valore di count è: " + i);
}
}
}
if && || !
// classe per verificare il ciclo if e le condizioni && || e !
class IfLogicDemo {
public static void main(String[] args) {
// variabili di test
int x;
int y;
boolean bol;
// assegnazione variabili
x = 20;
y = 30;
bol = false;
// controllo del valore della variabile
if(x>10){
System.out.println(“x è maggiore di 10”);
x=2;
}
if(x>1 && y<50){
System.out.println(“Il valore di y è: ” + y);
}
if(x>40 || y<50){
System.out.println(“Il valore di y è: ” + y);
}
if(!bol){
System.out.println(“Il valore di not bol è true ” );
}
}
Incapsulamento
public class Bicycle {
private int cadence;
private int gear;
private int speed;
•Si realizza nascondendo le
informazioni
•private e public
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
public int getCadence() {
return cadence;
}
public void setCadence(int newValue) {
cadence = newValue;
}
public int getGear() {
return gear;
}
public void setGear(int newValue) {
gear = newValue;
}
public int getSpeed() {
return speed;
}
public void applyBrake(int decrement) {
setSpeed(-decrement);
}
public void speedUp(int increment) {
setSpeed(+increment);
}
private void setSpeed(int spe) {
speed = speed + spe;
}
}
Ereditarietà- classe base
public class Veicolo
{
public String nome;
public int velocita; //in Km/h
public int direzione;
private int DRITTO=0;
private int SINISTRA = -1;
private int DESTRA = 1;
public Veicolo(){
velocita=0;
direzione = DRITTO;
nome = “Veicolo generico”;
}
public void muovi(){
velocita=1;
System.out.println(nome + “ si sta movendo a: ”+ velocita+” Kmh”);
}
public void ferma(){
velocita=0;
System.out.println(nome + “ si è fermato”);
}
public void sinistra(){
direzione =SINISTRA;
System.out.println(nome + “ ha sterzato a sinistra”);
}
public void destra(){
direzione =DESTRA;
System.out.println(nome + “ ha sterzato a destra”);
}
public void diritto(){
direzione = DRITTO;
System.out.println(nome + “ sta procedendo in linea retta”);
}
}
Ereditarietà – classe derivata
public class Macchina extends Veicolo{
public Macchina(){
velocita=0;
direzione = DRITTO;
nome = “Macchina”;
}
}
Ereditarietà - verifica
public class Autista{
public static void main(String args[]){
Veicolo v = new Veicolo();
v.muovi();
v.sinistra();
v.diritto();
v.ferma();
Macchina fiat = new Macchina ();
fiat.muovi();
fiat.sinistra();
fiat.diritto();
fiat.ferma();
}
}
Polimorfismo e ereditarietà
•Overriding
public class MacchinaLenta extends Veicolo{
public MacchinaLenta(){
velocita=0;
direzione = DRITTO;
nome = “Macchina Lenta”;
}
public void muovi(){
velocita=0.5;
System.out.println(nome + “ si sta movendo a: ”+ velocita+” Kmh”);
}
}
Polimorfismo
•Overloading
public class Veicolo
{
public String nome;
public int velocita; //in Km/h
public int direzione;
private int DRITTO=0;
private int SINISTRA = -1;
private int DESTRA = 1;
public Veicolo(){
velocita=0;
direzione = DRITTO;
nome = “Veicolo generico”;
}
public void muovi(){
velocita=1;
System.out.println(nome + “ si sta movendo a: ”+ velocita+” Kmh”);
}
public void muovi(int vel){
velocita=vel;
System.out.println(nome + “ si sta movendo a: ”+ velocita+” Kmh”);
}
…
}
Interazioni (una parte di) – classe chiamante
public class Veicolo
{
String nome;
int velocita; //in Km/h
int direzione;
private int DRITTO=0;
private int SINISTRA = -1;
private int DESTRA = 1;
private Ruota ruota;
public Veicolo(){
velocita=0;
direzione = DRITTO;
nome = “Veicolo generico”;
}
public void setRuota(Ruota ruo){
Ruota = ruo;
}
public void muovi(){
velocita=1;
System.out.println(nome + “ si sta movendo a: ”+ velocita+” Kmh”);
}
…
}
Interazioni (una parte di) – classe chiamata
public class Ruota{
private String marca;
private int raggio;
public void setMarca(String mar){
marca = mar;
}
public String getMarca(){
return marca;
}
public void setRaggio(int rag){
raggio = rag;
}
public int getRaggio(){
return raggio;
}
}
Interazioni (una parte di) – classe test
public class Test{
public static void main(String args[]){
// creazione veicolo
Veicolo v = new Veicolo();
v.muovi();
v.sinistra();
v.diritto();
v.ferma();
// creazione ruota
Ruota r = new Ruota();
r.setMarca(“Pirelli”);
r.setRaggio(18);
// inserimento ruota nel veicolo
v.setRuota(r);
System.out.println(“La marca della ruota del veicolo è: ” +
v.getRuota().getMarca());
}
}
GRAZIE