+-----------------------------------------------------------------------+
|                                                                       |
|                                                                       |
|                      Lezione Numero 5 di Java                         |
|                                                                       |
+-----------------------------------------------------------------------+
|                                                                       |
|                                                                       | 
|Autore: Brnocrist                                                      |
|Mail: brnocrist@libero.it                                              |
|                                                                       |
+-----------------------------------------------------------------------+
|Bene dopo le cose che sono presenti in quasi tutti i linguaggi,passiamo| 
|a spiegare un po' cosa sono le classi e cominciare a ragionare ad      |
|oggetti,anche se e' dura ma java e' un linguaggio molto potente e      |
|portabile =)                                                           |
|Si pensi ad un oggetto come una variabile particolare, memorizza dati, |
|ma si possono fare richieste a quel oggetto, chiedendo di eseguire     |
|operazioni su se stesso.                                               | 
|Un programma è un gruppo di oggetti che si dicono cosa fare l'un altro | 
|scambiandosi messaggi. Per fare una richiesta ad un oggetto, si manda  |  
|un messaggio a quell'oggetto. Ogni oggetto ha la sua memoria fatta di  |
|altri oggetti.                                                         |
|Come nel caso della creazione di una variabile contenente un tipo di   | 
|dati primitivo, si distinguono due fasi: la dichiarazione e            |
|l'inizializzazione. Siccome e' un oggetto, l'inizializzazione          |
|richiede prima la creazione dell'oggetto stesso, in modo da poter      |
|assegnare alla variabile il riferimento all'oggetto stesso.            |
|Se non facciamo un esempio non ci capiremo una mazza =)                |
+-----------------------------------------------------------------------+
 
String MiaStringa;

+-----------------------------------------------------------------------+
|Con questo sistema abbiamo solo creato la "scatola" che contiene       |
|l'oggetto, adesso per allocare memoria e riempire la "scatola" ci serve| 
|l'operatore "new", vediamo...                                          |
+-----------------------------------------------------------------------+

String MiaStringa = new String("Ciao Napoli!");

+-----------------------------------------------------------------------+
|L'inizializzazione di un oggetto viene svolta da un metodo             | 
|specializzato per questo scopo: il costruttore. Una classe può fornire |
|diversi metodi costruttori che possono servire a inizializzare in modo |
|diverso l'oggetto che si ottiene.                                      |
|Adesso proviamo a fare qualche esempio con gli oggetti.Si indica una   | 
|variabile o un metodo di un oggetto aggiungendo un punto (.) al        |
|riferimento dell'oggetto, seguito dal nome della variabile o del metodo| 
|da raggiungere. Variabili e metodi si distinguono perché questi ultimi |
|possono avere una serie di argomenti racchiusi tra parentesi (se non   |
|hanno argomenti, vengono usate le parentesi senza nulla all'interno).  |
+-----------------------------------------------------------------------+

riferimento_all'oggetto.variabile 

riferimento_all'oggetto.metodo() 

+-----------------------------------------------------------------------+
|oggetto.variabile, significa raggiungere una variabile appartenente a  | 
|una particolare struttura di dati, che è appunto l'oggetto. In un certo|
|senso, ciò si avvicina all'accesso a un elemento di un array.          |
|Invece un po' complesso è comprendere il senso di un metodo di un      |
|oggetto.                                                               | 
|Indicare oggetto.metodo() significa chiamare una funzione che          | 
|interviene in un ambiente particolare: quello dell'oggetto.            |
|Vediamo un esempio con gli oggetti...                                  |
+-----------------------------------------------------------------------+

class Moltiplicazione
{
    public int x;
    public int y;
    public calcola ()
    {
        return x*y;
    }
}

+-----------------------------------------------------------------------+
|Se venisse creato un oggetto a con questa classe, si potrebbe          |
|modificare il contenuto delle variabili e richiamare la "funzione"     | 
|calcola come nell'esempio seguente:                                    |
+-----------------------------------------------------------------------+

Moltiplicazione mult = new Moltiplicazione();
mult.x = 10;
mult.y = 5;
System.out.println ("Il risultato è " + mult.calcola ()); 

+-----------------------------------------------------------------------+
|Credo ceh ci sia poco da dire, sembra tutto motlo chiaro, nella prima  |
|abbiamo dichiarato una variabile a quell'oggetto e successivamente     |
|utilizzata. Adesso passiamo alle classi.                               | 
|Le classi sono lo stampo da cui si ottengono gli oggetti. La sintassi  |
|per la creazione di una classe è la seguente.                          |
+-----------------------------------------------------------------------+

MODIFICATORE class NomeClasse extends classe_superiore {
...
...
}

+-----------------------------------------------------------------------+
|Le parentesi graffe fanno parte dell'istruzione per delimitare il      | 
|contenuto, ovvero il corpo, costituito dalla dichiarazione di variabili| 
|e metodi. Di solito, il nome di una classe inizia con una lettera      |
|maiuscola.                                                             |
|Il modificatore può essere costituito da uno dei nomi seguenti:        |
|                                                                       |
|public: quando la classe è accessibile anche al di fuori del pacchetto | 
|        di classi cui appartiene.Se questo non viene indicato, la      |
|        classe è accessibile solo all'interno del pacchetto cui        | 
|        appartiene.                                                    |
|                                                                       |
|abstract: quando una classe serve solo come modello astratto per       | 
|          generare altre sottoclassi.                                  | 
|                                                                       |
|final: quando si vuole evitare che una classe possa generare altre     |
|       sottoclassi.                                                    |
|                                                                       |
|Tutte le classi ereditano automaticamente dalla classe java.lang.Object| 
|quando non viene dichiarano espressamente di ereditare da un'altra.    | 
|                                                                       |
|A fianco dell'eredità da un'altra classe, si abbina il concetto di     | 
|interfaccia, che rappresenta solo un'impostazione a cui si vuole fare  | 
|riferimento. Questa impostazione non è un'eredità, ma solo un modo per |
|definire una struttura standard che si vuole sia attuata nella classe  |
|che si va a creare.                                                    |
+-----------------------------------------------------------------------+

/**
 *      Esempio.java
 */

class Esempio
{
    static int variabileStatica = 0; // variabile statica o di classe
    int variabileDiIstanza = 0;  // variabile di istanza

    
    public static void main (String[] args)
    {
        // Se viene avviata questa classe da sola, viene visualizzato
        // il messaggio seguente.
        System.out.println ("Ciao!");
    }

    // Metodo statico. Può essere usato per accedere solo alla
    // variabile statica.
    public static void metodoStatico ()
    {
        variabileStatica++;
System.out.println("La variabile statica ha raggiunto "+ variabileStatica);
    }

    // Metodo di istanza. Può essere usato per accedere sia alla
    // variabile statica che a quella di istanza.
    public void metodoDiIstanza ()
    {
        variabileStatica++;
        variabileDiIstanza++;
System.out.println("La variabile statica ha raggiunto"+ variabileStatica);
System.out.println("La variabile di istanza ha raggiunto"+ variabileDiIstanza);
    }
}

+-------------------------------------------------------------------------+
|e pensa a quello che ti farei se fossimo in un paradiso grigio           |
|come piace a me                                                          |
|che dicon tutti che sono un po' strano                                   |
|e pensano che nn sono umano                                              |
|soltando perche' diverso come piace a me                                 |
|                                                                         |
|TnX Syscall, harada, {LoSt}, ^SiD^, mR_bIs0n, Maxtor, don, reizier,      | 
|Virgeles, siamo quaaaaaaaaaa only youuuuuuuu M|y4 :****                 |
+-------------------------------------------------------------------------+