Ingegneria del Software

Transcript

1 Ingegneria del Software Java Classi Dichiarazione di Classi [Doc comment] [Modifiers] class ClassName [ extends SuperClassName] [ implements InterfaceName [, InterfaceName]...] {ClassBody Doc comment commento di documentazione Modifiers abstract, final, public,... extends la classe è sottoclasse di un'altra implements la classe realizza una o più interfacce ClassBody i campi e i metodi della classe 1

2 Esempio Dichiarazione di una classe MyClass public class MyClass { int i; /* campo */ public void Add_to_i (int j) { /* metodo */ i = i+j; public MyClass () { /* metodo costruttore: ha lo */ i = 10; /* stesso nome della classe */ Creazione e uso di una istanza di MyClass MyClass mc; /* dichiarazione, non creazione */ mc = new MyClass(); /* creazione: l'attributo i vale 10 */ mc.i++; /* ora i vale 11 */ mc.add_to_i(10); /* e ora i vale 21 */ Dichiarazione di Campi [DocComment] [Modifiers] Type VariableDeclarator [,VariableDeclarator] ; Esempio: Doc comment Modifiers Type VariableDeclarator static int i = 5, j = 7, a[]; commento di documentazione static, public, protected,private, final,... tipo (primitivo o reference) identificatore (anche di array), con eventuale inizializzazione 2

3 Dichiarazione di Metodi [Doc comment] [Modifiers] ReturnType MethodName (ParameterList) [throws ClassType [,ClassType] ] { MethodBody Doc comment Modifiers ReturnType ParameterList commento di documentazione static, public,protected,private, abstract, final,native,... può essere un tipo primitivo o reference, o void (nessun valore di ritorno). Deve essere sempre specificato (ma non per i costruttori) un metodo ha sempre un numero fisso di argomenti (ma è possibile l overloading) Esempio int base; campo della classe public int power (int n) { int i, p; p=1; for (i=1; i<=n; ++i) p=p*base; return p; variabili locali valore della funzione 3

4 Il Modificatore static Campi e metodi dichiarati static, sono associati alla classe e non a una particolare istanza class MyClass { static int a; static void MyMethod() { a = a+1; Pertanto: esiste una sola copia di un campo statico, condiviso da tutte le istanze della classe; non occorre istanziare un oggetto per usare un membro statico; metodi statici possono accedere solo a membri statici della classe Sono qualificati con il nome della classe, e non della istanza MyClass.a =MyClass.a + 1; Esempio class Safe { static int LastSerialNumber; public int SerialNumber; int SetCombination;. Safe(int Combination) { SerialNumber = LastSerialNumber++; SetCombination = Combination; public static StartNewSeriesFrom (int Start) { LastSerialNumber = Start;. Il costruttore Safe fa sì che ogni istanza di Safe abbia un SerialNumber unico Safe.LastSerialNumber(100000); /* inizializza il numero di serie */ Safe MySafe = new Safe(23456); /* crea una Safe di SerialNumber = e combinazione */ MySafe.SerialNumber. 4

5 La Keyword this Se una variabile locale ha lo stesso nome di un membro della sua classe, questo risulta invisibile ( shadowing ) a meno di usare la keyword this, che denota l oggetto corrente Esempio: class MyClass { int x, y, z; /* membri */ void MyMethod (int x) { /* parametro */ int y; /* variabile locale */ y=x+1; /* y è la variabile locale, x è il parametro */ z=this.x; /* this.x è il membro x */ NB: Poichè this denota un oggetto, non si può usare con membri dichiarati static Passaggio di Parametri a un Metodo Tutti i tipi primitivi sono passati per valore Anche i riferimenti a oggetti di tipo reference sono passati per valore Es: int i; SomeObject obj = new SomeObject(); i obj MyMethod( i, obj );. Void MyMethod (int j, SomeObject o) { j o j = j+1; /* non altera i, passato per valore */ o = null; /* non altera obj, che si riferisce ancora all oggetto */ heap 5

6 Costruttori Sono metodi che vengono chiamati quando si crea una istanza di una classe; non ritornano alcun valore Se non definisco alcun costruttore, per default viene fornito il costruttore vuoto: class MyClass { MyClass() { Possono essere overloaded; non ha senso che siano static Esempio di Overloading Dichiarazione di una classe MyNewClass public class MyNewClass { int i; public MyNewClass () { i = 10; public MyNewClass (int j) { i = j; Overloading: metodi omonimi devono essere distinguibili per la quantità e/o per il tipo degli argomenti... Creazione di una istanza di MyNewClass MyNewClass mc0, mc1; /* dichiarazione, non creazione */ mc0 = new MyNewClass(); /* creazione: l'attributo i vale 10 */ mc0.i++; /* ora i vale 11 */ mc1= new MyNewClass(20); /* creazione: l'attributo i vale 20 */ mc1.i++; /* ora i vale 21 */ 6

7 Distruzione di Oggetti Java non supporta distruttori di oggetti: gli oggetti non possono essere distrutti esplicitamente Un oggetto privo di riferimenti incidenti non è più accessibile, e la memoria che esso occupa può essere "riciclata" dal garbage collector, che opera in un thread indipendente a bassa priorità String s; /* dichiarazione, non creazione */ s = new String ("abc"); /* creazione: s punta a "abc" */ s = "def"; /* "abc" non è più puntata da s */ Finalizzatori di Oggetti Un oggetto "riciclabile" (cioè privo di puntatori incidenti) potrebbe trovarsi in uno stato poco "pulito" (ad es. potrebbe aver aperto dei file che non sono stati ancora chiusi) Prima di riciclarlo, il garbage collector invoca il metodo finalize dell oggetto, es.: protected void finalize () throws Throwable {... super.finalize(); /* meglio metterlo sempre */ Il metodo finalize esiste sempre: se non è stato definito, viene ereditato da Object 7

8 Il Modificatore native Un metodo è dichiarato native quando il suo codice è dipendente dalla piattaforma (ad esempio, è scritto in un altro linguaggio) Esempio: public native void seek(long pos) throws IOException ; non deve essere specificato il body Ereditarietà class Animale { float Peso; void Mangia () { class Mammifero extends Animale { int BattitoCardiaco; // eredita Peso void Respira() { // eredita mangia class Gatto extends Mammifero { // eredita BattitoCardiaco, Peso, Mangia, Respira void FaLeFusa() { 8

9 Shadowing e Overriding shadowing un campo di una sottoclasse può nascondere un campo omonimo di una sua superclasse overriding un metodo di una sottoclasse può sovrascrivere un metodo di ugual segnatura e ugual ReturnType di una sua superclasse class SuperClass { int i; void m(int k) { nasconde sovrascrive class Subclass extends Superclass { long i: void m(int n) { La Keyword super per denotare un membro nascosto (campo shadowed o metodo overridden non static), si può usare la keyword super class SuperClass { int i; class Subclass extends SuperClass { long i: i = super.i +1; 9

10 Il Modificatore abstract Una classe è dichiarata abstract quando contiene almeno un metodo abstract (cioè senza body) Una classe abstract non può essere instanziata: occorre sovrascrivere tutti i metodi abstract in una sottoclasse, e istanziare la sottoclasse abstract class a { abstract int m(int k); class b extends a {... int m(int n) { sovrascrive, fornendo la implementazione del metodo final ha tre significati diversi: Il Modificatore final campo final non può essere modificato: è un campo costante (deve essere inizializzato) Esempio: final int i = 5; metodo final non può essere sovrascritto classe final non può avere sottoclassi (quindi i suoi metodi sono implicitamente final) 10

11 Interfacce In sostanza, sono liste di metodi di cui non è definita l implementazione, ma solo l interfaccia Una interface è definita in modo analogo ad una classe, ma ha metodi non implementati e non ha variabili di istanza. Una interface può contenere la definizione di costanti, che sono condivise dalle classi che implementano l interface. Più classi possono implementare la stessa interfaccia, definendone tutti i metodi. La loro implementazione deve essere realizzata da una classe IntStack.java interface IntStack { void push(int item); int pop( ); DynStack.java class DynStack implements IntStack { variabili di istanza e metodi propri... public void push(int item) { corpo di push per DynStack public int pop( ) { corpo di pop per DynStack FixedStack.java class FixedStack implements IntStack { variabili di istanza e metodi propri... public void push(int item) { corpo di push per FixedStack public int pop( ) { corpo di pop per FixedStack 11

12 InterfaceTest.java class InterfaceTest { public static void main (String args[]) { IntStack mystack; FixStack fs = new FixStack(8); DynStack ds = new DynStack(5); mystack = ds; for (int i=0; i<12; i++) mystack.push(i); mystack = fs; for (int i=0; i<8; i++) mystack.push(i); Superinterfacce Una interfaccia può estendere una o più altre interfacce, es.: interface a extends b, c, d {. Ogni classe che implementa un interfaccia deve estendere anche tutte le sue superinterfacce 12

13 Interfacce vs Classi abstract Le interfacce sono simili a classi che abbiano soltanto: metodi abstract campi static e final (cioè costanti) A differenza delle classi, le interfacce permettono di realizzare una forma di ereditarietà multipla 13