Java come ben sappiamo è un linguaggio di programmazione ad oggetti, e in questo breve articolo ti faccio vedere come è possibile, sfruttando la potenza del linguaggio come scrivere in modo veloce una classe e da essa derivare una sottoclasse.
Nello specifico, ti mostro come scrivere una semplice classe che contiene dei dati, e da essa derivare una sottoclasse.
Cominciamo con il dire che una classe è una rappresentazione astratta di una collezione di oggetti della realtà che si
vuole rappresentare e implementare con un programma informatico.
La classe è sempre costituita da attributi (i dati) e metodi ovvero delle implementazioni equivalenti alle funzioni e alle
procedure della programmazione procedurale per modificare e leggere i valori degli attributi che godono della proprietà
dell’incapsulamento ovvero i dati sono accessibili solo mediante i metodi che accedono dall’esterno della classe.
A tal proposito in tutti i linguaggi OOP esiste il concetto di modificatore di accesso ovvero una dichiarazione di visibilità
di metodi e attributi.
Proviamo a scrivere una dichiarazione di classe generica che possa andar bene in ogni contesto adattando i valori
previsti, da ogni singola situazione.
class nomeclasse {
[public | private | proteced ] tipo nome attributo 1;
.......
[public | private | proteced tipo nome attributo n;
public nomeclasse (elenco parametri) // costruttore non obbligatorio
{ ..... codice ....}
{public | private | protected] tipo nome metodo 1 (elenco di parametri)
{
codice ....}
{public | private | protected] tipo nome metodo 2 (elenco di parametri)
{
codice ....}
}
Nelle dichiarazione degli attributi o metodo puoi utilizzare private per renderlo privato ovvero per accedere solo
dall’interno di metodi pubblici della classe, protected per condividere tra classi che sono legate ad una relazione di
ereditarietà o che fanno parte dello stesso package, e public per condividere metodi o attributi con tutte le classi
anche disgiunte.
Le classi come modificatore di accesso hanno solo private e public.
Caso di studio
Adesso ti spiego come creare una classe e da essa derivarne un’altra, però prima di fare
ti spiego perché conviene lavorare in questo modo.
Immagina di avere una classe che server per risolvere un certo problema. e che magari, quellaclasse con pochi aggiustamenti la vorresti riutilizzare per un problema simile.
Se comprendi come effettuare le modifiche, potrai risparmiare tempo e codice inutile.
Ora concentriamoci sul caso di studio. Immaginiamo di avere costruito una classe Persona che memorizza i dati di una
persona, e che permetta di visualizzare i dati. Questa prima classe possiede tre attributi nome,. cognome, data di
nascita, due metodi uno costruttore che imposta gli attributi dall’esterno, e un altro che restituisce la data di nascita,
di quella persona.
E’ facile, riusare questa classe e estenderla a sotto classe Studente aggiungendo per lo studente la classe, e la sezione
che frequenta, e la media dei suoi voti.
In questa nuova sotto classe aggiungo un nuovo costruttore che estende quello della classe da cui effettuo la
derivazione, e aggiungo altri due metodi uno per la stampa dei dati, e uno per restituire le caratteristiche dell’oggetto
che io istanzio nel metodo main.
Ora ti inserisco il codice così comprendi meglio quello che sto dicendo.
Per esercizio tu potresti provare a realizzare il diagramma UML.
Ecco il codice delle due classi che sono salvati in due files separati con estensione java, e che fanno parte dello stesso,
package.
La prima classe Persona
package progetto_2_sottoclassi;
public class Persona {
String nome;
String cognome;
String data_nascita;
public Persona (String a, String b, String c)
{
this.nome=a;
this.cognome=b;
this.data_nascita=c;
}
public String getdata ()
{ String t;
t=data_nascita;
return t;
}
}Ecco la seconda classe derivata Studente
package progetto_2_sottoclassi;public class Studente extends Persona {
String classe;
String sezione;
double media;
public Studente(String a, String b, String c, String d, String e, double m)
{
super(a,b,c);
this.classe=d;
this.sezione=e;
this.media=m;
}
public String toString()
{
String s;
System.out.println("DAti dello Studente");
s="Nome:\t"+ super.nome+"\n Cognome:\t"+super.cognome;
s=s+"\n Data Nascita"+super.data_nascita +"\n Classe\t"+classe;
s="\n Media dei voti:\t"+media+"\n";
return s;
}
public double getmedia()
{ double m;
m= this.media;
return m;
}
public Object getoggetto()
{
return this;
}
public static void main (String args[])
{
String output;
Studente st= new Studente("mario","rossi","10-10-2002","4","g",7.5);
output=st.toString();
System.out.println(output);
double m;
m=st.getmedia();
System.out.println("Nuovamente la media:"+m);
}
}Alcuni commenti sul codice sono dovuti.
Allora per prima cosa nel costruttore della sottoclasse Studente uso super per utilizzare assegnare i valori di nome, cognome
e data di nascita, tramite il costruttore della Superclasse Persona. Infatti in questa relazione di ereditarietà la classe Persona assume,
il ruolo di superclasse.
Inoltre ho creato un metodo personalizzato toString che consente di visualizzare l’output.
Nel prossimo articolo che poi pubblicherò ti parlerò del metodo che ho scritto che ritorna un oggetto.