Ereditarietà

Vogliamo:

class Point {
  int x;
  int y;
  Point (int x1, int y1) {
    x = x1;
    y = y1;
  }
}

class ColouredPoint extends Point {
  String colour;
  ColouredPoint (int x, int y, String colour) {
    this.x = x;
    this.y = y;
    this.colour = colour;
  }
}

ColouredPoint pt = new ColouredPoint(3, 4, "red");
pt.x += 1;
pt.colour = "blue";

Point pt = new ColouredPoint(3, 4, "red");
pt.colour = "blue";

Cast

Point pt = new ColouredPoint(3, 4, "red");
((ColouredPoint) pt).colour = "blue";

class Point {
  ...
  int distanceToPoint() {
    return (int) Math.sqrt(x * x + y * y);
  }
  ...
}

Instanceof

(new Point(3, 4)) instanceof Object è vero

(new ColouredPoint(3, 4, "true)) instanceof Point è vero

(new ColouredPoint(3, 4, "true)) instanceof ColouredPoint è vero

(new Point(3, 4)) instanceof ColouredPoint è falso

((Point) (new ColouredPoint(3, 4, "red"))) instanceof ColouredPoint è vero

class Point {
  ...
  boolean equals(Object o) {
    if (o instanceof Point)  {
      return (((Point) o).x == x) && (((Point) o).y == y);
    } else { 
      return false;
    }
  }
  ...
}

Null

null instanceof Object è vero

 String pt = null;

Overriding

class ColouredPoint extends Point {
  ...
  boolean equals(Object o) {
    if (o instanceof ColouredPoint)  {
      ColouredPoint pt = (ColouredPoint)o;
      return (pt.x == x) && (pt.y == y) && colour.equals(pt.colour);
    } else { 
      return false;
    }
  }
  ...
}

Super

class ColouredPoint {
  ColouredPoint (int x, int y, String colour) {
    super(x, y);
    this.colour = colour;
  }
  boolean equals(Object o) {
    if (o instanceof ColouredPoint) {
      return super.equals(o) && colour.equals(((ColouredPoint) o).colour);
    } else { 
      return false;
    }
  }
}

Estensione

class A {
  A(){
  }
  int method() {
    return 1;
  }
}
class B extends A {
  B() {
  }
}

Il contrario non è vero.

class A {
  A(){
  int method() {
    return 1;
  }
}
class B extends A {
  B() {
  int method2() {
    return 2;
  }
}

Se c'è bisogno, si può anche cambiare il comportamento riscrivendo il metodo (overriding):

class A {
  A(){
  }
  int method() {
    return 1;
  }
}
class B extends A {
  B() {
  }
  int method() {
    return 2;
  }
}

Questo è vero anche quando l'oggetto è un parametro (overloading):

class C {
  C() {
  }
  int method(A a) {
    return 2;
  }
}

class C {
  C() {
  }
  int method(Object a) {
    return 2;
  }
  int method(A a) {
    return 3;
  }
}

La scelta del metodo può non essere unica:

class C {
  C() {
  }
  int method(B a) {
    return 1;
  }
}
class D extends C {
  D() {
  }
  int method(A a) {
    return 2;
  }
}

Tipi

vero tipo o tipo dinamico (Run time type)

tipo nel programma o tipo statico (Compile time type)

Point pt = new ColouredPoint(3, 4, "red");

Il tipo dinamico di pt è ColouredPoint.

int method (Point pt) {
  ...
}

Il tipo dinamico pt è sconosciuto.

Selezionare i metodi

Golden Rules

Overriding: Tipo dinamico

object1.method(object2)

1. Trova il tipo statico di object1
2. Nella class che definisce il tipo statico di object1, trova il metodo più specifico che accetta il tipo statico di object2.
3. Nell'esecuzione del metodo selezionato al passo 2, il corpo eseguito sarà quello del tipo dinamico di object1
.

Esempi

class A {
  int method(A a) {
    return 1;
  }
  int method(B a) {
    return 2;
  }
}
class B extends A {
  int method(A a) {
    return 3;
  }
  int method(B a) {
    return 4;
  }
}

A a1 = new A();
B a2 = new B();
A a3 = new B();

Con:

class A {
  int method(A a) {
    return 1;
  }
}
class B extends A {
  int method(A a) {
    return 3;
  }
  int method(B a) {
    return 4;
  }
}

A a1 = new A();
B a2 = new B();
A a3 = new B();

Con:

class A {
  int method(A a) {
    return 1;
  }
  int method(B a) {
    return 2;
  }
}
class B extends A {
  int method(B a) {
    return 4;
  }
}

A a1 = new A();
B a2 = new B();
A a3 = new B();

Con:

class A {
  int method(B a) {
    return 2;
  }
}
class B extends A {
  int method(A a) {
    return 3;
  }
  int method(B a) {
    return 4;
  }
}

A a1 = new A();
B a2 = new B();
A a3 = new B();

Con:

class A {

  int method(A a) {
    return 1;
  }
  int method(B a) {
    return 2;
  }
}
class B extends A {
  int method(A a) {
    return 3;
  }
}

A a1 = new A();
B a2 = new B();
A a3 = new B();

Overloading

class Print {
  static String toString(Object o) {
    return "Object";
  }
  static String toString(Point pt) {
    return "(" + pt.x + ", " + pt.y + ")";
  }
  static String toString(ColouredPoint pt) {
    return "(" + pt.x + ", " + pt.y + ")" + ":" + colour;
  }
}

Point pt = new Point(3, 4);

ColouredPoint pt = new CoulouredPoint(3, 4, "red");

Point pt = new CoulouredPoint(3, 4, "red");

Un'alternativa per Print

class Print {
  static String toString(Object o) {
    return "Object";
  }
  static String toString(Point pt) {
    return "(" + pt.x + ", " + pt.y + ")";
  }
  static String toString(ColouredPoint pt) {
    return toString((Point) pt) + ":" + colour;
  }
}

class Obj {
  static void method (Point pt1, ColouredPoint pt2) {
    ..
  }
  static void method (ColouredPoint pt1, Point pt2) {
    ..
  }
}

ColouredPoint pt = new ColouredPoint(3, 4, "red");
Obj.method(pt, pt);

Overriding

class Point {
  ...
  String toString() {
    return "(" + x + ", " + y + ")";
  }
  ...
}
class ColouredPoint extends Point {
  ...
  String toString(ColouredPoint pt) {
    return super.toString() + ":" + colour;
  }
  ...
}

Point pt = new Point(3, 4);

ColouredPoint pt = new CoulouredPoint(3, 4, "red");

Point pt = new CoulouredPoint(3, 4, "red");

Overloading e Overriding

class Print {
  String toString(Point pt) {
    return "(" + pt.x + ", " + pt.y + ")";
  }
}
class ColourPrint extends Print {
  String toString(Point pt) {
    return super.toString(pt) + ":black";
  String toString(ColouredPoint pt) {
    return super.toString(pt) + ":" + colour;
  }
}

Print pr = new ColourPrint();
Point pt = new CoulouredPoint(3, 4, "red");

Che cosa non va con:

class Point {
  ...
  boolean equals(Point pt) {
      return (pt.x == x) && (pt.y == y);
    } else { 
      return false;
    }
  }
  ...
}
class ColouredPoint extends Point {
  ...
  boolean equals(ColouredPoint pt) {
      return super.equals(pt) && colour.equals(pt.colour);
    } else { 
      return false;
    }
  }
  ...
}

ColouredPoint pt1 = new ColouredPoint(3, 4, "red");
Point pt2 = new ColouredPoint(3, 4, "blue");

Metodi statici

class A {
  static int getVal() {
    return 1;
  }
}

class B extends A {
  static int getVal() {
    return 2;
  }
}

  A a = new A();
  B b = new B();
  A c = new B();

Un metodo non statico non può essere overriding con un metodo statico. Questo non è valido:

class A {
  int getVal() {
    return 1;
  }
}

class B extends A {
  static int getVal() {
    return 2;
  }
}

Abstract

class Tree {
}
class Node extends Tree {
  Tree right;
  Tree left;
  Node (Tree left, Tree right) {
    this.left = left;
    this.right = right;
  }
}
class Leaf extends Tree {
  String s;
  Leaf (String s) {
    this.s = s;
  }
}

Adesso vogliamo calcolare il numero delle foglie di un albero. Questo non va bene:

class Node extends Tree {
  ...
  int getSize() {
    return left.getSize() + right.getSize();
}
class Leaf extends Tree {
  ...
  int getSize() {
    return 1;
  }
}

Soluzione:

abstract class Tree {
  abstract int getSize();
}
class Node extends Tree {
  ...
  int getSize() {
    return left.getSize() + right.getSize();
}
class Leaf extends Tree {
  ...
  int getSize() {
    return 1;
  }
}

Non si può fare new su una class abstract.

Final

class Node extends Tree {
  ...
  final int getSize() {
    ...
  }
}

I campi con il modificatore final sono costanti:

class A {
  final float pi = 3.1415926;
}

class A {
  static final pi = 3.14151926;
}

Array

(new ColouredPoint[2]) instanceof Point[] è vero

Point[] pts = new ColouredPoint[10];
pts[0] = new ColouredPoint(3, 4, "blue");
((ColouredPoint) pts)[0].color = "red";

Point[] pts = new ColouredPoint[10];
pts[0] = new Point(3, 4);

class foo {
  void putFirst (Point[] pts) {
    pts[0] = new Point(3, 4);
  }
  void start () {
    ColouredPoint[] pt = new ColouredPoint[3];
    putFirst(pt);
  }
}

Esercizi

D2. Scrivere un metodo maxLength che ritorna una delle stringhe che ha la massima lunghezza in un albero.

D3. Scrivere un metodo listOf che ritorna l'array contenente tutte le stringhe in un albero.

D4. Scrivere un metodo equals che prede un oggetto e verifica se l'albero è uguale all'oggetto.

D5*. Modificare le classe Tree, Node e Leaf in tale modo che gli alberi possono avere un numero arbitrario di figli. Aggiornare in conseguenza i metodi in, maxLength, listOf e equals.

D6*. Definire una classa astratta List e due sottoclassi Cons e Nil per rappresentare le liste di numeri interi tale che la lista composta dei numeri 1, 2 e 3 può essere creata tramite l'espressione new Cons(1, new Cons(2, new Cons(3, new Nil()))).

Aggiungere in List:

• un metodo in che prende un numero intero e verifica se tale numero intero è nella lista;
• un metodo sorted che verifica se la lista è ordinata in modo strettamente crescente;
• un metodo makeEmpty che crea una lista vuota;
• un metodo add che prende un numero intero e restituisce una nuova lista che contiene la lista iniziale piú il numero intero. Se il numero è già nella lista, il metodo solleva l'eccezione ListException. Inoltre si supponga che la lista sulla quale si applica il metodo add sia sempre ordinata. Di conseguenza il risultato deve essere una lista ordinata.

D7*. Definire una classa astratta Path e due sottoclassi Move e Select per rappresentare un camino in un albero tale che il camino new Move(2, new Move(1, new Select())) rappresenta il verso il primo figlio del secondo figlio dell'albero. Aggiungere in la classe Tree dell'esercizio C5:

• un metodo getPath che, dato un albero t, restituisce il cammino verso t se t compare nell'albero su cui è applicato il metodo, altrimenti solleva l'eccezione NotFoundException.
• un metodo getTree che, dato un cammino p, restituisce il sottoalbero denotato da p, altrimenti (se il cammino non è valido) solleva l'eccezione NotFoundException.

D8*. Definire una classa astratta Multi e due sottoclassi Single e Empty per rappresentare dei multinsiemi sui numeri interi tale che il multinsieme {1, 1, 3, 3, 3} può essere creato tramite l'espressione new Single(1, 2, new Single(3, 3, new Empty())).

Aggiungere in Multi:

• un metodo getMulti che prende un numero intero e restituisce il numero di volte che tale numero compare nella lista (0 se non compare);
• un metodo add che aggiunge un numero intero ad un multinsieme;
• un metodo makeEmpty che crea un multinsieme vuoto;
• un metodo in che prende un multinsieme e restituisce un booleano tale che a1.in(a2) è vero se a1 è incluso in a2;
• un metodo equals che prende un oggetto e restituisce un booleano tale che a1.equals(a2) è vero se a2 è un oggetto di tipo Multi e contiene gli stessi numeri di a1 con la stessa molteplicità.

D9*. Definire una classa astratta Exp e tre sottoclassi Int, Plus e Mult per rappresentare le espressioni arimetiche tale che l'espressione (1 + 2) * 3 possa essere rappresentata come Exp a = new Mult(new Plus(new Int(1), new Int(2)), new Int(3))}.

Quindi aggiungere nella classe Exp:

• un metodo pubblico val che calcola il valore che rappresenta l'espressione. Per esempio a.val() ritorna l'intero 9;
• un metodo pubblico equals che permette di verificare l'uguaglianza. Tale metodo prende un oggetto di qualunque tipo. Per esempio a.equals("abc") ritorna il booleano false;
• un metodo pubblico in che permette di verificare se un'espressione compare in un'altra. Per esempio a.in(new Plus(new Int(1), new Int(2)))