Sei sulla pagina 1di 5

L'incapsulamento

L'incapsulamento è uno dei quattro concetti fondamentali dell'OOP. Gli altri tre sono ereditarietà,
polimorfismo e astrazione. Nell'incapsulamento, le variabili di una classe saranno nascoste alle altre
classi e sarà possibile accedervi solo tramite i metodi della loro classe corrente. Pertanto, è anche
noto come nascondere i dati.
Per ottenere l'incapsulamento in Java -
• Dichiarare le variabili di una classe come private.
• Fornire metodi setter e getter pubblici per modificare e visualizzare i valori delle variabili.
public class EncapTest {
private String name;
private int age;
public void setAge(int newAge) {
age = newAge;
}
public void setName(String newName) {
name = newName;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
----------------------------------------------------------------------------------------------------------------------
public class RunEncap {
public static void main(String args[]) {
EncapTest encap = new EncapTest();
encap.setName("Lollo");
encap.setAge(17);
System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
}
}
Polimorfismo

Il polimorfismo è la capacità di un oggetto di assumere molte forme. È importante sapere che l'unico
modo possibile per accedere a un oggetto è attraverso una variabile di riferimento. Una variabile di
riferimento può essere di un solo tipo. Una volta dichiarato, il tipo di una variabile di riferimento
non può essere modificato.
La variabile di riferimento può essere riassegnata ad altri oggetti a condizione che non sia dichiarata
final.

Esempio

Vediamo un esempio.
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
Ora, la classe Deer è considerata polimorfa poiché ha ereditarietà multipla.

Abstract

Una classe che contiene la parola chiave abstract nella sua dichiarazione è nota come classe astratta.
• Le classi astratte possono contenere o meno metodi astratti , cioè metodi senza corpo (public
void get ();)
• Ma, se una classe ha almeno un metodo astratto, la classe deve essere dichiarata astratta.
• Se una classe viene dichiarata astratta, non può essere istanziata.
• Per usare una classe astratta, devi ereditarla da un'altra classe, fornire implementazioni ai
metodi astratti in essa contenuti.
• Se erediti una classe astratta, devi fornire implementazioni a tutti i metodi astratti in essa
contenuti.

Esempio

Questa sezione fornisce un esempio della classe astratta. Per creare una classe astratta, è sufficiente
utilizzare la parola chiave abstract prima della parola chiave class, nella dichiarazione della classe.

public abstract class

Superclasse e la Sottoclasse
La differenza fondamentale tra la Superclasse e la Sottoclasse è quello Superclasse è la classe
esistente da cui derivano le nuove classi mentre Sottoclasse è la nuova classe che eredita le
proprietà e i metodi della Superclasse.
L’overloading
L’overloading dei metodi, in italiano sovraccaricamento, è il meccanismo con cui Java permette la
definizione di più metodi con lo stesso nome. Per poter avere l’overloading l’unica regola da
rispettare è quella di avere una lista di argomenti differente.

public class Figura {


public int a;
public double b;

public void setNumero(int num){


a=num;
}

public void setNumero(double num){ // Ok, lista parametri diversa


b=num;
}

public void setNumero(int Num){ // Errore, lista uguale


a=num;
}

public int setNumero(int num){ // Errore, lista uguale


a=num;
return a;
}

public float setNumero(){ // Ok, lista differente


return 3.14;
}

public void setNumero(int num, double num2){ // Errore, il tipo


// di ritorno non é usato per distinguere i metodi
this(num); // Sfruttiamo il sovraccaricamento
b=num2; // Non possiamo riusare this(), può essere usato
// Solo sulla prima riga di ogni metodo
}
}
L’overriding
L’overriding è il meccanismo che permette la sovrapposizione dei metodi di una superclasse da
parte di una sottoclasse. Per poter sovrapporre un metodo proveniente da una superclasse bisogna
che il nuovo metodo abbia:

1. lo stesso nome, lo stesso tipo di ritorno e la stessa lista di parametri;


2. visibilità non inferiore
3. il metodo sovrapposto non può avere problemi di grandezza più grandi del metodo che
viene sovrapposto

public class Persona {


public int anni=0; // Verrà ereditato da Maschio, è public
public void setAnni(int anni){
this.anni=anni;
}
}
public class Maschio
extends Persona{
public void setAnni(int anni){ // Tutto uguale, overriding corretto
this.anni=anni*2;
}
public void setAnni(int Years){ // Tutto uguale, overriding corretto
this.anni=anni*2;
}
public void setAnni(double anni){ // Non c'è overriding (lista parametri diversi), ma c'è
overloading
//...
}
public int setAnni(int anni){ // Errore, non c'è overriding e neanche overloading (solo lista
parametri differente): sovraccaricamento illegale di metodi
this.anni=anni*2;
return this.anni;
}
}
public class Principale {

public static void main(String[] args) {

InputStreamReader flusso = new InputStreamReader(System.in);


BufferedReader lettore = new BufferedReader(flusso);

try
{
cognome = lettore.readLine();
System.out.println(Componi(cognome,'p'));
System.out.println(Componi(cognome,'d'));
}
catch(IOException e)
{
e.printStackTrace();
}

//ESEMPIO
//Nocilli
//oil(paro)
//Ncli(disparo)

private static String cognome;

public static String Componi(String cognome,char tipologia)


{
String risultato = "";
for(int i = 1 ; i <= cognome.length() ; i++)
{
if(Character.toUpperCase(tipologia) == 'P')
{
if(i % 2 == 0)//Pari
{
risultato += cognome.charAt(i-1);
}
}
else
{
if(i % 2 != 0)//Disparo
{
risultato += cognome.charAt(i-1);
}
}
}
return risultato;
}
}