Modificatori di accesso Java

I modificatori di accesso java sono parole riservate che forniscono al compilatore informazioni sulla natura del codice, delle variabili e delle classi contenute nei file sorgenti. Essi regolano la visibilità ad un componente Java. I modificatori di accesso Java permettono di realizzare la cosiddetta information hiding (incapsulamento delle informazioni).
Vediamo rapidamente il loro funzionamento dal meno restrittivo (public) al più restrittivo (private).

MODIFICATORI DI ACCESSO JAVA: public

Il modificatore public garantisce accesso incondizionato a metodi, classi, variabili e costruttori dichiarati pubblici. Quando utilizziamo public ad esempio per una classe vuol dire che quella classe è visibile al dì fuori del package di appartenenza.

package Car;
 
public class Punto {
	public int anno;
	public void publicMethod() {
		System.out.println(anno);
	}
}
 
package Moto;
import Car.*;
 
class Vespa {
	void accessMethod() {
		Punto p = new Punto();
		p.anno = 10; // legal
		p.publicMethod(); // legal
	}
}

MODIFICATORI DI ACCESSO JAVA: protected

Il modificatore protected garantisce l’accesso agli elementi dello stesso package e a tutte le sue sottoclassi indistintamente dal package in cui si trovano.
ESEMPIO 1: Accesso permesso a classi dello stesso package

public class Point {
	protected int x,y;
}
public class Point3D extends Point {
	protected int z;
	public void move(int x, int y, int z) {
		this.x = x; //OK
		this.y = y; //OK
		this.z = z; //OK
	}
}

ESEMPIO 2: Accesso permesso solo alle sottoclassi indistintamente dal package

package Veicoli;
 
public class Punto {
	protected int anno;
	protected void protectedMethod() {
		System.out.println(anno);
	}
}
 
package Veicoli;
 
class Vespa {
	void accessMethod() {
		Punto p = new Punto();
		p.anno = 10; // legal
		p.protectedMethod(); // legal
	}
}
 
package Aerei;
import Veicoli.*;
 
class Delta extends Punto {
	void accessMethod(Punto a, Delta d) {
		a.anno = 10; // illegal
		d.anno = 10; // legal
		a.protectedMethod(); // illegal
		d.protectedMethod(); // legal
	}
}

MODIFICATORI DI ACCESSO JAVA: default

Il modificatore di accesso default o anche detto di package può non essere esplicitamente specificato. Tale modificatore possiede un accesso a livello di package, permette infatti un accesso a tutte le classi e le sottoclassi dello stesso package (solamente) dove è dichiarato.
Questa visibilità è assegnata di default se non viene specificato nessun modificatore di accesso per classi, attributi, costruttori e metodi Java.

package Veicoli;
 
public class Punto {
	protected int anno;
	protected void protectedMethod() {
		System.out.println(anno);
	}
}
 
package Veicoli;
 
class Vespa {
	void accessMethod() {
		Punto p = new Punto();
		p.anno = 10; // legal
		p.protectedMethod(); // legal
	}
}

MODIFICATORI DI ACCESSO JAVA: private

Il modificatore private permette l’accesso solo ad attributi e metodi della stessa classe. Tale visibilità non vale per classi all’interno dello stesso package.

class Alpha {
	private int iamprivate;
	private void privateMethod() {
		System.out.println("privateMethod");
	}
}
class Beta {
	void accessMethod() {
		Alpha a = new Alpha();
		a.iamprivate = 10; // illegal
		a.privateMethod(); // illegal
	}
}

Di seguito si riporta una tabella riassuntiva sui modificatori di accesso java.

Modificatori di accesso Java

Visibilità dei modificatori di accesso Java


Per concludere la trattazione sui modificatori di accesso java effettuo delle piccole precisazioni:

  • REGOLA 1: Ereditando, le sottoclassi non possono avere una tipologia più restrittiva. La sottoclasse o è visibile allo stesso livello o è più visibile. (es. superclasse protected, la sottoclasse che la estende o è protected o public).
  • REGOLA 2: Se voglio impedire l’estensione di una classe da me definita basterà inserire la parola chiave final. final può essere usato in più contesti in questa sede ci limitiamo esclusivamente a questa sfaccettatura.
Modificatori di accesso Java ultima modidfica: 2015-01-10T13:28:38+01:00 da Gianluca Di Vincenzo