Astrazione

La classe astratta funziona come una classe madre, che verrà estesa dalla sua sottoclasse. Il metodo della sottoclasse sovrascriverà il metodo astratto della classe astratta. 

 

   esempio

abstract class libri { // definisce una classe astratta
abstract int lettura( ); // definisce un metodo astratto
}
class eBooks extends libri{ // estende la classe madre
int lettura( ){ return 100; } //sovrappone il metodo astratto
}

   SINTASSI

abstract class |libri|{ // definisce una classe astratta
abstract int |lettura|( ); // definisce un metodo astratto
}
class |eBooks| extends |libri|{ // estende la classe madre
int |lettura|( ){ return |100|; } //sovrappone il metodo astratto
}

   Spiegazione

1. “abstract class libri{ }” definisce ua classe abstract.
2. “abstract int lettura( )” definisce un metodo abstract.
3. “class eBooks extends libri{ }” significa che una sottoclasse “eBooks entra a far parte della classe madre (la amplia, la estende)
4. “int lettura( ) { }” significa che questo metodo nella sottoclasse sovrascrive il metodo astratto nella classe madre.

---

2

 

 

 

 

   Esempio di Astrazione

   Esempio

package mioPackage;
abstract class libri{// definisce una classe astratta
abstract void lettura(); // definisce un metodo astratto
}
class eBooks extends libri{ // estende la classe madre
void lettura(){ //sovrascrive il metodo astratto
System.out.println("Sovrascrive il metodo astratto!");
}}

public class EsempioAstrazione {
public static void main(String[] args){
eBooks obj =new eBooks();
obj.lettura();
}}

   SINTASSI

package |mioPackage|;
abstract class |libri|{// definisce una classe astratta
abstract void |lettura|( ); // definisce un metodo astratto
}
class |eBooks| extends |libri|{// estende la classe madre
void |lettura|( ){ //sovrascrive il metodo astratto
System.out.println("Sovrascrive il metodo astratto!");
}}

public class |EsempioAstrazione|( )
|EsempioAstrazione| {
public static void main(String[] args){
|eBooks| |obj| =new |eBooks|();
|obj|.|lettura|( );
}}

Output: Sovrascrive il metodo astratto!

Spiegazione:

1. “abstract class libri{ }” definisce una classe astratta.
2. “abstract int lettura( )” definisce un metodo astratto.
3. “class eBooks extends Libri { }” significa che la sottoclasse “eBooks” amplia la classe madre
4. La classe pubblica EsempioAstrazione crea 0ggetto statico astratto ebooks xhe non puo essere cambiato
   “int lettura ( ) { }” significa che questo metodo della sottoclasse sovrascrive il metodo astratto nella classe madre.
   

 

---

3

 

 

 

   Permessi - autorizzazioni

Java ha i seguenti quattro modificatori di autorizzazione per definire un membro: 1 predefinito, 2 pubblico, 3 privato, 4 protetto

Livelli	1	2	3	4
	Default	Pubblico	Privato	Protetto
Stessa classe	V	V	V	V
stesso package classe Madre	V	V	X	V
stesso package sottoclasse	V	V	X	V
package diverso classe Madre	X	V	X	X
package diverso sottoclasse	X	V	X	V

1. Un membro predefinito (default member) non permette l'accesso a un package diverso, cioè non suo.
2. Un membro pubblico (public member) permette l'accesso ad ogni package e ad ogni classe.
3. Un membro privato (private member) non permette l'accesso a una classe che non sia la sua.
4. Un membro protetto (protected member) permette l'accesso a ogni sottoclasse.
   
   
   
   

---

4

 

 

 

 

    Membri di default (predefinito)

1. Il membro predefinito non ha alcun modificatore.
2. Non è possibile accedere al membro predefinito da un pacchetto diverso.
3. Il nome del pacchetto deve essere uguale al nome della directory in cui risiede il pacchetto.

  Esempio

Nello stesso pacchetto ci sono 2 files
   
  a) File1 di mioPackage
Public class |ClasseMadre|{
int |num|=|100|;// Questo è membro predefinito- default member
}

  b) file2 di myPackage
package |mioPackage|;
public class SubClass extends |ClasseMadre|{
public static void main(String[] args) {
SubClass |s|=new SubClass( );
System.out.print ( |s|.|num| ); /* s referenzia num nello stesso package, ok! */
}
}

Output: 100

Spiegazione

1. “int num=100” definisce un membro predefinito
2. “s.num” può accedere a un membto predefinito nello stesso package.
   

---

5

    Membri Pubblici

È possibile accedere a un membro pubblico da qualsiasi pacchetto o classe, specialmente in pacchetti diversi.

Esempio

Prendiamo due files in due pacchetti diversi come segue:
a) File1 di mioPackage
Package |mioPackage|;
public class |ClasseMadre|{
public int |num|=|100|; // Questo è un membro pubblico.
}

a) File2 di NovoPackage
Package |novoPackage|;
import |mioPackage|.|ClasseMadre|;
public class SubClass extends |ClasseMadre|{
public static void main(String[] args) {
SubClass |s|=new SubClass( );
System.out.print ( |s|.|num| ); /* s referenzia num in un package diverso, ok! */un
}

Output: 100

Spiegazione:

1. “public int num=100” definisce un membro pubblico.
2. “s.num” può accedere a un membro pubblico in/da pacchetti diversi.

 

---

6

    Membri Privati

Non si può accedere a un membro privato da una classe diversa, ma solo dalla stessa che lo contiene.

Esempio:

class |miaClasse| {
private |miaClasse|{ // costruttore
System.out.println(“|Questo metodo è privato!|”);
}}

public class |novaClasse|{
public static void main ( String args [ ] ) {
|miaClasse| obj = new |miaClasse| ( ); ///* Errore! Accesso a costruttore privato*/
}}

Output: Error message!

Spiegazione

1. "Private MiaClasse( )"definisce un costruttore privato "MiaClasse".
2. "New MiaClasse (  )" tenta di chiamare il costruttore privato "MiaClasse", ma si verifica un errore, perché rispettivamente viene da una classe diversa.

---

7

 

 

 

   Esempio di Membro privato

private member can be accessed by the same class.

Esempio

package |mioPackage|;
public class |nostraClasse| {
private int |a| = |100|; // dichiara una variabile privata
private int |b| = |200|; // dichiara una variabile privata

public void |VariableAccesso| ( ){
System.out.println(" |a =|" + |a|); // accede a una variabile privata
System.out.println(" |b =|" + |b|); // accede a una variabile privata
}}

public class |PrivatoEsempio| {
public static void main ( String args [ ] ){
|nostraClasse| obj = new |nostraClasse| ( ); /* OK! accede aun costruttore predefinito */
obj.|VariableAccesso|( );
}}

Output:
a = 100
b = 200

 

 

 

 

 

 

 

---

8

 

 

 

   Membro protetto

un membro protetto è accessibile da qualsiasi sottoclasse.

Esempio

qui di séguito abbiamo 2 files in diversi package:
a)file1 di mioPackage

package |mioPackage|;
public class |ClasseMadre|{ // Classe Madre
protected int |num|=|100|; // num è un membro protetto
}

b) file2 di NovoPackage

package |novoPackage|;
import |mioPackage|.|ClasseMadre|;
public class |SottoClasse| extends |ClasseMadre| { //sottoclasse
public static void main(String[] args) {
|SottoClasse| |s|=new |SottoClasse|( );
System.out.print (|s|.|num| ); //accede a un membro protetto .
}
}

Output: 100

Spiegazione

1. “protected int num=100” definisce un membro protected.
2. “s.num” può accedere a un membro protetto da una sottoclasse anche se si trova in package dfferenti.
3. Ai membri protetti si può accedere da ogni sotto classe.

---

9

 

 

 

   Interfaccia

L'interfaccia è una classe speciale, che contiene uno o più metodi vuoti che verranno implementati da un metodo della classe.

Esempio

interface |libri| { // definisce una interfaccia
int|numerolibro|( ); // definisce un metodo vuoto
}

class |eBooks| implement |libri| { //implementa l'interFaccia
public int |numerolibro| ( ) { // implementa un metodo vuoto
return |100|;
} }

 

Spiegazione:

1. “interface libri” definisce un'interfaccia chiamata “libri”.
2. “int numerolibro( )” definisce un metodo vuoto cgiamato “numerolibro”.
3. “class eBooks implement libri{ }” significa che la classe “eBooks” implementa l'interfaccia “libri” .
4. “public int numerolibro( ){ }” implementa il metodo numerolibro( )

---

10

 

 

 

   Esempio di interfaccia

esempio

package mioPackage;
interface libri// definisce una interfaccia
{public void numerilibri();} // definisce un metodo vuoto
class eBooks implements libri//implementa l'interFaccia
{public void numerilibri ()// implementa un metodo vuoto
{System.out.println("Implementa il metodo vuoto!");}}


public class EsempioInterface {
public static void main(String[] args) {
eBooks obj = new eBooks();
obj.numerilibri();
}}

SINTASSI

package |mioPackage|;
interface |libri|// definisce una interfaccia
{public void |numerilibri|();} // definisce un metodo vuoto
class |eBooks| implements |libri|//implementa l'interFaccia
{public void |numerilibri| ( )// implementa un metodo vuoto
{System.out.println("Implementa il metodo vuoto!");
}}

public class |EsempioInterface|{
public static void main(String[] args) {
|eBooks| obj = new |eBooks|();
obj.|numerilibri|();
}}

 

output : Implementa il metodo vuoto!

 

 

---

11

 

 

 

   Astratto e interfaccia

Spiegazione di Astratto

abstract class |libri|{ // definisce una classe madre astratta
int |lettura|( );} // definisce un metodo astratto

class |eBooks| extends |libri|{ //estende la classe madre aggiungendo ebooks
int |lettura|( )
{ return …; } }// sovrascrive il metodo astratto

Spiegazione di interfaccia

interface |libri|{ // definisce un'interface
int |numerolibro|( ); // definisce un metodo vuoto
}
class eBooks implement |libri|//implementa l'interface aggiungendo ebooks
{public int |numerolibro|( )// implementa il metodo vuoto

{ return …; } }

---

12

 

 

 

   Inizializzazione delle Variabili

Quando si crea un oggetto, è necessario un costruttore per inizializzare le variabili.

esempio

class libro { // definisce una classe
public String titolo;
public int numero;
public libro ( ) { // definisce un costruttore della classee
titolo = “Learning Java ”; // inizializzazione
numero = 100; // inizializzazione
}}

public class Editore { // // definisce una classe pubblica main
public static void main ( String args [ ]) { // metodo della classe main
Libro eBook = new libro ( ); // crea un oggetto
System.out.print( eBook.titolo + eBook.numero);
}}

SINTASSI

class |libro| { // definisce una classe
public String |titolo|;
public int |numero|;
public |libro| ( ) { // definisce un costruttore della classee
|titolo| = “Learning Java ”; // inizializzazione titolo
|numero| = 100; // inizializzazione numero
}}

public class |Editore|{ // // definisce una classe pubblica main
public static void main ( String args [ ]) { // metodo della classe main
Libro |eBook| = new |libro| ( ); // crea un oggetto
System.out.print(|eBook|.|titolo| +|eBook|.|numero|);
}}

 

Output: Learning Java 100

Spiegazione :

"public libro ( ) {... variabili.., }" è un construttore che serve per attribuire alle variabili i valori iniziali .

 

---

13

 

 

 

   Altra Classe

La classe principale (main) può utilizzare un'altra classe per chiamare un altro metodo.

Esempio

class UnaltraClasse { // definisce una classe
public static void UnaltroMetodo ( ){ // definisce metodo della classe
System.out.print ( “Very Good” ); }
}
public class MainClass { // definisce una classe pricipale
public static void main (String args [ ]){ // definisce metodo della classe
UnaltraClasse.UnaltroMetodo( ); // UnaltraClassechiama UnAltro metodo
}}
( Output: Very Good )

SINTASSI

class |UnaltraClasse|{ // definisce una classe
public static void |UnaltroMetodo| ( ){ // definisce metodo della classe
System.out.print ( “|Molto Buono|” ); }
}
public class |MainClass| { // definisce una classe pricipale
public static void main (String args [ ]){ // definisce metodo della classe
|UnaltraClasse|.|UnaltroMetodo|( ); // UnaltraClasse chiama UnAltro metodo
}}

Output: Molto Buono

Spiegazione

“UnaltraClasse.UnaltroMetodo( )” la classe main (MainClass) può usare un metodo definito in un'altra diversa.

---

 

 

 

 

 Esercitazioni: Max & Min  #  Interfaccia

Start up Eclipse > Select “myPackage” > new > class > name > DemoAstratta > Finish.

Esempio (Abstract)

package mioPackage;
abstract class A { // definisce una classe abstract
abstract int max(int x, int y); // definisce un metodo abstract
int min(int x, int y){
return x<y?x:y;
}}

class B extends A{ // definisce una classe B che estende la classe A
int max(int x, int y){ // sovrascrive il metodo abstract
return x>y?x:y;
}}

public class DemoAstratta {
public static void main(String[] args) {
A a;
B b=new B();
int max=b.max(100, 200);
int min=b.min(100, 200);
System.out.println("Max="+max);
System.out.println("Min=" +min);
}}

SINTASSI (Abstract)

package |mioPackage|;
abstract class |A|{ // definisce una classe abstract
abstract int max(int |x|, int |y|); // definisce un metodo abstract
int min(int |x|, int |y|){
return |x|<|y|?|x|:|y|;
}}

class |B| extends |A| { //definisce una classe B che estende la classe A
int max(int |x|, int |y|){ // sovrascrive il metodo abstract
return |x|>|y|?|x|:|y|;
}}

public class DemoAstratta {
public static void main(String[] args) {
|A||a|;
|B| |b|=new |B|( );
int max=|b|.max(100, 200);
int min=|b|.min(100, 200);
System.out.println("|Max=|"+max);
System.out.println("|Min=|" +min);
}}

Fate clic sul pulsante verde col triangolo bianco nella barra degli strumenti per eseguire il programma e vedere l'output:

Output: Max = 200
        Min = 100

---

 

 

 

 

  

Esercitazione: Interfaccia   #   Max & Min  

Start up Eclipse > Select “mioPackage” > new > class > name > DemoInterfaccia > Finish.

esempio

package mioPackage;
interface miaInterface{ // definisce un'interfaccia
public void comparaNumeri(int num1, int num2); /* definisce un metodo vuoto */
}
class NumMax implements miaInterfaccia{ // implementa l'interfaccia
public void comparaNumeri(int num1, int num2){ /* implementa il metodo vuoto */
System.out.println("Tra due numeri: "+num1+" & "+num2);
if (num1>=num2)
System.out.println("Massimo è:"+num1);
else
System.out.println("Massimo è:"+num2);
}
}

class NumMin implements miaInterfaccia{ // implementa l'interfaccia
public void comparaNumeri(int num1, int num2){
System.out.println("Tra due numeri: "+num1+" & "+num2);
if (num1<=num2)
System.out.println("Minimo è:"+num1);
else
System.out.println("Minimo è:"+num2);
}
}

public class DemoInterfaccia {
public static void main(String[] args) {
NumMax ObjectMax = new NumMax();
maxObject.comparaNumeri(100, 120);
NumMin ObjectMin = new NumMin();
minObject.comparaNumeri(60, 80);

SINTASSI

package |mioPackage|;
interface |miaInterfaccia|{ // definisce un'interfaccia
public void |comparaNumeri|(int |num1|, int |num2|); /* definisce un metodo vuoto */
}
class NumMax implements |miaInterfaccia|{ // implementa l'interfaccia
public void |comparaNumeri|(int |num1|, int |num2|){ /* implementa il metodo vuoto */
System.out.println("|Tra due numeri:|"+|num1|+" & "+|num2|);
if (|num1|>=|num2|)
System.out.println("|Massimo è:|"+|num1|);
else
System.out.println("|Massimo è:|"+|num2|);
}
}

class NumMin implements |miaInterfaccia|{ // implementa l'interfaccia
public void |comparaNumeri|(int |num1|, int |num2|); {
System.out.println("|Tra due numeri:|"+|num1|+" & "+|num2|);
if (|num1<=|num2)
System.out.println("|Minimo è:|"+|num1|);
else
System.out.println("|Minimo è:|"+|num2|);
}
}

public class |DemoInterfaccia|{
public static void main(String[] args) {
|NumMax| ObjectMax = new |NumMax|();
maxObject.|comparaNumeri|(100, 120);
|NumMin| ObjectMin = new |NumMin|();
minObject.|comparaNumeri|(60, 80);

Fate clic sul pulsante verde col triangolo bianco nella barra degli strumenti per eseguire il programma e vedere l'output:

Output:

I due numeri sono: 100 & 120
  Massimo è :120
Idue numeri sono 60 & 80
  Minimo è:60

Spiegazione

1. “interface miaInterfaccia” definisce una interfaccia chianata “miaInterfaccia”.
2. “void comparaNumeri(....)” definisce un metodo vuoto “void comparaNumeri( )”.
3. “class NumMax implements myiaInterfaccia{ }” significa che la classe “NumMax” implementa l'interfaccia “miaInterfaccia”.
4. “class NumMin implements miaInterfaccia{ }” significa che la classe “MinNum” implementa l'interfaccia “miaInterfaccia” .
5. “public void comparaNumeri( ){...}” implementa il metodo vuoto comparaNumberi( ) in interfaccia