The object oriented extension java o of java c java and the java virtual machine ch 5
Advertisement
This presentation is the property of its rightful owner.
1 / 21

The object-oriented extension Java o of Java c (Java and the Java Virtual Machine ch. 5) PowerPoint PPT Presentation

The object-oriented extension Java o of Java c (Java and the Java Virtual Machine ch. 5). PSLab 문세원 . 1. Static semantics of Java o. Definition 5.1.1 : Types A, B, C are generated as follows Primitive types are types(see table 3.1) Classes and interfaces are types

Download Presentation

The object-oriented extension Java o of Java c (Java and the Java Virtual Machine ch. 5)

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


The object oriented extension java o of java c java and the java virtual machine ch 5

The object-oriented extension Javaoof Javac(Java and the Java Virtual Machine ch. 5)

PSLab 문세원


1 static semantics of java o

1. Static semantics of Javao

  • Definition 5.1.1 :

    Types A, B, C are generated as follows

    • Primitive types are types(see table 3.1)

    • Classes and interfaces are types

    • Null and void are types

    • If A is a type different from Null and void, then A[] is a type


1 static semantics of java o1

1. Static semantics of Javao

  • Definition 5.1.2 :

    For reference types, the relation ⊆ is the least reflexive and transitive relation satisfying the following conditions

    • If A ⊂d B, then A ⊆ B.

    • If A is a reference type, then Null ⊆ A and A ⊆ Object

    • A[] ⊆ Cloneable and A[] ⊆ Serializable.

    • If A ⊆ B and A, B are reference types, then A[] ⊆ B[]


1 static semantics of java o2

1. Static semantics of Javao

  • Example 5.1.1 :

    Although every reference type is a subtype of Object, this is not true for primitive types.

    • Java.lang.Integer ⊆ Object

    • int ⊆ Object (x)

  • Note, that although int is a subtype of long the type array int is not a subtype of array of long.

    • int ⊆ long, but int[] ⊆ long[] is not true.


1 1 operators for reference types

1.1 Operators for reference types


1 2 syntax of java o

1.2 Syntax of Javao

  • Syntax of Javao

    • Exp :=...| null | this | Exp.Field | super.Field

      | Expinstanceof Class | (Class) Exp

    • Asgn := ...| Exp.Field = Exp | super.Field= Exp

    • Invk : = ...| newClass(Exps) | Exp.Meth(Exps)

      | super.Meth(Exps)


1 3 constructor declarations

1.3 Constructor declarations

  • Syntax

    <public|protected|private> A(B1 loc1, …,Bn locn) cbody

    cbody := block | {this(exps); bstm…}

    | {super(exps); bstm..}


1 3 constructor declarations1

1.3 Constructor declarations

  • Example

    Class A{

    private int x;

    private int y = 17;

    static int z = 3;

    A(int x){

    this.x = x;

    }

    }

A(int x){

super();

y = 17;

this.x = x;

}


1 4 field access expressions

1.4 Field access expressions

  • Instance field access expressions are transformed at compile-time into the abstract form exp.C/field

  • Instance fields can be accessed

    • exp.field → exp.C/field

    • super.field → this.C/field

    • field → this.C/field


1 5 overloaded methods

1.5 Overloaded methods

  • Instance method invocations expressions are transformed at compile-time into the abstract form exp.D/msig(exps)

  • Instance methods can be invoked

    • α(βexp.methν(exps)) → α(βexp.D/mν(exps))

    • αsuper.methν(exps) → α(βthis.D/mν(exps))

    • αmethν(exps) →α(βthis.D/mν(exps))

  • first step : Compiler computes a set app(α)

  • next step : A most specific method is selected.


1 5 overloaded methods1

1.5 Overloaded methods

  • Instance method invocations have an additional callKind which is used for method lookup (assume D/m)

    • dataKind = Special | Virtual | Super

    • Special, overriding is not allowed and the instance method m in class D is called directly

    • Virtual, then the instance method m is looked up dynamically starting at the class of the target reference

    • Super, the instance method m in class D is called directly


1 6 instance creation expressions

1.6 Instance creation expressions

  • be treated like ordinary method invocations

  • new C(exps) → (new C).C/msig(exps)

  • Since constructors are not inherited, applicable constructors are always in the same class.

  • The callKind of a constructor invocation is Special


1 7 type checking of java o

1.7 Type checking of Javao

  • Table 5.2 Type constraints for Javao


1 7 type checking of java o1

1.7 Type checking of Javao


1 7 type checking of java o2

1.7 Type checking of Javao

  • Table 5.3 Type constraints after introduction of primitive type casts


1 8 vocabulary of java o

1.8 Vocabulary of Javao

  • The following static functions look up compile-time info. in the environment.

    • instanceFields : class → Powerset(Class/Field)

    • defaultVal : Type → Val

    • type: Class/Field → Type

    • lookup: (Class, Class/Msig) → Class

    • type Val = ... | Ref | null

    • data Heap = Object(Class, Map( Class/Field, Val))

      heap : Ref → Heap

      classOf : Ref → Class

      classOf(ref) = case heap(ref) of Object(c, fields) → c


1 8 vocabulary of java o1

1.8 Vocabulary of Javao

package p;

public class A{

String m(){ return “p”;}

public String n(){ return this.m();}

}

package q;

public class B extends p.A{

public String m(){ return “q”;}

public static void main(String[] _){

B x = new B();

Sytem.out.println(x.n());

}

}

lookup(q.B, p.A/m) → lookup(p.A, p.A/m) → p.A

If p.A/m() is declared public,

lookup(q.B, p.A/m) → lookup(q.B, p.A/m) → q.B

Class A{

private int x;

public int y;

public static int z;

}

Class B extends A{

private int x;

}

instanceFields(B)

=[A/x, A/y, B/x]


2 transition rules for java o

2. Transition rules for Javao

  • Fig. 5.2 Execution of Javao expressions

    execJavaExpo = case context(pos) of

    this → yield(locals(“this”))

    new c → if initialized(c) then create ref

    heap(ref) := Object(c,{(f,defaultVal(type(f)))

    | f ∈ instanceFields(c)})

    yield(ref)

    else initialize(c)


2 transition rules for java o1

2. Transition rules for Javao

αexp.c/f → pos : = α

►ref.c/f → if ref not null then yieldUp(getField(ref,c/f))

αexp1.c/f = βexp2→ pos : = α

►ref.c/f = βexp → pos : = β

αref.c/f = ►val → if ref not null then

setField(ref, c/f, val)

yieldUp(val)

αexp instanceof c → pos : = α

►ref instanceof c → yieldUp(ref not null ∧ classOf(ref) ⊆ c)


2 transition rules for java o2

2. Transition rules for Javao

(c)αexp → pos : = α

(c)►ref → if ref = null ∨ classOf(ref) ⊆ c then yieldUp(ref)

αexp.c/mβ(exps) → pos : = α

►ref.c/mβ(exps) → pos : = β

αref.c/m►(vals) → if ref not null then

let c´ = case callKind(up(pos)) of

Virual → lookup(classOf(ref), c/m)

Super → lookup(super(classNm(meth)), c/m)

Special → c

invokdMethod(up(pos), c´/m, [ref]• vals)


2 transition rules for java o3

2. Transition rules for Javao

getField(ref, f) = case heap(ref) of

Object(c, fields) → fields(f)

setField(ref, f, val) =

heap(ref) := Object(c, fields + {(f, val)})

where Object(c, fields) = heap(ref)

exitMethod(result)=

elseif methNm(meth) = “<init>” ∧ result = Norm then

restbody := oldPgm[locals(“this”) / oldPos]


  • Login