Ereditarietà

Una classe può essere l'estensione di una sottoclasse. Le proprietà della classe sono estese alla classe genitore; "Extends" è utilizzato in una sottoclasse estesa a una classe genitore.

  Esempio


class parent_class { // classe genitore
....................... ; // definite le variabili qui
....................... ;// definite il metodo qui
}

sub_class extends parent_class{ // sub class
....................... ; // definite le variabili qui
....................... ;// definite il metodo qui
}

 

  Spiegazione:

"Class sub_class extends parent_class" significa che una sottoclasse estende le proprietà a una classe genitore (chiamata anche superclasse).
La sottoclasse può accedere alla variabile e al metodo nella classe genitore, ad eccezione della variabile privata e del metodo privato nella classe genitore, a cui non piò accedere.

 

 

 

 

2

 

 

 

 

   La parola chiave "super"

Nella sottoclasse, "super" serve per chiamare il costruttore della classe madre.

Esempio

class super_class{
super_class (int x, int y){ // costruttore
this.x=x; this .y=y;
}}

class sub_class extends super_class{
sub_class(int x, int y){ // costruttore
super ( x,y ); // chiama il construttore della classe madre
}}

SINTASSI

class |super_class|{
|super_class| (int |x|, int |x|){ // costruttore
this.|x|=|x|; this.|y|=|y|;
}}

class |sub_class| extends |super_class|{
sub_class(int |x|, int |y|){ // costruttore
super ( |x|,|y| ); // chiama il construttore della classe madre
}}

Spiegazione:
“super ( x,y );” chiama il costruttore della classe madre.

 

3

 

 

 



   Prevalenza (Overriding)

Se il nome del metodo e l'argomento sono gli stessi, il metodo della sottoclasse può sovrapporsi al metodo della classe madre.

Esempio

class Super_class{
int test( int num ) { return num; } // sovrapposizione
}
class Sub_class extends Super_class{
int test( int num ) { return 100 + num; }// sovrapposizione
}
public class OverridingClass {
public static void main (String args[ ]){
Sub_class obj=new Sub_class( );
System.out.print( obj.test( 200 ));
}}

SINTASSI

class |super_class|{
int test( int |num| ) { return |num|; } // sovrapposizione
}
class |sub_class| extends |super_class|{
int test( int |num|) { return |100| + |num|; }// sovrapposizione
}
public class |OverridingClass|{
public static void main (String args[ ]){
|sub_class| obj=new |sub_class| ( );
System.out.print( obj.test( |200| ));
}}


Output: 300

Spiegazione:

Quando "obj.test (200)" chiama "int test () {}", "int test () {}" nella sottoclasse sostituisce "int test () {}" delle super classe, perché hanno stesso nome e stesso argomento


4

 

 

 

 

 

   Sovraccarico e prevalenza

Sovraccarico: stesso nome di metodo, argomento diverso, nella stessa classe.
Prevalenza: stesso nome di metodo, stesso argomento, tra superclasse e sottoclasse.

Esempio
(sovraccarico)

class Color { String x,y;
Color ( String a, String b) { x=a; y=b; } // sovraccarico
Color ( ) { x=”Giallo”; y=”Porpora”;} // sovraccarico
}

(prevalenza)

class super_class {
int test( int num ) { return num; } // prevalenza
}
class sub_class extends super_class{
int test( int num ) { return 100 + num; }// prevalenza
}
---------------------------------------------------

SINTASSI
(sovraccarico)

class |Color| { String |x|,|y|;
Color ( String |a|, String |b|) { |x|=|a|; |y|=|b|; } // sovraccarico
Color ( ) { |x|=”|Giallo|”; |y|=”|Porpora|”;} // sovraccarico
}

(prevalenza)

class |super_class|{
int test( int |num| ) { return |num|; } // prevalenza
}
class |sub_class| extends |super_class|{
int test( int |num| ) { return |100| + |num|; }// prevalenza
}

5







   La Variabile Static (variabile di classe)

Al contrario delle variabili non statiche, che non possono essere riferite alla classe, la "variabile static", nota come variabile di classe, può essere referenziata sia dalla classe che dall'oggetto.

Esempio

class MyClass {
static int count=100; //dichiara una variabile statica
public static void main (String args[ ]){
System.out.print( MyClass.count ); /* MyClass referenzia la variabile static “count” direttamente */
}} ( Output: 100 )

SINTASSI

class |MyClass|{
static int |count|=|100|; //dichiara una variabile statica "count"
public static void main (String args[ ]){
System.out.print( |MyClass|.|count| ); /* MyClass si riferisce direttamente alla variabile static “count” */
}}

Output: 100

 

 

6







    La variabile Final

“final” è una parola chiave, “final+ variabile” significa che il valore della variabile non è modificabile.

Esempio

class MyClass{
final int x =100; // dichiara una variabile final
static void test( ){ x = 200;} //errore! “x” non si può modificare
public static void main (String args[ ]){
System.out.print( MyClass.test( ) );
}}

SINTASSI

class |MyClass|{
final int |x| =|100|; // dichiara una variabile final
static void test( ){|x| =|200|;} //errore! “x” non si può modificare
public static void main (String args[ ]){
System.out.print( |MyClass|.test( ) );
}}

Spiegazione:
“final int x =100” definisce la variable “x”, con valore 100, che non è modificabile.
la funzione “static void test( ) { x = 200;}” prova a modificare il valore di “x”, ma viene segnalato un errore.

 

7

 

 

 

 

 

   Il Metodo Final

“final” è una keyword. “final method( )” significa che il metodo non si può modificare.

Esempio

class animal{
final void test ( ){//dichiara un metodo final
System.out.print(“animal”);
}}
class dog extends animal {
void test ( ){ // errore! il metodo test() non può prevalere
System.out.print(“dog”);
}}

SINTASSI

class |animal|{
final void test ( ){ //dichiara un metodo final
System.out.print(“|animal”);
}}
class |dog| extends |animal| {
void test ( ){ // errore! test() non può prevalere
System.out.print(“|dog|”);
}}

 

 

 

 

8

 

 

 

 

 

   La Classe Final

"Final" è una parola chiave. " final Class" significa che la classe non può essere estesa.

esempio

final class animal { // dichiara una classe final
// qui definisce qualche variabile;
// qui definisce qualche metodo;
}
class elephant extends animal { //error! non estensibile
// qui definisce qualche variabile;
// qui definisce qualche metodo;
}

SINTASSI

final class |animal| { // dichiara una classe final
// qui definisce qualche variabile;
// qui definisce qualche metodo;
}
class |elephant| extends |animal| { //error! non estensibile
// qui definisce qualche variabile;
// qui definisce qualche metodo;
}

 

Spiegazione:

“Final class animal {…}” definisce una classe finale “animal”, il che significa che la classe “animal” non può essere estesa.
"Class elephant extends animal {…}" cerca di estendere la super class "animal" all'elefante, ma si verifica un errore.
.

 

 

9

 

 

 

 

 

   Polimorfismo

Il polimorfismo descrive la capacità di eseguire metodi diversi per oggetti diversi.

Esempio

class animali{ // classe madre
void voce( ){
System.out.println("fa il suo verso...");
}
}
class Cane extends Animali{ // sottoclasse della classe madre
void voce( ){ // sovraccaricare
System.out.println("Wow, Wow......");
}
}
class Gatto extends Animali{ // altra sub class
void voce( ){ // sovraccaricare
System.out.println("Meow, Meow....");
}
}
class PolymorphismDemo{
public static void main(String args[ ]){ // funzione main
Animali animalVar;
animalVar = new Cane( ); // crea un oggetto cane
animalVar.voce( ); // l'oggetto cane chiama voce()
animalVar = new Gatto( ); // crea un oggetto gatto
animalvar.voce(}; // l'oggetto gatto chiama voce()
}}

SINTASSI

class |animali|{ // classe madre
void |voce( )|{
System.out.println("|fa il suo verso...|");
}
}
class |cane| extends |animali|{ // sottoclasse della classe madre
void |voce( )|{ // sovraccaricare
System.out.println("Wow, Wow......");
}
}
class |gatto| extends |animali|{ // altra sottoclasse
void |voce( )|{ // sovraccaricare
System.out.println("Meow, Meow......");
}
}
class |PolymorphismDemo|{
public static void main(String args[ ]){ // funzione main
Animali |animalVar|;
|animalVar| = new |cane()|; // crea un oggetto cane
|animalVar|.|voce( )|; // l'oggetto cane chiama voce()
|animalVar| = new |gatto( )|; // crea un oggetto gatto
|animalVar|.|voce( )|;// l'oggetto gatto chiama voce()
}
}

Output:
Wow, Wow……
Meow, Meow……

Spiegazione

"AnimalVar = new Cane( )" crea un oggetto cane, quindi, animalVar.voce( ) lo chiama
"AnimalVar = voce( )" crea un metodo voce( ) nella sottoclasse Cane che chiama voce.

"AnimalVar = new Gatto()" crea un oggetto Gatto, quindi "animalVar.Voce ( )" lo chiama nella sottoclasse Cat.

 

 

10

 

 

 

 

 

   Package e Import.

“package package-name” crea o usa un package.
“import package.class” importa un package o sua classe

   esempio

package mioPackage; /* crea un package comprendente 2 classi */
class MiaClasse1 {…}
class MiaClasse2 {…}

package mioPackage; // usa package “mioPackage”
import mioPackage; // importa le classi di mioPackage

  SINTASSI

package |mioPackage|; /* crea un package comprendente 2 classi */
class |MiaClasse1| {…}
class |MiaClasse2| {…}

package |mioPackage|; // usa package “mioPackage”
import |mioPackage|; // importa le classi di mioPackage

  

Spiegazione

“package mioPackage” crea un package di nome “mioPackage”, che contiene due classi.”MiaClasse1” e “MiaClasse2” nel file1.

“import myPackage.” importa ogni classe appartenente al package “mioPackage” dal file1 a un file2.

Nota: il comando “package” deve venire prima del comando “import”.

 

11

 

 

 

 

 

   Build Package - Import Class

package mioPackage; // build costruisce un package
import ogniClasse; // importa una classe

Esempio (In Drive.java)

package mioPackage; // crea un package contenente una classe
public class Drive{
public void getDistanza (int Kmh, float tempo){
System.out.println(“VELOCITÀ:” + mph + “ Km/ORA”);
System.out.println(“TEMPO:” + tempo + “ ORE”);
System.out.println(“DISTANZA:” + tempo*Kmh + “ CHILOMETRI”);
}
}

(In TestDrive.java)

package mioPackage; // usa 'mioPackage'
import mioPackage.Drive; //importa la classe “Drive” in mioPackage
public class TestDrive{
public static void main (String args[ ]) {
Drive mioDrive = new Drive( );
mioDrive.getDistanza(120, 5);}}

==========================================================

SINTASSI (In Drive.java)

package |mioPackage|; // crea un package contenente una classe
public class |Drive|{
public void |getDistanza|(int |Kmh|, float |tempo|){
System.out.println(“VELOCITÀ:” + |Kmh| + “ Km/ORA”);
System.out.println(“TEMPO:” + |tempo| + “ ORE”);
System.out.println(“DISTANZA:” + |tempo|*|Kmh| + “ CHILOMETRI”);
}
}

(In TestDrive.java)

package |mioPackage|; // usa 'mioPackage'
import |mioPackage|.|Drive|; //importa la classe “Drive” in mioPackage
public class |TestDrive|{ //crea la classe “TestDrive”
public static void main (String args[ ]) {
|Drive| |mioDrive| = new |Drive|( );
|mioDrive|.|getDistanza|(|120|,|5|);}}

Output:

Velocità: 120 Km/ORA Tempo: 5 ORE DISTANZA: 600 CHILOMETRI

   Spiegazione

  1. "package mioPackage;” crea il package “mioPackage” nel file Drive.java
  2. “import myPackage.Drive;” importa la classe “Drive” di “mioPackage”.
  3. “Drive mioDrive = new Drive( )” può creare un oggetto “mioDrive” nel file TestDrive, perché la classe Drive è stata importata dal file Drive.java
  4. “mioDrive.getDistanza(120, 5);” chiama un metodo dal file Drive.java .

NB: il comando “package” deve venire prima del comando “import”

 

12

 

 

 

 

 

   Esercitazione: ereditarietà

Start up Eclipse > Select “myPackage” > new > class > name > InheritanceDemo>Inheritance Example

      esempio

package mioPackage1{
class code1{ //classe madre
int x, y;
code1(int a, int b){//costruttore
x = a; y = b; } }

class code2 extends code1{ //sotto classe
code2 (int a, int b){//costruttore
super (a,b);}}// chiama il costruttore nella classe madre

public class InheritanceDemo {
public static void main(String[] args) {// funzione main
int risultato;
code2 numero = new code2(100, 200); /* crea un oggetto “numero”, e chiama il costruttore code2 automaticamente */
risultato = numero.x + numero.y;
System.out.println("Somma = " + risultato);
} }

    SINTASSI

package |mioPackage1|{ // usa 'mioPackage'
class code1{ //classe madre
int |x|, |y|;

|code1|(int |a|, int |b|){ //costruttore della classe
|x|= |a|; |y| = |b|; } }

class |code2| extends |code1|{ //sotto classe
|code2| (int |a|, int |b|){//costruttore
super (|a|,|b|);}} // chiama il costruttore nella classe madre

public class |InheritanceDemo|{
public static void main(String[] args) { // funzione main
int |risultato|;
|code2| |numero| = new |code2|(|100|, |200|); /* crea un oggetto “numero”, e chiama il costruttore code2 automaticamente */
|risultato| = |numero|.|x| + |numero|.|y|;
System.out.println("Somma = " + |risultato|);
} }

Output: Somma = 300 

Cliccate il botton verde dal triangolo bianco nella barra degli utensili per avviare il programma e vedere il risultato

  SPIEGAZIONE

  1. “class code1” crea la super classe “code1”.

  2. “code1(int a, int b){ }” definisce il costruttore della classe.

  3. “class code2 extends code1” crea la sottoclasse “code2” che estende la super classe “code1”.

  4. “code2 (int a, int b){ }” definisce un costruttore.

  5. “super (a,b)” chiama il costruttore nella super classe in modo da inizializzare le variabili x e y.

  6. “public class InheritanceDemo” crea una classe main .

  7. “code2 numero = new code2(100, 200)” crea un oggetto “numero”, che chiama automaticamente il costruttore “code2( ){ }”, e gli passa due parametri 100 e 200, in modo da passarli alle variabili x e y.