Classi: class Foo { public int x; public int y; public void swap (boolean z) { if (z) {int temp = x; x = y; y = temp;}; }; } Ambienti per le classi: Cenv Cenv = {Ide  Menv x  x Menv} variabili di istanza: metodi: operazioni sugli oggetti  c = { , y->  },  m )> }  m ={ >

Oggetti: istanze di classe ogni oggetto una differente istanza: istanze differiscono per:: i valori nel frame i metodi non cambiamo Class Foo {....}; Foo obj1 = new Foo; Foo obj2 = new Foo;.... frame per obj1:  1 = {x-> , y->  } frame per obj2:  2 = {x-> , y->  } ({x-> , y->  },  m ) Heap per gli oggetti: Heap Heap = {Loc  Ide x  }

Valori, Classi e Oggetti: una vista grafica Class Foo {public int x; public int y; public void swap (boolean z){ if (z) {int temp = x; x = y; y = temp;}; }; } Class Fie { public int y;} } Foo oj1 = new Foo; Fiepp oj2 = new Fie; boolean b = true;.... L2 Il Nuovo Stato : Class_Env x  x Heap Foo cc Fie  fie x  x  y   foo L1 Foo  x  y  y  Fie altri frames dello stato  oj1 oj2 btt  

Sistema di transizioni per: Semantica dei Comandi S S com ={<  com, T com,  com }  com = { | C  Com,  ,  c   c  Cenv,   Heap }   >  { |  ,   Heap }  >  T com = { |  ,   Heap }  com = {(=),..., tutte le regole che vedremo }

Comandi (nuova semantica)  com >  com  com >  com  com  com >  com (Block) (StmL)  c, ,  >  exp v  (x)≠   c, ,   >  com (=)

 exp tt  cmd >  exp tt  cmd  com >  com  exp ff  cmd >  exp ff  cmd  com >  com (if-tt) (if-ff) Condizionale

 exp ff >  exp ff  com ,  >  com  exp tt  cmd >  exp tt >  cmd >  com  com >  com (W-ff) (W-tt) Iterazione (while)

La sintassi del nucleo Progr::=prog {ClassDeclList {StmtList}} ClassDecl_List::=ClassDecl | ClassDecl ClassDeclList ClassDecl::=class Ide {StatMetDecList InstVarDecList MetDecList} InstVarDecList::=InstVarDec | InstVarDec InstVarDecList InstVarDec::=public Type Ide StmtList::= Stmt | Stmt StmtList Stmt::= Com | Decl Decl::= Type Ide | Type Ide= Exp; | Type ide = new Ide(); Type::= int | boolean | char | Ide Block::= {StmtList} Exp::= Ide.Ide | Ide | NumExp | BoolExp | Ide.Ide m (Exp)

La sintassi del nucleo MetDecList::= MetDec MetDecList |  MetDec::=public void Ide(T Ide){StmtList} StatMetDecList::= StatMetDec StaticMetDecList |  StatMetDec::=public static TypeR Ide(Type Ide){StmtList} TypeR::=Type | void Com::= Ide= Exp; | Ide.Ide=Exp; | Ide = new Ide(); | Block |Ide.Ide m (Exp) | if (BoolExp) Com else Com; | while (BoolExp) Com;

Esempio prog{ class Foo { public int x; public int y;} class Fie { public int x;} {Foo oj1= new Foo(); Fie oj2= new Fie(); oj1.x=5; oj1.y=oj1.x+4; oj2.x=oj1.x+oj1.y;}} public class volume { public static class Foo { publicint x ; public int y;} public static class Fie { publicint x ;} public static void main (String [ ] args) { Foo oj1=new Foo(); Fie oj2=new Fie(); oj1.x=5; oj1.y=oj1.x+4; oj2.x=oj1.x+oj1.y; }} programma Java

 classdecl  c  com ,   classdecl  c >  com  classdecl ,   classdecl (prog) Semantica: il programma

  c ’   c ”   c ’   c ” <ClassDecl ClassDecList,  c   c ” <ClassDecl ClassDecList,  c   c ”  istdecl s  istdecl   mdl m  istdecl  s  istdecl   mdl  m / c]   c [ / c] Semantica: classi (classdecl) (classdeclList)

  s [ /m]   s [ /m]   s ’   s ”   s ’   s ” < MetDef MetDefList,  s   s ”  istdecl  [  /x]  istdecl  [  /x]   ”   ’   ”   ”   ” (instdecl) Semantica: istanza e metodi d’istanza (instdeclist) (MetDef) (MDL)

 c (c) = l = newloc (  )  c (c) = l = newloc (  ) >  /l ]> >   = .  ’ >   = .  ’  = .  ’ >  new (declnew) Semantica: dichiarazioni di oggetti (declnonew)

>   ’ =  [v/x] >  v  (o)= l  ( l )=  ’ =  [v/x] >   (o)=l  (l)=  (o)=l  (l)= >   ( x ) (com =new ) (com o.x= ) Semantica: assegnamento ed espressioni exp o.x

 c (c)=  m (m)=  >  v  (o)=l  (l)=  c (c)=  m (m)=  >  Semantica: metodi d’istanza invocazione (Ipotesi che le espressioni non modifichino lo stato) invoc