Appunti Java

Fondamenti

  • Dal problema al programma
  • La nozione di algoritmo
  • Linguaggi per la descrizione di algoritmi.
  • I diagrammi di flusso
  • Paradigmi di programmazione
  • Tipi di dato semplici
  • Strutture di controllo sequenziali, condizionali ed iterative
  • Tipi di dato complessi e oggetti
  • Funzioni e metodi
  • Il ciclo di vita del software e le qualità dei programmi
  • Astrazione e decomposizione
  • La programmazione modulare
  • Strutture dati fondamentali: liste, hash table

snippets

Math.PI
Math.random()
Math.pow(a, b)

System.currentTimeMillis()
System.out.println(anyValue)

JoptionPane.showMessageDialog(null, message)
JOptionPane.showInputDialog(prompt-message)

Integer.parseInt(string)
Double.parseDouble(string)

Arrays.sort(type[] list)
Arrays.binarySearch(type[] list, type key)
String s = "Welcome";
String s = new String(char[]);
int length = s.length();
char ch = s.charAt(index);
int d = s.compareTo(s1);
boolean b = s.equals(s1);
boolean b = s.startsWith(s1);
boolean b = s.endsWith(s1);
String s1 = s.trim();
String s1 = s.toUpperCase();
String s1 = s.toLowerCase();
int index = s.indexOf(ch);
int index = s.lastIndexOf(ch);
String s1 = s.substring(ch);
String s1 = s.substring(i,j);
char[] chs = s.toCharArray();
String s1 = s.replaceAll(regex,repl);
String[] tokens = s.split(regex);
ArrayList<E> list = new ArrayList<E>();
list.add(object);
list.add(index, object);
list.clear();
Object o = list.get(index);
boolean b = list.isEmpty();
boolean b = list.contains(object);
int i = list.size();
list.remove(index);
list.set(index, object);
int i = list.indexOf(object);
int i = list.lastIndexOf(object);
Array Monodimensionali
int[] list = new int[10];
list.length;
int[] list = {1, 2, 3, 4};
Array Multidimensionali 
int[][] list = new int[10][10];
list.length;
list[0].length;
int[][] list = {{1, 2}, {3, 4}};
Array irregolari
int[][] m = {{1, 2, 3, 4},
{1, 2, 3},
{1, 2},
{1}};
        String[] mesi = {
                "Gennaio",
                "Febbraio",
                "Marzo",
                "Aprile",
                "Maggio",
                "Giugno",
                "Luglio",
                "Agosto",
                "Settembre",
                "Ottobre",
                "Novembre",
                "Dicembre",
        };

        //se conosco a priori il numero di iterazioni
/*        for (int i = 0; i < mesi.length; i++) {
            System.out.println("mese: " + mesi[i]);
            String risposta= getInput("Ti piace il mese di " + mesi[i]);
            System.out.println(risposta);
        }
        */
        //anche per scorrere l'array al contrario
/*
        for (int i = mesi.length -1; i>=0; i-- ){

            if(i % 2 != 0)
            System.out.println("mese:  "+ mesi[i]+"[" +  i +"]");

        }

*/

/*        for (String m : mesi ) {
            System.out.println(m);
        }*/

        int counter = 0;
        while(counter < mesi.length){
            System.out.println("il valore di contatore è" + counter);
            System.out.println("il valore di mese è" + mesi[counter]);
            counter++;
        }

        boolean sentinella = false;

/*
        while(sentinella == false){

            String s =getInput("Inserisci un numero");
            System.out.println(s);
            if (s.equals("esci"))
                sentinella = true;

        }
*/
;
        do{

            String s =getInput("Inserisci un numero");
            System.out.println(s);
        }
        while(sentinella == true);




        int mese = 3;
        //dichiaro oggetto stringa
        String meseStringa;

        //dichiaro un'oggetto di tipo scanner
        Scanner sc = new Scanner(System.in);

        //messaggio
        System.out.println("Inserisci inserisci una stringa di 3 lettere abbreviazione mese in cui siamo");
/**/        String input = sc.nextLine();
        try {
            mese = Integer.parseInt(input);
        } catch (NumberFormatException e) {
            System.out.println("Hai inserito un numero, dovevi inserire");
            //e.printStackTrace();
        }


        //valorizzo stringa con input dell'utente
         meseStringa = sc.nextLine();

        if(meseStringa.equals("esci"))
            System.out.println("programma terminato");



        //if... else if... else
//        if (mese >=1 && mese <=3){
//            System.out.println("Sei nel 1° trimestre");
//        }
//
//        else if (mese >=4 && mese <=6){
//            System.out.println("Sei nel 2° trimestre");
//        }
//        else if (mese >=7 && mese <=9){
//            System.out.println("Sei nel 3° trimestre");
//        }
//        else if (mese >=10 && mese <=12){
//            System.out.println("Sei nel 4° trimestre");
//        }
//        else {
//            System.out.println("Questo valore è sconosciuto");
//        }

//        switch (mese){
//
//            case 1:
//            case 2:
//            case 3:
//                //System.out.println("gennaio");
//                System.out.println("siamo nel 1 trimestre");
//                break;
//            case 4:
//            case 5:
//            case 6:
//                System.out.println("siamo nel 2 trimestre");
//                break;
//            default:
//                System.out.println("inserisci un numero tra 1 e 2");
//                break;
//
//
//        }

            //dalla versione 7 possso utilizzare le stringhe
        switch (input){

            case "Gen":
                System.out.println("gennaio");
                break;
            case "Feb":
                System.out.println("febbraio");
                break;
            case "Mar":
                System.out.println("marzo");
                break;
            case "Apr":
                System.out.println("aprile");
                break;

            //.....

            default:
                System.out.println("inserisci una stringa di 3 lettere");
                break;


        }

Tipi primitivi tipi complessi

static

//uso una classe con metodi statici, accedo ad esse senza istanziare nuovi oggetti:
Math.sqrt(4);

//tipo di utilizzo classe, creo oggetto, attraverso l'oggetto mediante l'operatore dot (.) accedo ai suoi metodi e variabili
Persona p1 = new Persona();
Persona p2 = new Persona();

p1.setEta(23);

Flusso di lavoro

  • GESTIONE DEL FLUSSO DI ESECUZIONE
  • COSTRUTTI DI PROGRAMMAZIONE
  • Il costrutto if
  • Il costrutto while
  • Il costrutto for
  • Il costrutto do
  • Cicli for migliorato
  • Il costrutto switch

costrutti condizionali

  • if()
  • if... else if... else
  • switch() // un if elegante

costrutti iterativi

  • for
  • for: per scorrere p.es un array in entrambe le direzioni
  • for(each): scorre solo in una direzione
  • while
  • do...while

esercizio:

  • costruire un programma che chieda in input l'altezza degli studenti di una classe (altezza espressa in cm )
  • il programma accetta un numero indeterminato di valori in input e restituisce la media aritmetica incrementale ogni volta
  • inserire una condizione per uscire dal ciclo e informare l'utente della stringa da inserire

soluzione esercizio MB

boolean esci = false;
int studentiTot=0;
int altezzaTot = 0;
double media = 0.0D;
while(esci == false){
    String s =getInput("Inserisci un numero");
    int valoreInserito = Integer.parseInt(s);
    //è la condizione che mi fa uscire
    if (valoreInserito == 0) esci = true;
    studentiTot++;
    altezzaTot += valoreInserito;
    media = altezzaTot/studentiTot;
    System.out.println("il numero degli studenti è " + studentiTot);
    System.out.println("l'altezza totale degli studenti è " + altezzaTot);
    System.out.println("quindi la media aritmetica dell'altezza dell'aula " + media);
}

esercizio 2

  • la direttrice del centro di formazione di via xx settembre vi chiede un programma per formare le classi per il nuovo anno scolastico.
  • Stampare o visualizzare il numero di classi che si possono ottenere con un gruppo di studenti di cui si conosce l'anno di nascita.
  • Le classi devono essere omogenee per età e possono contenere max 16 studenti.

Esercizio 3

  • utilizzando la classe LanciaDadi creata a lezione, implementare un gioco di dadi
  • problema
  • costruire un gioco statistico
  • lanciadadi

requirements

  • deve permettere al player di scegliere il numero di facce del dado (default 6)
  • deve poter scegliere il numero di dadi con cui giocare (default 2)
  • devo verificare e riportare le statistiche di successo su 1000 lanci: successo = tutte le facce con lo stesso valore
  • evoluzione: classificare i risultati per faccia del dado

pseudo codice

ciclo for innestato

String mieRighe = getInput("Quante righe ha la tua tabella");
String mieColonne = getInput("Quante righe ha la tua tabella");
int righe = Integer.parseInt(mieRighe);
int colonne = Integer.parseInt(mieColonne);
//voglio stampare a video una matrice 3x3
for (int i = 1; i <= righe; i++) {
    //ciclo innestato
    for (int j = 1; j <= colonne ; j++) {
        int result = i * j;
        if(result % 2 == 0)
        System.out.print(result);
        //inserisco un tabulate
        System.out.print("\t");
    }
    System.out.println();
}

//metodo statico richiamato dal metodo main
public static String getInput(String domanda){
    System.out.println(domanda);
    Scanner stringa = new Scanner(System.in);
    String miaStringa = stringa.next();
    return miaStringa;
}

date in java

Array Monodimensionali

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        System.out.println("Array di tipi primitivi");
        //semplificato
        int[] interi = {6,4,2};
        Arrays.sort(interi);
        for (int i = 0; i < interi.length ; i++) {
            System.out.println(interi[i]);
        }
        System.out.println("Array di stringhe");
        //semplificato
        String[] colori = {"Rosso","verde", "blu"};
        Arrays.sort(colori);
        for (int i = 0; i < colori.length ; i++) {
            System.out.println(colori[i]);
        }
        System.out.println("Array di stringhe con for(each)");
        //semplificato
        String[] moto = {"MT-09","VSTROM", "CBR"};
        //Arrays.sort(moto);
        for (String m : moto) {
            System.out.println(m);
        }
        System.out.println("Array di interi sintassi alternativa");
        //semplificato
        int dimensione= 10;
        int[] dimensionato = new int[dimensione] ;
            //con il prossimo ciclo riempio l'array
        for (int i = 0; i < dimensionato.length; i++) {
            dimensionato[i] = i*50;
        }
        //con il prossimo ciclo stampo gli elementi dell'array
        for (int valore : dimensionato ) {
            System.out.println(valore);
        }
        System.out.println("copiare un array");
        int[] nuovo = new int[10];
        System.arraycopy(dimensionato,0,nuovo,2,9);
        for (int n : nuovo) {
            System.out.println(n);
        }
//        int[] interi = new int[3];
//        interi[0] = 2;
//        interi[1] = 4;
//        interi[2] = 6;
    }
}

Array multidimensionali

public class ArrayMulti {
    public static void main(String[] args) {
        String[][] moto = new String[3][2];
        moto[0][0] = "MT-09";
        moto[0][1] = "Yamaha";
        moto[1][0] = "VSTROM";
        moto[1][1] = "Suzuki";
        moto[2][0] = "CBR600";
        moto[2][1] = "Honda";
        for(int i = 0; i < moto.length; i++ ){
            StringBuilder sb = new StringBuilder();
            sb.append("La marca della ")
                    .append(moto[i][0])
                    .append(" è ")
                    .append(moto[i][1])
                    .append(".");
            System.out.println(sb);
        }
    }
}

matrici

int righe = 10;
int colonne = 10;
//primo ciclo for
for (int i = 1; i < righe; i++) {
    //2 ciclo for innestato
    for (int j = 1; j <= i; j++) {
        //if(i*j < 10) System.out.print("0");
        System.out.print("A");
        //System.out.print(i * j);
        //System.out.print("\t");
    }
    System.out.println();
}

Esercizio:

  • con i cicli innestati stampare a video la figura di un triangolo isoscele composto di lettere A maiuscola

ArrayList

import java.util.ArrayList;
import java.util.List;
public class ListaArray {
    public static void main(String[] args) {
    List<String> elenco = new ArrayList<>();
        elenco.add("MT_09");
        elenco.add("CBR600");
        elenco.add("VSTROM");
        System.out.println(elenco);
        elenco.add("Africa Twin");
        System.out.println(elenco);
        elenco.remove(1);
        System.out.println(elenco);
        System.out.println(elenco.get(0));
        int posizione = elenco.indexOf("Africa Twin");
        System.out.println("Africa è in posizione " + posizione);
    }
}

http://www.bogliaccino.it/corso-java-base-2/

Corso Java Base – JCF

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);
	  }	  
	  
}

http://www.bogliaccino.it/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

1. Introduzione a Java

  • Introduzione
  • Compilazione ed esecuzione
  • 2. Sintassi e programmazione strutturata
  • variabili e metodi
  • tipi di dati, array
  • operatori di controllo flusso

3. Sintassi e programmazione OO

  • Object Oriented fondamenti
  • Ereditarieta, Incapsulamento, Polimorfismo
  • sintassi e pratica OO
  • 4. Accesso database
  • ·          accesso a DB via JDBC
  • ·          Object Relation Mapping
  • 5. Eccezioni
  • ·          Classe Exception
  • ·          Try e catch
  • ·          Generazione di eccezioni
  • ·          Creazione di nuove eccezioni

6. Core libraries

  • collezioni e iteratori
  • input/output
  • gestione delle date, numeri complessi e formattazione
  • networking di base

Unità didattiche

Introduzione 8 4

  • 1 Introduzione
  • 2 Installazione ambiente di sviluppo
  • 3 Introduzione linguaggio Java
  • 4 Compilazione ed esecuzione
  • Compilazione ed esecuzione 8 4
  • 5 Sintassi java
  • 6 Basi della programmazione

variabili e metodi 12 4

  • 9 Operatori di assegnazione, relazionali e booleani
  • 10 Operatori aritmetici
  • 11 Pre/post incremento e concatenazione stringhe
  • 12 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 12 4

  • 13 Scope delle variabili
  • 14 Tipi di dato primitivi
  • 15 Caso particolare: la classe String
  • 16 Casting
  • Input/Output utente
  • Array monodimensionali
  • Array multidimensionali

operatori di controllo flusso 16 8

  • 17 Istruzione If-Else e operatore ternario
  • 18 IF annidati
  • 19 Istruzione Switch – case
  • 20 Ciclo While
  • 21 Ciclo Do-While
  • 22 Ciclo For
  • 23 Cicli annidati
  • 24 Cicli infiniti

Object Oriented fondamenti 16 8

  • 25 Labels, Break e Continue
  • 26 Programmazione ad oggetti
  • 27 La programmazione ad oggetti
  • 28 Progettare una Classe
  • 29 Istanziare un Oggetto: il costruttore
  • 30 Variabili d’istanza e incapsulamento
  • 31 Visibilità dei membri di una classe
  • 32 Il reference This
  • Ereditarieta, Incapsulamento, Polimorfismo 12 4
  • 33 La parola riservata null
  • 34 Ereditarietà
  • 35 Il concetto di ereditarietà
  • 36 Strutture ereditarie

Dalla teoria alla pratica: Ereditarietà

  • La parola riservata super
  • La classe Object
  • Impedire l’ereditarietà: la parola riservata final
  • sintassi e pratica OO 8 4
  • 37 Membri statici e membri dinamici
  • 38 Polimorfismo
  • 39 Overloading e Overriding
  • 40 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 a DB via JDBC 16 8

  • 41 Introduzione a JDBC
  • 42 Convenzioni JDBC URL Naming
  • 43 Gestione dei driver: il DriverManager
  • 44 Gestione degli errori
  • 45 Le SQLException
  • 46 Supporto per i tipi di dati
  • 47 Estensioni standard di JDBC
  • 48 Connection Pooling
  • Object Relation Mapping 8 4
  • 49 Gestione dei dati: JDBC
  • 50 DB

Classe Exception 8 4

  • 53 Eccezioni
  • 54 Errori ed eccezioni
  • 55 Il costrutto TRY-CATCH-FINALLY
  • 56 Tipi di eccezione ed il costrutto Throws
  • Try e catch 12 4
  • 57 Lanciare un’eccezione: il costrutto Throw
  • 58 Eccezioni personalizzate
  • Generazione di eccezioni 8 4
  • Creazione di nuove eccezioni 8 4

collezioni e iteratori 8 4

  • 69 Il Framework Collections
  • 70 Framework Collections
  • 71 Foreach ed Iterator
  • 72 Implementazioni di Set e SortedSet
  • input/output 12 4
  • 73 Implementazioni di List
  • 74 Implementazioni di Queue
  • 75 Implementazioni di Map e SortedMap
  • 76 Tipi Generics

gestione delle date, numeri complessi e formattazione 8 4

  • 77 Input/Output
  • 78 Introduzione all’I/O: input da tastiera
  • 79 Java.io: Leggere un file
  • 80 Java.io: Scrivere su un file
  • networking di base 8 4
  • 81 Java.io:Operazioni su file
  • 82 Networking: Socket

http://www.bogliaccino.it/corso-android-2-java-fondamentale/

Corso android #2 – Java Fondamentale

Corso android #2

Java Fondamentale

Caratteristiche di Java

• Semplice e familiare
• Orientato a oggetti
• Indipendente dalla piattaforma
• interpretato
• Sicuro
• Robusto
• Distribuito e dinamico
• Multi-thread

Semplice e familiare

• Basato su C
• Sviluppato da zero
• Estremamente semplice: senza puntatori, macro, registri, tipizzazione
–Apprendimento rapido
–Semplificazione della programmazione
–Riduzione del numero di errori

Orientato a oggetti

• Orientato a oggetti dalla base
• In Java tutto è un oggetto
• Incorpora le caratteristiche
–Incapsulamento
–Polimorfismo
–Ereditarietà
–Collegamento dinamico
• Non sono disponibili
–Ereditarietà multipla
–Overload degli operatori

Indipendente dalla piattaforma

• Più efficiente di altri linguaggi interpretati
• Soluzione: la macchina virtuale
• JVM (non è proprio la JVM)
• Linguaggio macchina bytecodes

Interpretato

• Il bytecode deve essere interpretato
• Vantaggi rispetto ad altri linguaggi interpretati
–Codice più compatto
–Efficiente
–Codice confidenziale (non esposto)

sicuro

• Supporta la sicurezza di tipo sandboxing
• Verifica del bytecode
• Altre misure di sicurezza
–Caricatore di classi
–Restrizioni nell’accesso alla rete

Robusto

• L’esecuzione nella JVM impedisce di bloccare il sistema
• L’assegnazione dei tipi è molto restrittiva
• La gestione della memoria è sempre a carico del sistema
• Il controllo del codice avviene sia a tempo di compilazione sia a tempo di esecuzione (runtime)

Distribuito e dinamico

• Disegnato per un’esecuzione remota e distribuita
• Sistema dinamico
–Classe collegata quando è richiesta
–Può essere caricata via rete
• Dinamicamente estensibile
–Disegnato per adattarsi ad ambienti in evoluzione

Multi-thread

• Soluzione semplice ed elegante per la multiprogrammazione
• Un programma può lanciare differenti processi
• Non si tratta di nuovi processi, condividono il codice e le variabili col processo principale
• Simultaneamente si possono svolgere vari compiti

Creazione di classi in Java

• Definire i termini oggetto e classe
• Descrivere la forma nella qual possiamo creare nuove classi in Java
• mostrare come, una volta creata una classe possiamo creare oggetti di questa classe e utilizzarli

Java è un linguaggio orientato agli oggetti

• Java è un linguaggio orientato agli oggetti in cui quasi tutto è un oggetto
• Pertanto risulta fondamentale sapere come definire classi di oggetti in Java
• Anzitutto conviene definire questi termini:
–Oggetto: entità che dispone di alcune proprietà (attributi) e comportamenti (metodi)
–Classe: definisce un tipo concreto di oggetto
• In Java quasi tutto è un oggetto, ci sono solo due eccezioni: le variabili semplici e gli array

Le classi in Java

• Il primo passo per definire una classe in Java è creare un file che deve chiamarsi esattamente come la classe e con estensione .java
• Java permette di definire solo un a classe per ogni file
• Una classe in Java è formata da:
–Attributi: (o campi/proprietà) che immagazzinano alcune informazioni sull’oggetto. Definiscono lo stato dell’oggetto
–Costruttore: metodo che si utilizza per inizializzare un oggetto
–Metodi: sono utilizzati per modificare o consultare lo stato di un oggetto. Sono equivalenti alle funzioni o procedimenti di altri linguaggi di programmazione

Struttura di una classe

Esempio in aula

Esempio di classe

Esempio in aula

Creazione e utilizzazione di oggetti

Esempio in aula

Incapsulamento e visibilità in Java

Interfaccia e implementazione

• Quando disegniamo un software ci sono due aspetti che risultano fondamentali:
–Interfaccia: come il sw può essere utilizzato
–Implementazione: il codice che abbiamo utilizzato
• In Java
–Interfaccia: definita come gli elementi che sono visibili dall’esterno
–Implementazione: definita creando alcuni determinati attributi e scrivendo il codice dei differenti metodi

Incapsulamento

• L’incapsulamento consiste nell’occultamento degli attributi di un oggetto in modo che possano essere manipolati solo attraverso metodi appositamente implementati
• Dettoo in altro modo: fare in modo che l’interfaccia sia più indipendente possibile dall’implementazione
• In Java l’incapsulamento è strettamente relazionato con la visibilità

Visibilità

• Per indicare la visibilità di un elemento (attribuito o metodo) possiamo farlo precedere da una delle seguenti parole riservate
–public: accessibile da qualsiasi classe
–private: accessibile solo dalla classe attuale
–protected: solo dalla classe attuale, le discendenti e le classi del nostro pacchetto
–Se non indichiamo la v.: sono accessibili solo dalle classi del nostro pacchetto

Accesso agli attributi della classe

• Gli attributi di una classe sono strettamente relazionati con la sua implementazione. Conviene contrassegnarli come private e impedirne l’accesso dall’esterno
• In futuro potremo cambiare la rappresentazione interna dell’oggetto senza alterare l’interfaccia
• In pratica:
class NomeClasse{
   private double nome1, nome2;
• Non permettiamo di accedere agli attributi perciò risulta impossibile consultarli e modificarli
• Soluzione: creare i metodi getter e setter
Metodi getter e setter
• Danno accesso agli attributi:

class NomeClasse{  private double nome1, nome2;

       public double getNome1(){
       return nome1;<
       } 
       public void setNome1(double nome1){ 
       this.nome1 = nome1; 
       }
• Vantaggi: possiamo cambiare la rappresentazione interna, verificare che i valori siano corretti, modificare altri aspetti dell’oggetto

Modifica di rappresentazione interna di una classe

• Uno dei maggiori vantaggi di occultare gli attributi è che in futuro potremo cambiarli senza la necessità di cambiare l’interfaccia
esempio

Ereditarietà in Java

• Definire il concetto di ereditarietà
• Descrivere la forma nella qual possiamo creare una nuova classe in java estendendone una già esistente
• Mostrare alcuni casi in cui l’ereditarietà può essere molto utile

Come riutilizzare il codice

• Uno dei grandi vantaggi della programmazione a oggetti è la facilità nel riutillizzare il codice
• In Java si realizza attraverso l’ereditarietà
• Per esempio immaginiamo di disporre di un sistema di georeferenziazione in cui la classe principale è

Geopunto {attributi: longitudine, latitudine}

• Dobbiamo modificare il sistema per aggiungere un nuovo attributo, l’altitudine
a)Modifichiamo direttamente la classe Geopunto Errore
b)Creiamo una nuova classe che erediti da Geopunto:

NuovoGeopunto {Geopunto + attributo: altitudine}

Estendere la classe

Quando utilizzare l’ereditarietà

• Per modificare classi già esistenti
–In un ambiente di sviluppo reale disponiamo di centinaia di classi. Per esempio la classe Button che rappresenta un bottone
–Immagina di dover creare un nuovo tipo di bottone che riproduca un suono quando viene schiacciato
–Con l’ereditarietà risulta molto semplice
• Per non dover riprogrammare due volte lo stesso codice
–Devi creare varie classi, p.es Cliente, Venditore, Distributore
–Esiste una parte del codice comune a tutte quante, p.es Piva, indirizzo, SpedireLettera()
–Crei una classe addizionale che raccolga il codice comune, es ParteCommerciale da cui ereditino le parti comuni

Il polimorfismo in Java

• Introdurre la classe Object e ripassare il concetto di ereditarietà
• Definire il concetto di polimorfismo
• Mostrare alcuni casi in cui il polimorfismo può essere molto utile
• Descrivere alcuni strumenti di Java utili quando lavoriamo col polimorfismo

L’ ereditarietà e la classe Object

• L’ ereditarietà ci permette di creare nuove classi a partire da altre già esistenti
• Quelle classi che non indichiamo in modo esplicito da dove derivino lo faranno in modo automatico dalla classe Object
• Pertanto la classe Object è la radice dell’albero genealogico dell’ereditarietà in Java. Come dire che tutti gli oggetti discendono da tale classe
• Questa classe dispone di una serie di metodi che pertanto sono disponibili in tutti gli oggetti che creiamo
• Tra questi metodi troviamo, p.es
–toString(), getClass(), equals(Object o), …

L’ ereditarietà e la classe Object

• Un oggetto della classe figlia appartiene anche alla classe padre ed agli ascendenti
• Per esempio un oggetto della classe vista prima ComplessoAmpliato appartiene tanto alla classe Complesso, quanto a Object

Il polimorfismo

• Il polimorfismo consiste nel dichiarare un oggetto di una classe, però istanziandolo come un discendente di tale classe (non si può fare il contrario!)
  <Classe_padre> <oggetto> =
  new <Classe_figlia> (<parametri>);

Perché si usa il polimorfismo

• Quando stiamo sviluppando una applicazione Android e vogliamo inserire un bottone, spesso vogliamo aggiungere una grafica di sfondo
• Per far questo avremo bisogno di un oggetto Drawable
• Abbiamo a disposizione moltissimi sfondi

Ma magari non sappiamo che tipo di disegno sarà!

Conversione di tipi (TYPE CAST)

mostra esempio in aula

Uso di INSTANCEOF

• La keyword riservata instanceof permette di verificare se un oggetto appartiene ad una classe
• Esempio

http://www.bogliaccino.it/corso-jsp-java-server-faces/

Corso JSP – Esempio Java Server Faces

“Programmazione web server-side con JSP” – corso IFTS – ITIS Pininfarina (TO) – Corso JSP – 

Corso JSP – Java Server Faces

Hello world JSF con Netbeans 7.3

  1. Crea un nuovo progetto Java Web – > Web Application
  2. Assegna un nome al progetto e salvalo sul disco
  3. Scegli un server web
  4. Scegli il framework Java Server Faces
  5. Clicca su ‘Fine’

In Source Packages aggiungi un nuovo package (p.es login ), all’interno del package aggiungi una classe java (p. es accesso.java)

Incolla il codice seguente

package login;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;

/**
*
* @author mauro
*/

@ManagedBean
@RequestScoped
public class accesso {
public String login;

public String getLogin() {
return login;
}

public void setLogin(String login) {
this.login = login;
}

public accesso() {
}
}

Il file index.xhtml contiene il form per l’invio del nome utente, incolla il codice all’interno dei tag h:body

    
<h:form>

<h2>login</h2>
Login: <h:inputText id="login" size="30" required="true" requiredMessage="inserisci nome utente" value="#{accesso.login}" />

<h:/form>

Iinfine crea il file login.xhtml che visualizza il testo inviato. Attenzione! Anche questo codice dovrà compreso all’interno dei tag h:form, così come il campo input per l’invio del testo.

    
<h:form>

Benvenuto: <h:outputText value="#{accesso.login}" />
            <h:commandLink value="torna alla home" action="index"/>

<h:/form>

http://www.bogliaccino.it/corso-angularjs/

Angularjs e altri framework Js per sviluppare app

Angularjs

Secondo modulo del Corso di sviluppo avanzato per applicativi web e mobile: nelle prime due giornate parleremo di Angularjs by Google e di YII, il mio framework Php preferito.

 

Logo Angularjs
Logo Angularjs

Primo modulo

Recap – Il corso precedente si è concluso con successo: abbiamo realizzato e rilasciato un’app professionale con PhoneGap/Cordova e JQueryMobile. Così anche un cliente è rimasto soddisfatto ;)

Abbiamo realizzato un’app ibrida con funzionalità avanzate, forse ha un lieve gap prestazionale rispetto ad una nativa, ma come avete constatato una curva di apprendimento e tempi di sviluppo decisamente ridotti. Oltre al vantaggio non trascurabile di riutilizzare le conoscenze html5 e css, scrivendo una sola volta il codice sorgente per  diversi sistemi operativi mobili.

Secondo modulo

In questo secondo modulo di 5 lezioni vedremo i principali framework javascript: Angular, Ember e Backbone. In particolare Angularjs che analizzeremo in maniera approfondita, anche perché è  supportato da Google: il rischio dei framework è che ad un certo punto ‘spariscano’, cessino di esser supportati per le ragioni più varie.

(Ri)Parleremo anche di design pattern: Model View Controller (MVC), Model View ViewModel (MVVM), Single-page application (SPA) e trattando Angular.js introdurremo il MV* o meglio MVW, cioè Model View Wathever come dicono gli autori stessi: Where Whatever stands for “whatever works for you”.

I design pattern favoriscono la pulizia, la manutenzione, la condivisione e il riuso del codice, in questo corso la parola d’ordine è DRY: Don’t Repeat Yourself.

Approfondiremo anche le potenzialità di Node.js: framework javascript server-side, lo abbiamo già utilizzato per installare PhoneGap ma può fare molto altro!

Troverete le slide nella sezione materiale didattico ed il codice sorgente su Github.

Appuntamento a Ivrea (To) il 12 novembre 2014.

Happy coding ;)

http://www.bogliaccino.it/helpful-hints-android-intents/

Android Intents

android intent action list

elenco principali azioni in android

azioni principali:

  • ACTION_MAIN
  • ACTION_VIEW
  • ACTION_ATTACH_DATA
  • ACTION_EDIT
  • ACTION_PICK
  • ACTION_CHOOSER
  • ACTION_GET_CONTENT
  • ACTION_WEB_SEARCH
  • ACTION_DIAL
  • ACTION_CALL
  • ACTION_SEND
  • ACTION_FACTORY_TEST
  • ACTION_SENDTO
  • ACTION_ANSWER
  • ACTION_INSERT
  • ACTION_DELETE
  • ACTION_RUN
  • ACTION_SYNC
  • ACTION_PICK_ACTIVITY
  • ACTION_SEARCH

richiama le azioni dal codice java – esempi

mostra una pagina web:

	Uri uri = Uri.parse("http://www.bogliaccino.it");
 Intent it  = new Intent(Intent.ACTION_VIEW,uri);
 startActivity(it);

//mostra una mappa centrata sulle coordinate GPS (engim artigianelli torino)

Uri uri = Uri.parse("geo:45.0728629,7.6714303");
Intent it = new Intent(Intent.Action_VIEW,uri);
startActivity(it);

//mostra un percorso

Uri uri = Uri.parse("http://maps.google.com/maps?f=d&saddr=startLat%20startLng&daddr=endLat%20endLng&hl=en");
Intent it = new Intent(Intent.ACTION_VIEW,uri);
startActivity(it);

//chiamata telefonica

Uri uri = Uri.parse("tel:xxxxxx");
Intent it = new Intent(Intent.ACTION_DIAL, uri);
startActivity(it);
Uri uri = Uri.parse("tel.xxxxxx");
Intent it =new Intent(Intent.ACTION_CALL,uri);

//aggiungi i permessi nel manifest: uses-permission id=”android.permission.CALL_PHONE”

//inviasms/mms, call sender program

Intent it = new Intent(Intent.ACTION_VIEW);
it.putExtra("sms_body", "The SMS text");
it.setType("vnd.android-dir/mms-sms");
startActivity(it);

//send sms

Uri uri = Uri.parse("smsto:0800000123");
Intent it = new Intent(Intent.ACTION_SENDTO, uri);
it.putExtra("sms_body", "The SMS text");
startActivity(it);

//invia mms

Uri uri = Uri.parse("content://media/external/images/media/23");
Intent it = new Intent(Intent.ACTION_SEND);
it.putExtra("sms_body", "some text");
it.putExtra(Intent.EXTRA_STREAM, uri);
it.setType("image/png");
startActivity(it);

//invia email

Uri uri = Uri.parse("mailto:xxx@abc.com");
Intent it = new Intent(Intent.ACTION_SENDTO, uri);
startActivity(it);
Intent it = new Intent(Intent.ACTION_SEND);
it.putExtra(Intent.EXTRA_EMAIL, "me@abc.com");
it.putExtra(Intent.EXTRA_TEXT, "The email body text");
it.setType("text/plain");
startActivity(Intent.createChooser(it, "Choose Email Client"));
Intent it=new Intent(Intent.ACTION_SEND);
String[] tos={"me@abc.com"};
String[] ccs={"you@abc.com"};
it.putExtra(Intent.EXTRA_EMAIL, tos);
it.putExtra(Intent.EXTRA_CC, ccs);
it.putExtra(Intent.EXTRA_TEXT, "The email body text");
it.putExtra(Intent.EXTRA_SUBJECT, "The email subject text");
it.setType("message/rfc822");
startActivity(Intent.createChooser(it, "Choose Email Client"));

//aggiungi extra

Intent it = new Intent(Intent.ACTION_SEND);
it.putExtra(Intent.EXTRA_SUBJECT, "The email subject text");
it.putExtra(Intent.EXTRA_STREAM, "file:///sdcard/mysong.mp3");
sendIntent.setType("audio/mp3");
startActivity(Intent.createChooser(it, "Choose Email Client"));

//play media

Intent it = new Intent(Intent.ACTION_VIEW);
Uri uri = Uri.parse("file:///sdcard/song.mp3");
it.setDataAndType(uri, "audio/mp3");
startActivity(it);
Uri uri = Uri.withAppendedPath(MediaStore.Audio.Media.INTERNAL_CONTENT_URI, "1");
Intent it = new Intent(Intent.ACTION_VIEW, uri);
startActivity(it);

//Uninstall

Uri uri = Uri.fromParts("package", strPackageName, null);
Intent it = new Intent(Intent.ACTION_DELETE, uri);
startActivity(it);

//uninstall apk

Uri uninstallUri = Uri.fromParts("package", "xxx", null);
returnIt = new Intent(Intent.ACTION_DELETE, uninstallUri);

//install apk

Uri installUri = Uri.fromParts("package", "xxx", null);
returnIt = new Intent(Intent.ACTION_PACKAGE_ADDED, installUri);

//play audio

Uri playUri = Uri.parse("file:///sdcard/download/everything.mp3");
returnIt = new Intent(Intent.ACTION_VIEW, playUri);

//invia extra

Intent it = new Intent(Intent.ACTION_SEND);
it.putExtra(Intent.EXTRA_SUBJECT, "The email subject text");
it.putExtra(Intent.EXTRA_STREAM, "file:///sdcard/eoe.mp3");
sendIntent.setType("audio/mp3");
startActivity(Intent.createChooser(it, "Choose Email Client"));

//search
//where pkg_name is the full package path for an application

Uri uri = Uri.parse("market://search?q=pname:pkg_name");
Intent it = new Intent(Intent.ACTION_VIEW, uri);
startActivity(it);

//show program detail page
//app_id è l’application ID sul Market

Uri uri = Uri.parse("market://details?id=app_id");
Intent it = new Intent(Intent.ACTION_VIEW, uri);
startActivity(it);

//cerca con google – search google

Intent intent = new Intent();
intent.setAction(Intent.ACTION_WEB_SEARCH);
intent.putExtra(SearchManager.QUERY,"searchString")
startActivity(intent);

http://www.bogliaccino.it/corso-android-10-array-e-adapter/

Corso Android #10 – Array e adapter

Corso Android #10

Array e adapter

ListView

● Componente comunemente usato in una GUI su Android: la lista scrollabile
● Ogni elemento è a sua volta una View
● Quindi la ListView è un ViewGroup pur non essendo un layout
● Ci sono altri casi simili
– Gallery, CalendarView, DatePicker…

Array

Se le view contenute nella ListView sono statiche

  • Si definisce un array di risorse in res/values
  •  Si imposta l’attributo android: entries del tag <ListView> con un riferimento alla risorsa array

Approccio con vantaggi e svantaggi

  • Comodo quando i valori vanno configurati:
  • Per lingua, nazione, carrier, ecc.
  • Limitato sui dati visualizzabili:
  • Solo statici, solo testi semplici
Res/values/arrays.xml

Più spesso, i dati da visualizzare in una ListView sono dinamici
● Generati dal programma
● Estratti da un database
● Ottenuti da un servizio web
● Ecc.

In questi casi, si accoppia una ListView a un Adapter

● ArrayAdapter, CursorAdapter, ListAdapter, …

Un Adapter ha diversi compiti
● Ottenere i dati “grezzi” per una entry
● Costruire una View che rappresenti graficamente i dati “grezzi”
● Fornire la View al ViewGroup a cui l’Adapter è associato
● Notificare gli Observer quando i dati cambiano
● Alcuni altri compiti “amministrativi”
● È sempre possibile scrivere propri Adapter custom

Le diverse sottoclassi di Adapter traducono diversi formati di dati “grezzi”
● ArrayAdapter<T>: un array (Java) di elementi di tipo T
● Vari costruttori, con parametri:
● Context (per accedere alle risorse)
● ID del layout (XML) da utilizzare
● ID della TextView dentro il layout da popolare con i dati
● T[ ] o List<T> contenente i dati “grezzi”

altre forme di Adapter

  • CursorAdapter

– Adatta i risultati di una query SQL

  • ResourceCursorAdapter

– Adatta un array di risorse XML come se fosse un database

  • SimpleCursorAdapter

– Usa i risultati di una query SQL come identificatori per accedere
a testi e immagini fra le risorse XML

  • SimpleAdapter

– Usa una ArrayList<Map>, una riga per entry, una chiave nella
Map per ogni campo della riga (stringhe, booleani, immagini)

 

Oltre a visualizzare dati (con scroll), le ListView sono spesso usate per consentire all’utente delle scelte
● Attivare un elemento da una lista (azione → button)
● Scegliere un elemento da una lista (opzione → radio)
● Selezionare zero o più elementi da una lista (opzione → check)
● Espandere o collassare sezioni di una lista gerarchica (navigazione → tree)

Per riconoscere il click su un elemento;
● Si implementa l’interfaccia OnItemClickListener
● Lo si associa alla lista con setOnItemClickListener()
● Si aspetta che venga chiamato onItemClick()

ListActivity

Android fornisce una sottoclasse di Activity specializzata per contenere ListView
● Il layout di default contiene due view:
– La ListView, con id “@android:id/list” (= “list”)
– Opzionalmente, una view per il caso di lista vuota, con id “@android:id/empty”
● È anche possibile usate setContentView() per sostituire un proprio layout a quello di default
– Il proprio layout deve però contenere una ListView “list” e opzionalmente la view “empty”

http://www.bogliaccino.it/corso-android-7-view-e-layout/

Corso Android #7 – View e Layout

Corso Android #7

View e Layout

view

Una UI Android è un albero con foglie di classe  View e nodi intermedi di classe ViewGroup
● tipicamente definito in XML
● ogni View è una classe Java con nome uguale al tag XML relativo

La disposizione visuale delle view è regolata da un Layout

A run-time, esiste un albero di oggetti Java che creato a partire dall’albero XML del layout
● Gli oggetti possono ricevere input dall’utente (si interfacciano col sistema touch)
● Quando si verifica un evento significativo, viene chiamato un handler
● La vostra Activity può registrare propri handler
● In Java, sono inner interfaces dentro la classe View
● Ogni interfaccia definisce un metodo on…Listener()

i costruttori

● View(Context c)
– Costruttore di base, associa la view al suo context (tramite il quale accedere, per esempio, alle risorse)
● View(Context c, AttributeSet attr)
– Costruttore chiamato quando la view viene creata a partire dalla specifica XML in un file di layout
– Da attr si possono ottenere i valori degli attributi, tramite metodi getter come getAttribute<tipo>Value(String namespace, String attributo, <tipo> valoreDefault)
● View(Context c, AttributeSet attr, int stile)
– Costruttore che in aggiunta applica uno stile (identificato dal suo ID di risorsa)

View(): non si può avere una view senza il suo contesto

 layout

  • AbsoluteLayout  Coordinate assolute (x,y) per ogni componente
  • LinearLayout  Serie verticale o orizzontale di componenti
  • RelativeLayout  Posizione di ogni componente relativo agli altri
  • GridLayout Griglia di celle di uguale dimensione; componenti a cavallo di più celle
  • FrameLayout  Componenti uno sull’altro (l’ultimo aggiunto sta in cima) – solitamente usato con un solo componente
  • TableLayout  Griglia di celle di dimensione variabile (dinamicamente); un componente per cella (salvo eccezioni, come in HTML)
  • È sempre possibile comporre layout o scrivere i propri Layout Manager

 

http://www.bogliaccino.it/corso-web-standard-1/

Corso WEB Standard 1 – ITS

Regole dei fogli di stile

come l'(X)HTML anche un foglio di stile è un  documento di testo composto da

  • selettori: individuano gli elementi coinvolti 
  • dichiarazioni: costituite da una o più proprietà con il relativo valore che specifica l’azione da intraprendere

esempio di regola di stile

h1 {color: #ffcc00;}

Le pseudo-classi
non sono riferite ad un elemento come le classi e gli id ma applicano delle proprietà ai diversi stati di uno stesso elemento.
Per esempio un comunissimo link? All’inizio ha un colore, poi passandoci sopra con il cursore questo colore cambia
ed infine il link già visitato non ha più il colore iniziale. Ecco le pseudo-classi ti permettono di agire su ognuno questi diversi stati.
Di seguito le pseudo-classi supportate da tutti i browser:
:link
:visited
:hover
:focus
:active


esempio psudo-classe


<h1>Titolo in verde</h1>
<p>Lorem ipsum dolor sit amet, consectetur adipisici,
<a href="url.html class="nomeclasse">sed eiusmod</a>
tempor incidunt ut labore et dolore magna aliqua.</p>
<style type="text/css">
a.nomeclasse:link {
color: #006600;
}
a.nomeclasse:hover {
color: #000000;
}
</style>

Pseudo-elementi
come per le pseudo-classi non sono riferiti ad un elemento
in particolare ma ne selezionano una sotto parte.
Ad esempio:
:first-letter
:first-line
:before
:after
puoi applicare pseudo classi e pseudo elementi
a tutti gli elementi di un documento html.
Altre proprietà

text-align (left, right, center, justify)
text-transform (capitalize, uppercase, lowercase, none)
font-variant (small-caps, none)
text-decoration (underline-overline, line-trought, blink, none)
line-height
background
letter-spacing
word-spacing
text-indent
white-space (pre, nowrap, none)
text-shadow (colore, valore x, valore y, valore sfocatura)

Le proprietà di background

background-image (url, none)
background-color: (valore colore, transparent)
background-repeat (repeat-x, repeat-y, no-repeat)
background-position (left, right, top, bottom, center)
background-attachment (fixed, attachment)

esempio inserimento background
div {
background-image: url(img/bg.png);
background-repeat: no-repeat;
background-color: #CCCCCC;
}

div {
background: url(img/bg.png) no-repeat #CCCCCC;
}

I divisori
sono gli elementi che utilizzeremo per strutturare la nostra
pagina web e sono caratterizzati dal tag <div> e ci aiuteranno a
sezionare la nostra pagina e a raggruppare più elementi.
Le proprietà

width (larghezza relativa allo spazio per i contenuti)
height (altezza relativa allo spazio per i contenuti)
padding (spazio fra contenuti ed il bordi)
border (solid, dotted, dashed, double, groove, ridge, inset, outset, none)
margin (spazio fra il bordo e gli altri oggetti della pagina)
position (relative, absolute, fixed)
float (left, right)
z-index
vertical-align (baseline, middle, sub, super, text-top, text-bottom, top, bottom)
overflow (visible, hidden, scroll, auto)

Il visual formatting model
insieme al box model è uno degli elementi fondamentali per la realizzazione di impaginazioni complesse.
Il visual formatting model tratta essenzialmente il comportamento di un box in relazione agli altri presenti nella stessa pagina e ne
definisce il posizionamento.
Position
è la proprietà fondamentale per la gestione della posizione degli elementi sulla pagina. Si applica a tutti gli elementi e non è
ereditaria.
I valori di position sono:

static (valore di default)
absolute
fixed
relative

Il flusso e la posizione relativa
ogni elemento ha una posizione naturale nel flusso della pagina,
lo spostamento degli elementi in relazione alla posizione originale
prende il nome di “posizionemento relativo” e non influisce sugli
elementi circostanti. La regola per agire su questa proprietà è:
position: relative;
La posizione viene determinata attraverso le seguenti proprietà:

top
right
left
bottom

div.relativo {
position:relative;
left:10px;
top: 10px;
}

Il posizionamento assoluto
con la dichiarazione position:absolute è possibile posizionare il box in un
punto esatto della pagina indipendentemente dal flusso e non ha alcuna
influenza sulla posizione degli altri blocchi.
La posizione viene determinata attraverso le proprietà: top, right, bottom, left
a partire da un determinato punto di riferimento iniziale.
L’elemento assoluto è posizionato in rapporto al suo div “contenitore” posto
che anche quest’ultimo abbia la sua proprietà position impostata con un
valore diverso da “static”.
Diversamente l’elemento con proprietà position:absolute si posizionerà in
base all’elemento radice HTML (normalemente, l’area visiva della finestra del
browser) sempre in alto a sinistra.
Un elemento posizionato in modo assoluto scrorre insieme al resto del
documento.


div.assoluto {
position: absolute;
right: 0;
bottom: 0;
width:500px;
}

Posizionamento fisso
con la dichiarazione position:fixed il box dell’elemento viene, come
per absolute, sottratto al normale flusso del documento. La differenza
sta nel fatto che per fixed il box contenitore è sempre il cosiddetto
viewport (l’area interna del borwser).
La caratteristica sostanziale è che un box in posizione fissa non
scorre con il resto del documento rimanendo fisso nella posizione che
abbiamo definito.

div.fixed {
position: absolute;
left: 0;
top: 500px;
width: 150px;
height: 200px;
}

Controllare Il flusso
La proprietà clear impedisce ad un elemento di fluire accanto ad un
altro. Si applica solo agli elementi blocco e non è ereditata.
la necessità di questa regola nasce dal fatto che il float sposta un
elemento dal flusso normale del docuemento ed è possibile che
esso venga a trovarsi in una posizione non desiderate, magari al
fianco di altri elementi che vogliamo invece tenere separati.
Clear risolve questo problema.

none - Gli elementi con float possono stare a destra e sinistra
right - impedisce il posizionamento degli elementi a destra
left - impedisce il posizionamento degli elementi a sinistra
both - impedisce il posizionamento degli elementi a destra e sinistra

Z-index
quando si usa il posizionamento assoluto o relativo è possibile che
gli elementi si sovrappongano. Per decidere quale elemento deve
stare più in alto si utilizza la proprietà z-index.
funziona solo per gli oggetti in posizione relativa o assoluta
il valore più alto indica che l’oggetto sta in posizione prioritaria
i valori possono essere positivi e negativi
la proprietà non è ereditaria


div.assoluto {
position: absolute;
right: 0;
bottom: 0;
width:500px;
z-index: 2;
}

div.assoluto_sotto {
position: absolute;
right: 200px;
bottom: 100;
width:500px;
z-index: 1;
}

Overflow
quando il contenuto del nostro riquadro è più grande del riquadro
stesso (che sia un testo o un’immagine) può essere controllato grazie
alla prorietà overflow.

visible (default)
hidden
scroll
auto

div.box_overflow {
position: absolute;
right: 0;
bottom: 0;
width:500px;
overflow: auto;
}

Display
conosciamo la differenza tra gli elementi block e inline.
la proprietà display è molto utile in quanto permette di variare la
visualizzazione dell’elemento (nasconderlo o trasformarlo in un
elenco) o di cambiare la sua natura (block level, inline).

none
block
inline
list-item

Visibility
da non confondere con il display:none. La proprietà visibility
permette di nascondere un elemento della pagina il quale però
non viene eliminato dal flusso.
In breve se display:none nasconde un elemento dalla pagina
rendendolo completamente invisibile, impostando un elemento
visibility: hidden al posto dell’elemento verrà visualizzato uno
spazio vuoto.

visible (default)
hidden

Il float
è la proprietà che utilizzerai maggiormente anche se all’inizio la sua
gestione potrà sembrarti problematica.
La w3c definisce il float come segue:
“…un box che viene spostato a sinistra o a destra rispetto la
riga corrente. La caratteristica più interessante di un float è che
il contenuto può scorrere lungo il suo lato (o lo si può impedire
attraverso la proprietà “clear”).
Il contenuto si posiziona lungo il lato destro di un box flottato a
sinistra e sul lato sinistro di un flottato riquadro a destra.”
La prorietà float non è ereditaria ed ha tre valori:

left
right
none

Collassare i margini
l’espressione collassare i margini [collapsing margins] significa che
margini adiacenti (non li separa nessuna area di bordo o padding) di due
o più riquadrati (che possono essere vicini l’uno all’altro o annidati) si
combinano per formare un singolo margine.
Nei CSS2, i margini orizzontali non collassano mai.
I margini verticali possono collassare ad esempio ciò accade con i
margini verticali di più paragrafi in successione. Un approfondimento:
Caratteristiche
I blocchi flottanti consecutivi si dispongono uno di fianco
all’altro. Ad esempio se più box hanno la proprietà float:left
questi si disporanno uno accanto all’altro “spingendosi”
verso sinistra.
Se lo spazio non è sufficiente a contenere i diversi blocchi,
quelli in eccesso verranno disposti al di sotto degli altri.
Se ad uno dei box assegno la proprietà clear posso impedire
che il box successivo si affianchi.
Ricorda

che il padding e il border si sommano alla
dimensione del nostro box!
Se ad esempio un box ha una larghezza di
200px e un padding totale (top, right, left,
bottom) di 5px la sua larghezza reale sarà di
210px. Se non calcoli bene la larghezza dei box
farai molta fatica a strutturare il tuo layout.

Altre caratteristiche
Se ad un elemento viene assegnata la proprietà float, questo
verrà tolto dal normale flusso e sarà posizionato nel punto
più a sinistra (o a destra) possibile rispetto al suo contenitore
(che potrebbe essere anche il body).
Se ad un box non viene assegnata nessuna dimensione questa
verrà determinata dal suo contenuto. Se invece ne assegni solo
una, ad esempio la larghezza, l’altra si adatterà di conseguenza.
Assegnando ad in box i margini laterali “auto” (margin: auto)
questo si posizionerà al centro in orizzontale della pagina.

http://alistapart.com/article/css-floats-101

comporre un layout

In breve
la prima cosa cosa che dovrai fare è sicuramente creare il tuo
wrapper, ovvero il main box che conterrà tutti gli altri.
Questo sarà il punto di riferimento dentro il quale verranno
posizionati tutti i tuoi div (escluso quelli in posizione assoluta
e in tutti quei casi che abbiamo spiegato nella lezione
precedente).
Il mio consiglio personale è quello di flottare sempre i tuoi box
dallo stesso lato anche se opposti.

formattare i moduli

I moduli
Le parti fondamentali di un modulo sono due:
l’insieme di campi, etichette e pulsanti che l’utente
compila e lo script che permette il funzionamento del
modulo ovvero l’invio delle informazioni.
La formattazione dei moduli è molto semplice e grazie
all’utilizzo dei css è possibile personalizzare ogni
elemento.

Etichette <label>

Casella di testo <input type=”text”>
Elenco a discesa <select><option>
Casella di controllo <input type=”checkbox”>
Pulsante invio <input type=”submit”>
Area di testo <textarea>

Per iniziare
un modulo deve essere racchiuso all’interno dei tag <form>, elemento
block level che necessita di alcuni attributi per poter funzionare:
action per indirizzare il modulo al server, all’ URL o all’indirizzo di
posta elettronica.
method per dichiarare con quale dei due possibili metodi, post o get,
si devono trasmettere i dati.
id (facoltativo) Il nome che preferite assegnare al modulo, diventa
indispensabile facendo uso di JavaScript o altro linguaggio di
programmazione che diversamente non saprebbe a quale modulo fare
riferimento nella pagina web.
Organizzazione dei contenuti
Qualora volessimo ragruppare in macro aree le
informazioni di un modulo è possibile utilizzare i tag
<fieldset> e <legend>.


<form>
<fieldset>
<legend>Personali:</legend>
Name: <input type="text" size="30" /><br />
Cognome: <input type="text" size="30" /><br />
Data di nascita: <input type="text"/>
</fieldset>
<fieldset>
<legend>Altro:</legend>
Email: <input type="text" size="30" /><br />
</fieldset>
</form>

Il tag <input>
Il tag più utilizzato per creare i campi di un form è il tag
<input> che non richiede chiusura.
Ad ogni <input> deve essere associato ad un attributo che
ne determini la tipologia, il nome (ad esempio per interagire
con JavaScript) e il valore (il testo visualizzato).


<form method="post" action="showform.php">
<fieldset>
<legend>Personali:</legend>
Name: <input type="text" name="nome"/><br />
Cognome: <input type="text" name="cognome" /><br />
Data di nascita: <input type="text" name="data"/>
</fieldset>
</form>

<form method="post" action="showform.php">
<fieldset>
<legend>Personali:</legend>
Name: <input type="text" name="nome"/><br />
Password: <input type="password" name="pass" maxlength="10" />
</fieldset>
</form>

Pulsanti d’opzione e pulsanti di controllo
sono degli elementi molto utili all’interno di un form e permettono
all’utente di effettuare delle scelte.
Il pulsante di opzione (type=”radio”) a differenza del pulsante di
controllo (type=”checkbox”) permette di fare una sola scelta.
Ad entrambi gli elementi possono essere associati i seguenti attributi.
name: identifica i dati inviati allo script
value: il valore che verrà inviato al server
checked: per far si che il pulsante sia attivo per default


<form method="post" action="showform.php">
<fieldset>
<legend>Scegli la taglia:</legend>
Small: <input type="radio" name="scegli" value="S"/><br />
Medium: <input type="radio" name="scegli" value="S"/><br />
Large: <input type="radio" name="scegli" value="S"/>
</fieldset>
</form>

<form method="post" action="showform.php">
<fieldset>
<legend>Vuoi iscriverti alla newsletter?</legend>
<input type="checkbox" name="nl" value="yes" checked="checked"/>
</fieldset>
</form>

Etichette
Accanto ad ogni elemento di un form possiamo inserire un
semplice testo indentificativo. Ad esempio accanto ad un <input>
per l’inserimento del nome potremmo scrivere semplicemente
“Nome”. XHTML ha un tag apposito ovvero <label>
Un’attributo di label è “for” che consente di associare l’etichetta
all’elemento “id” dell’elemento corrispondente (che avranno lo
stesso valore).


<form method="post" action="showform.php">
<label for="nome">Nome</label>
<input type="text" value="inserisci" id="nome"/>
<label for="cognome">Cognome</label>
<input type="text" value="inserisci" id="cognome"/>
</form>

Elenchi a discesa
sono la migliore soluzione per offrire agli utenti una scelta tra più opzioni
predefinite. Il tag per questo tipo di elemento è <select> dentro il quale
inseriremo i tag <option> per definire ogni singola scelta.
Il tag <select> può presentare i seguenti attributi:
Il tag <option> può presentare i seguenti attributi:
name: identifica i dati inviati allo script
multiple: consente la selezione multipla attraverso il tasto CTRL o CMD
selected: per selezionare una voce di default
value: consente la selezione multipla attraverso il tasto CTRL o CMD


<form>
<fieldset>
<legend>Siti web</legend>
<select name="siti" >
<option value="http://www.sito.it" selected="selected">Vai al sito</option>
<option value="http://www.sito-due.it">Vai al sito 2</option>
<option value="http://www.sito-tre.it">Vai al sito 3</option>
</select>
</fieldset>
</form>

<form>
<fieldset>
<legend>Siti web</legend>
<select name="siti" >
<optgroup label="Web Design">
<option value="http://www.sito.it" selected="selected">Vai al sito</option>
<option value="http://www.sito-due.it">Vai al sito 2</option>
</optgroup>
<optgroup label="Risorse">
<option value="http://www.sito-a.it">Vai al sito</option>
<option value="http://www.sito-b.it">Vai al sito 2</option>
</optgroup>
</select>
</fieldset>
</form>

Area di testo
il tag <textarea> permette di creare degli spazi all’interno di un
modulo in cui l’utente può scrivere del testo. A differenza delle normali
aree di testo possono essere più grandi e quindi contenere più righe.
A ogni textarea possono essere associati i seguenti attributi:

name: identifica i dati inviati allo script

rows: definire il numero di righe

cols: definire la larghezza

rows e cols non sono obbligatori, è preferibile formattare la textarea
tramite CSS per definire altezza e larghezza


<form method="post" action="showform.php">
<label for="messaggio">Lascia un messaggio</label>
<textarea name="testo" rows="5" cols="40" id="messaggio">
Inserire qui il testo
</textarea>
</form>


<form method="post" action="showform.php">
<label for="messaggio">Lascia un messaggio</label>
<textarea name="testo" class="nomeclasse" id="messaggio">
Inserire qui il testo
</textarea>
</form>

Altri elementi di un form
<input type=”file”> permette di creare una casella per il carimento di file.
<input type=”submit”> bottone per l’invio del modulo, fondamentale.
<input type=”reset”> bottone per ripristinare il modulo.
<input type=”hidden”> per nascondere un campo input.
<input type=”image”> creare un’immagine attiva.
<button type=”submit”> bottone per l’invio del modulo con immagine.
Altri attributi
tabindex=n per ordinare la navigazione del form tramite il tasto tab.
accesskey=x per impostare le scorciatoie di tastiera.
disable=”disabled” disabilita un elemento.
readonly=”readonly” disabilita la scrittura.
Ricorda
puoi personalizzare ogni caratteristica di questi
elementi attraverso i CSS. Altezza, larghezza,
bordo, sfondo, tipo di carattere, margini etc.
Questo permetterà di rendere i tuoi form ancora più
usabili e sicuramente più gradevoli.
Puoi formattare direttamente il selettore o applicare
una classe come faresti con qualunque altro tag.