AndroidLab

Il Laboratorio Italiano Android e Google Chrome

Inizia su Androidlab una serie di tutorial per familiarizzare con Java, il linguaggio di programmazione utilizzato per sviluppare applicazioni Android. Il nostro obiettivo è quello di preparare chi ha già familiarità con un linguaggio di programmazione, come PHP o C/C++, a sentirsi a proprio agio con il linguaggio di programmazione Java e tuffarsi nello sviluppo di applicazioni Android.
Apprendere Java per programmare Android
In questo primo tutorial, si leggerà una breve introduzione ai fondamenti di Java, tra cui la programmazione orientata agli oggetti, l’ereditarietà e altro ancora.

Sia che siate completamente a digiuno di Java, o semplicemente un po’ arrugginiti e volete rispolverarne i dettagli questo tutorial potrebbe esservi di aiuto.

Seppure potrebbe risultare poco ortodosso negli esempi di codice ho preferito utilizzare la lingua italiana per i nomi delle variabili, delle classi e  dei metodi nella speranza che risulti più chiaro al lettore neofita.


Cosa occorre per iniziare

Per sviluppare applicazioni Android (o qualsiasi applicazione Java), è necessario un ambiente di sviluppo. Eclipse è un ambiente di sviluppo (IDE) molto popolare tra gli sviluppatori Java ed è l’IDE di riferimento per lo sviluppo in Android. È disponibile gratuitamente per Windows, Mac e sistemi operativi Linux.

Per le istruzioni complete su come installare Eclipse e l’SDK di Android, vedere il sito web degli sviluppatori Android.

Che cosa è Java?

Le applicazioni Android sono sviluppate utilizzando il linguaggio Java.

Java è un linguaggio di programmazione, molto popolare sviluppato da Sun Microsystems (ora di proprietà di Oracle). Sviluppato molto tempo dopo C e C + +, Java, incorpora molte delle caratteristiche di questi potenti linguaggi pur mitigando alcuni dei loro svantaggi.  Molta della potenza dei linguaggi di programmazione dipende dalle librerie di cui dispongono. Le librerie sono state create per aiutare gli sviluppatori a scrivere applicazioni.

Le principali caratteristiche di Java, citando i creatori del linguaggio, sono:

  • È Semplice e facile da imparare e capire
  • È Orientato agli oggetti,
  • È Robusto
  • È Sicuro
  • È Neutrale rispetto all’architettura. Progettato per essere indipendente dalla piattaforma
  • È Portabile grazie all’utilizzo delle “virtual machines”
  • È Interpretato
  • È Altamente performante
  • È Multithreaded
  • È Dinamico

Android si basa su questi fondamenti di Java. L’ SDK Android include numerose librerie standard di Java (struttura dei dati, librerie matematiche, librerie grafiche, librerie di rete e quant’altro si possa desiderare), così come librerie esclusive di Android che vi aiuteranno a sviluppare splendide applicazioni Android.

Perché Java è facile da apprendere?

Java è facile da imparare per una serie di motivi. Primo fra tutti l’abbondanza di risorse per l’apprendimento del linguaggio , tra cui siti web, tutorial, libri e lezioni.

Java è uno dei linguaggi di programmazione più dibattuti, insegnati, e utilizzati sul pianeta. È usato per diversi tipi di progetti, dalle applicazioni web alle applicazioni desktop passando per le applicazioni mobili.

Se provenite da un linguaggio di programmazione tradizionale come C o C + +, troverete la sintassi Java abbastanza simile, se provenite da altri linguaggi non avrete comunque problemi nell’apprendimento di Java. Sarete operativi in pochissimo tempo.

Per finire, possiamo dire che Java è uno dei linguaggi più comprensibili anche per coloro i quali sono completamente a digiuno di programmazione, considerando il seguente codice

1
2
3
4
5
6
7
char carattere = 'a';
if(carattere =='a')
{
    faiQualcosa();
} else {
    faiQualcosaltro();
}

si può tranquillamente comprendere quello che questa porzione (snippet) di codice sta facendo:

Si crea una variabile chiamata carattere assegnandole il valore a . Successivamente si verifica se la variabile carattere è uguale  alla lettera “a” , in questo caso faremmo qualcosa, invocando il metodo  faiQualcosa() , altrimenti faremmo qualcosa di diverso, invocando il metodo faiQualcosaltro().

Perché l’indipendenza dalla piattaforma è importante?

In molti linguaggi di programmazione, è necessario utilizzare un compilatore per tradurre il codice sorgente scritto in linguaggio di alto livello in codice di basso livello eseguibile dal dispositivo. Sebbene questo sia utile, i diversi dispositivi non utilizzano il medesimo codice di basso livello. Questo significa che potrebbe essere necessario compilare le applicazioni per ogni dispositivo sul quale si intende far girare il nostro codice sorgente, in altre parole, il codice non è molto portabile. Questo non è il caso di Java. I compilatori Java convertono il codice sorgente in “bytecode“. Questo codice viene interpretato dalla  Java Virtual Machine, uno strato software posto tra il linguaggio di alto livello e l’hardware, che si occupa ti tradurre il “bytecode” in codice di basso livello eseguibile dalla CPU fisica. Il vantaggio di questo approccio è che possiamo scrivere codice Java ed eseguirlo su qualsiasi dispositivo dotato di una Java Virtual Machine. Anche se tutto questo potrebbe sembrare inefficiente, l’ottimizzazione di questo processo ha reso l’interpretazione del “bytecode” molto veloce ed efficiente.

Le applicazioni Android sono eseguite da una speciale Virtual Machine chiamata Dalvik. Da sottolineare che seppure il principio di funzionamento è il medesimo, il bytecode prodotto dalla Dalvik è diverso da quello prodotto dalla Java Virtual Machine Standard e che in futuro l’SDK Android potrebbe implementare l’utilizzo di altri  linguaggi, che verrebbero ugualmente compilati in bytecode Dalvik.  Può essere utile pensare alla Dalvik Virtual Machine come ad una bolla in cui l’applicazione Android è in esecuzione, consentendoci di non dover preoccuparci se il dispositivo è un Motorola Milestone, un Nexus One o un Galaxy S.

Perche Java è sicuro?

Poiché le applicazioni Java sono eseguite all’interno della bolla, che sarebbe la macchina virtuale, sono isolate dal dispositivo hardware sottostante. Dunque, una macchina virtuale può incapsulare, contenere e gestire l’esecuzione di codice in modo sicuro rispetto ai linguaggi che operano direttamente in “codice macchina”. La piattaforma Android porta questo concetto ad un livello superiore.

Infatti ogni applicazione Android gira nel sistema operativo (basato su kernel Linux) con un differente account utente e con una propria istanza diella Dalvik. Le applicazioni Android sono strettamente controllate dal sistema operativo e sono terminate se non girano in maniere efficiente (ad esempio, usano troppa capacità di elaborazione, non rispondono, o più generalmente sprecano risorse, ecc.) Pertanto, è importante sviluppare applicazioni che siano stabili e reattive. Le applicazioni possono comunicare tra loro utilizzando protocolli ben definiti.

Compilazione del codice

Come abbiamo già accennato, anche Java è un linguaggio compilato, seppure in bytecode e non direttamente in “codice macchina”. Questo significa che, lo sviluppatore, deve compilare i propri progetti e racchiuderli in “pacchetti Android”, gli apk, per distribuire le applicazioni sui vari  dispositivi. L’ambiente di sviluppo Eclipse, utilizzato con l’ Android development plug-in, rende questa operazione abbastanza semplice ed indolore. In Eclipse, infatti, la compilazione automatica è attivata per impostazione predefinita. Questo significa che ogni volta che si salva un progetto, Eclipse ricompila le modifiche. In questo modo è possibile vedere subito gli errori di compilazione. Eclipse, come tutti i moderni IDE,  interpreta Java durante la digitazione, apportando la giusta colorazione e formattazione al codice evidenziando al volo anche molti tipi di errori. Spesso, è possibile fare clic su l’errore affinché Eclipse corregga automaticamente un errore di battitura o aggiunga un’istruzione import, facendoci risparmiare molta battitura.

Se lo si desidera è comunque possibile compilare il codice manualmente. All’interno di Eclipse, troverete tutte le impostazioni di generazione alla voce di menu Project.

Se la voce “Build Automatically” è attivata, è comunque possibile utilizzare l’opzione “Clean …”, per effettuare la rigenerazione completa di tutti i file. Se “Build Automatically” è disattivata, saranno visibile  le opzioni “Build All” e “Build Project”. “Build All” consente di generare tutti i progetti presenti  nel workspace. È possibile avere molti progetti nella medesimo workspace Ecplipse.

Il processo di generazione (build), per i progetti Java standard, produce un file con estensione JAR – Java ARchive. La generazione di  applicazioni Android, produce invece  file con estensione APK, Anndroid PacKage, pronti per essere distribuiti sui vari terminali. Questi pacchetti non solo includono il codice Java compilato, ma anche tutte le altre risorse che l’applicazione richiede per l’esecuzione ,come le immagini o  i file audio  e il file manifesto dell’applicazione (Android Manifest file), AndroidManifest.xml. L’ Android Manifest file è un file necessario in  tutte le applicazioni di Android, usato per definire i dettagli di configurazione dell’applicazione.

Che cosa è un linguaggio di programmazione orientato agli oggetti?

La programmazione orientata agli oggetti (OOP) è uno stile o tecnica  di programmazione basata sulla definizione di strutture di dati chiamati oggetti. Per chi è nuovo di OOP, un oggetto potrebbe essere rappresentato come un tipo di dati personalizzato. Ad esempio, si potrebbe avere un oggetto Automobile, che rappresenta il progetto generico di un automobile avente come attributi una marca, una carrozzeria(es.: berlina,station wagon,2 volumi) ed un  colore. È quindi possibile creare istanze diverse di un oggetto per rappresentare automobili specifiche. Ogni oggetto Automobile deve essere creato con una chiamata al costruttore (un metodo che ha il nome dell’ oggetto stesso, e potrebbe, ma non necessariamente, avere alcuni parametri per la definizione dei valori iniziali). Ad esempio, l’oggetto automobile che segue, utilizza un costruttore con tre parametri (marca, carrozzeria, colore):

1
2
3
Automobile auto1 = new automobile ("Fiat", berlina, bianco);
Automobile auto2 = new automobile ("Ford", monovolume, grigio);
Automobile auto3 = new automobile ("Opel", suv, nero);

Il lettore potrebbe chiedersi a questo punto: “dove si trova la definizione dell’oggetto automobile?” Per rispondere abbiamo bisogno di introdurre uno dei concetti fondamentali del linguaggio di programmazione Java: la classe.

In Java una classe ( class ) fornisce la definizione di un oggetto, pertanto, affinché il codice sopra abbia senso, da qualche parte dovrà essere stata definita una classe Automobile, non importa se l’abbiamo definita noi stessi o  se la definizione si trova in qualche libreria scritta da altri.

In generale, una classe sarà definita in un proprio file, con il nome corrispondente al nome della classe stessa (ad esempio Automobile.java). Ci sono eccezioni a questa regola, come le classi definite all’interno di altre classi (quando una classe è dichiarata all’interno di un’altra  classe, è generalmente definita per l’uso, all’interno della classe genitore, solo come classe di supporto, e ci si riferisce ad essa come classe interna o inner class).

Quando si vuole fare riferimento ad un oggetto già esistente all’interno di una classe, è necessario includere una dichiarazione di importazione o import statement, proprio come si è soliti fare in C utilizzando l’istruzione #include.

Una classe generalmente descrive i dati (proprietà) e il comportamento di un oggetto. Il comportamento è definito usando i metodi. Metodo è il termine comune per chiamare una subroutine in un linguaggio OOP. Molte classi di oggetti sono definite in librerie condivise nei  kit di sviluppo software (SDK), mentre altre sono definite dallo sviluppatore per i propri scopi. Il software è quindi costruito utilizzando e manipolando le istanze degli oggetti in modi diversi a seconda degli scopi che il software si propone di raggiungere

Si tenga presente che questa è una definizione molto generalizzata di OOP, esistono interi libri scritti su questo argomento. Se si desidera approfondire la teoria sulla programmazione ad oggetti si potrebbe iniziare dalle seguenti risorse:

Comprendere i concetti di Incapsulamento, Ereditarietà e Polimorfismo

L’Incapsulamento è una tecnica fondamentale della programmazione orientata agli oggetti. Esso si basa sul principio dell’ information hiding, letteralmente “occultamento delle informazioni”, secondo il quale l’utente non deve conoscere ne preoccuparsi dell’implementazione interna delle informazioni e dei meccanismi che le gestiscono all’interno della classe.

Un esempio ci aiuterà a comprendere meglio il concetto, supponiamo di voler creare una classe rettangolo che calcoli l’area della figura geometrica, potremmo definire come dati privati, utilizzando la parola chiave private per specificare il livello di accesso, le proprietà base ed altezza, incapsulandole e rendendole inaccessibili, se non dall’interno della classe stessa.

Per consentire la modifica delle proprietà dall’esterno definiamo, specificando il livello di accesso con la parola chiave public, i metodi che in questo caso sono detti Mutator, setBase e setAltezza.

Per richiamare i valori dall’esterno definiamo, invece, i metodi pubblici (chiamati per la loro funzione Accessor) getBase e getAltezza ed infine si definisce il metodo pubblico che effettua e stampa a video il prodotto di base ed altezza.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class rettangolo
{
    // Dichiarazione delle proprietà: si noti che sono tutte private.
    private int base;
    private int altezza;
    // Si definiscono i Metodi "Mutator" per la modifica
   //delle proprietà dall'esterno
    public void setBase(int bas)
    {
        base = lar;
    }
    public void setAltezza(int alt)
    {
        altezza = alt;
    }
    // Si definiscono i Metodi "Accessor" per richiamare i valori
    // delle proprietà dall'esterno
    public int getBase()
    {
        return Base;
    }
    public int getAltezza()
    {
        return altezza;
    }
    // Si definisce un metodo pubblico per richiamare l'area del rettangolo,
    //  utilizzando le proprietà interne della classe
    public void mostraArea()
    {
        System.out.println(base * altezza);
    }
}

Ereditarietà (Inheritance) significa che le classi Java (e quindi gli oggetti) possono essere organizzate in gerarchie dove le classi più interne e specifiche ereditano i metodi e le proprietà delle classi genitore più generiche.

Si può illustrare meglio questo concetto con un esempio. Supponiamo di sviluppare un’applicazione Java che simuli un acquario ed all’interno di questo acquario ci sono alcuni pesci che nuotano. Pertanto, si potrebbe definire una classe per rappresentare un pesce. Questa classe, chiamata Pesce, potrebbe includere alcuni dati (le proprietà, che in definitiva sono le variabili utilizzate all’interno della classe) per descrivere l’oggetto pesce: la specie,il colore e le dimensioni, ed alcuni  comportamenti (i metodi, chiamati anche subroutine o funzioni nei linguaggi procedurali), come mangiare() , dormire() e procreare( ) .

Come abbiamo già visto un particolare tipo di metodo, chiamato costruttore, viene utilizzato per creare e inizializzare un oggetto; i costruttori hanno lo stesso nome della classe e possono includere i parametri. La nostra classe Pesce dispone di due costruttori: uno per la creazione di un oggetto Pesce generico ed un altro per la costruzione di un oggetto Pesce specifico con alcuni dati iniziali. Si noterà, inoltre, che la classe Pesce dispone di due metodi mangiare() : uno per mangiare qualcosa di casuale, e un altro per mangiare un altro pesce, rappresentato da un’altra istanza della classe Pesce :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Pesce {
 
    private String mSpecie;
    private String mColore;
    private int mDimensioni;
 
    Pesce() {
        // pesce generico
        mSpecie = "sconosciuto";
        mColore = "sconosciuto";
        mDimensioni = 0;
    }
 
    Pesce(String specie, String colore, int dimensioni) {
        mSpecie = specie;
        mColore = colore;
        mDimensioni = dimensioni;
    }
    public void mangiare() {
        // maniga le alghe
    };
 
    public void mangiare(Pesce pesceDaMangiare) {
        // mangia un altro pesce!
    };
 
    public void dormire() {
        // dorme
    };
 
    public void procreare(Pesce PesceConiuge, int numeroPesciolini) {
        // procrea numeroPesciolini con il  PesceConiuge
    };
}

Le classi possono essere organizzate in gerarchie, dove una classe derivata (o subclass) include tutte le caratteristiche della sua classe genitore (o superclass), ma aggiunge ulteriori proprietà e metodi per definire un oggetto più specifico, per fare questo si utilizza la parola chiave extends .

Ad esempio, la classe dei pesci potrebbe avere due sottoclassi: PesceAcquaDolce e PesceAcquaSalata.

Queste sottoclassi avrebbero tutte le caratteristiche della classe Pesce, ma potrebbero ulteriormente personalizzare gli oggetti attraverso nuove proprietà o metodi della classe padre modificati. Ad esempio, la classe PesceAcquaDolce potrebbe includere informazioni circa il tipo di d’acqua dolce dove il pesce vive (ad esempio, fiume, lago, stagno, o pozza).

Correlato al concetto di ereditarietà è il Polimorfismo, ad esempio la classe PesceAcquaSalata potrebbe personalizzare il metodo procreare(), in modo che il pesce mangi il suo compagno dopo la riproduzione (quello definito nella  superclass) utilizzando il meccanismo di override, come nell’esempio che segue:

1
2
3
4
5
6
7
8
9
10
public class PesceAcquaSalata extends Pesce
{
    @Override
    public void procreare(Pesce PesceConiuge, int numeroPesciolini) {
        // chiamata al metodo genitore che si intende modificare
        super.procreare(PesceConiuge, numeroPesciolini);
        // mangia il pesce coniuge
        mangiare (PesceConiuge);
    }
}

oppure potrebbe personalizzare il metodo mangiare() modificandone il set di argomenti accettati per esempio aggiungendo all’argomento pesceDaMangiare l’argomento algheDaMangiare, ed è questa la tecnica chiamata overload

1
2
3
4
5
6
public class PesceAcquaSalata extends Pesce
{
    public void mangiare(Pesce PesceConiuge, int algheDaMangiare) {
	// mangia un pesce ed una certa quantità di alghe
        }
}

L’ overloading permette cmq di accedere a tutte le chiamate del metodo mangiare() scegliendo tra quella specifica della classe PesceAcquaSalata e quella della superclass Pesce

Esiste un ulteriore parola chiave che definisce il livello di accesso alle variabili interne ad una classe, stiamo parlando della parola chiave protected , che sebbene impedisce l’accesso alla variabile dall’esterno, ne consente l’accesso dalle classi derivate e facente parti dello stesso package, come si vedrà meglio in seguito.

Se non si definisce un metodo di accesso tra public, protected e private, quindi ad esempio al posto di “private int base;” “int base;” il metodo di accesso di default utilizzato dalla classe sarà protected .

In Java il concetto di ereditarietà e così esteso che tutti le classi ereditano dalla superclasse predefinita Object, anche se non si è obbligati a creare le nuove classi mediante l’istruzione class miaclasse extends Object .

Organizzare i metodi nelle Interface

In Java  è possibile organizzare i metodi di un oggetto in insiemi che si chiamano  Interface. Mentre una classe definisce un oggetto, un Interface definisce una serie di metodi che possono essere applicati ad un oggetto. Per esempio, potremmo definire una interfaccia Nuotatore che fornisce un insieme di metodi che sono comuni a tutti gli oggetti che possono nuotare, siano essi pesci, lontre, o androidi sottomarini. L’interfaccia Nuotatore potrebbe specificare quattro metodi: iniziaaNuotare() , finisciDiNuotare() , immersione() e superficie() .

1
2
3
4
5
6
7
public interface Nuotatore
{
    void iniziaaNuotare();
    void finisciDiNuotare();
    void immersione();
    void superfice();
}

La nostra classe Pesce potrebbe implementare l’interfaccia Nuotatore usando la parola chiave implements :

1
2
3
public class Pesce implements Nuotatore {
 // Fornisce implementazione dei quattro metodi all'interno dell'interface Nuotatore
}

Organizzare Classi ed Interfacce in Package

Le gerarchie di classi, come le nostre classi Pesce, possono essere organizzati in packages (pacchetti). Un package è semplicemente un insieme di classi e interfacce. Gli sviluppatori utilizzano gli spazi dei nomi (namepsaces) per assegnare nomi univoci ai  pacchetti. Per esempio, potremmo usare com.pescistrambi.acquario o com.cliente.progetto.sottoprogetto come nome per il nostro package per tenere traccia delle  nostre classi relative ai  pesci.

Conclusioni

Al termine di questo lungo articolo, abbiamo appena intrapreso il percorso per apprendere Java e sviluppare applicazioni Android. Concediamoci del tempo per comprendere meglio i concetti introdotti nell’attesa della prossima lezione in cui entreremo nello specifico della sintassi Java.

Indice

  1. Introduzione a Java
  2. La Sintassi di Java
  3. instance of – Verificare il tipo di un oggetto
  4. Gli Array

Michele Dipace

Admin di Androidlab e "Computer Addicted", ha cominciato la sua"carriera" nella metà degli anni 80 sui computer 8 bit Commodore e Sinclair passando poi al 16 bit Amiga, diventandone grande appassionato. Oggi Linux user, crede che Android sia il sistema operativo destinato ad emergere nel mercato della telefonia mobile.

More Posts - Website

Follow Me:
TwitterFacebookLinkedInPinterestGoogle PlusYouTube

  • grandissima iniziativa!!!
    è proprio quello che serviva ai neofiti come me che vogliono iniziare!!!

    l'unico appunto che vi faccio è, sempre se riesce coi tempi, di non pubblicare un tutorial ogni millemila giorni, ma nel minor tempo possibile… noi neofiti scalpitiamo e vogliamo imparare velocemente XD

  • CesareC

    GRAZIE MILLE!
    mi sembra un ottimissima idea per iniziare.

    un solo suggerimento però: se avete intenzione di pubblicare altri tutorial, vi consiglio di iniziare una specie di appuntamento (per esempio ogni lunedì della settimana un nuovo argomento) in modo da aiutare noi novellini e… aumentare le visite nel blog XD

  • come cercavo di dire la prima volta che hai postato la guida….
    Complimenti per l'impegno.
    io però sistemerei qualcosa:
    1) parlerei di information hiding e incapsulamento (in modo tale da spiegare, successivamente, meglio cosa è un oggetto e come si dovrebbe pensare a tale per crearne uno)
    2) migliorerei la parte sull'ereditarietà e sulle interfacce (l'esempio non è sbagliato, ma andrebbe spiegato meglio, spenderei più parole sulla specializzazione dell'ogetto e il senso di creare una classe astratta o altro)
    3) parlerei del polimorfismo specificando overriding e overloading
    4) spiegherei come usare public private e protected

    aspetto con curiosità i prossimi appuntamenti, in particolare quando si parlerà nello specifico della programmazione per android (sperando di avere presto un terminale android)

    PS se ti chiedi con quale criterio ti ho suggerito le modifiche, volevo solo precisare che sviluppo in java da diversi anni, sono un perito informatico, e stò studiando informatica all'università (in particolare il mio corso è informatica per la produzione del software, e appunto utilizziamo java) dico questo solo per farti capire che non sono uno sprovveduto qualsiasi che ha aperto un libro e ha sparato le prime 4 cose lette.
    PPS ametto di non aver letto tutto l'articolo, ma solo alcune parti in particolare quella in cui spieghi la programmazione ad oggetti e l'ereditarietà

  • Grazie per i commenti ed i suggerimenti, cercherò di pubblicare i tutorial con cadenza regolare, ma non mi sento di prendere un appuntamento fisso, che a causa degli svariati impegni potrei non riuscire a rispettare.
    @valantin89 ritengo sicuramente validi i tuoi suggerimenti e ti ringrazio per averli formulati. Ci tengo a precisare, però, che lo scopo di questi tutorial non è quello di fronire una guida completa a java ed alla programmazione orientata agli oggetti, ma piuttosto si vuole offrire un rapido riferimento al lettore che volendosi avvicinare allo sviluppo di applicazioni Android, ha necessità di familiarizzare con i concetti fondamentali di Java, fermo restando la necessità di approfondirli in altre sedi.
    Detto questo, è indubbio, che i concetti di incapsulamento e polimorfismo debbano essere quantomeno accennati, infatti mi riservo la possibilità di modifcare questo articolo o affrontarli nei tutorial seguenti, senza togliere la possibilità a chiunque ne abbia voglia di utilizzare lo strumento dei commenti per aggiungere le nozioni che ritiene possano servire a chi voglia iniziare a progammare Android.

    • kaffeine si capisco che non è una guida all'apprendimento del linguaggio java, ma come dici nelle prime righe è un punto di partenza per cominciare a programmare ad oggetti in java, e sinceramente ritengo che informazioni come information hiding e incapsulamento sono fondamentali per indirizzare il programmatore al giusto modo di pensare ad un oggetto, e quindi fondamentali anche per questa guida.
      Altrimenti andrebbero dati dei prerequisiti al tutorial perchè molte delle persone che conoscono linguaggi orientati agli oggetti come php, python, c++ in realtà li utilizzano in modo procedurale, sopratutto se appresi da autodidatti.

  • Pingback: Tweets that mention Apprendere Java per programmare Android: Introduzione a Java | AndroidLab -- Topsy.com()

  • vorrei aggiungere 2 cose per la sezione "Comprendere i concetti di Incapsulamento, Ereditarietà e Polimorfismo"
    1) più che altro una curiosità, se non si definisce un metodo di accesso tra public, protected e private, quindi ad esempio al posto di "private int base;" "int base;" il metodo di accesso di default utilizzato dalla classe sarà protected;
    2) l'overloading permette cmq di accedere a tutte le chiamate del metodo mangiare() scegliendo (nell'esempio) tra quella specifica della classe PesceAcquaSalata e quella della superclass Pesce

    • ho aggiunto le tue osservazioni al tutorial

  • Grazie @valantin89 per i commenti costruttivi che aiutano a migliorare il tutorial! 🙂

  • Pingback: Apprendere Java per programmare Android: La Sintassi di Java | AndroidLab()

  • Pingback: Apprendere Java per programmare Android: instanceof –Verificare il tipo di un oggetto | AndroidLab()

  • stefano

    salve io ho provato a usare eclipse per fare qualcosa in andorid risultato ; un disastro , trovo eclipse poco frendly mi sapete indicare un tutorial per iniziare passo-passo??

    • Stefano continua a seguirci, presto tratteremo anche l'argomento Eclipse.

  • Pingback: Apprendere Java per programmare Android: gli Array | AndroidLab()

Forum Android
Diventa un blogger, scrivi un articolo