Scribd
Upload
47 views4 pages

Laborator 5: Middle - C C - Sharp B - Flat

1. Upcasting allows calling overridden methods of derived classes at runtime. When an object of derived class is passed as a base class reference, the derived class's implementation of overridden methods will be called. 2. Static fields and methods are bound at compile time. Polymorphism does not work for fields - accessing a field returns the compile-time type's field value. 3. Within a constructor, overridden methods are called based on the constructor's class, not the object's runtime class. This can cause issues if the overridden method relies on fully initialized object state.

Uploaded by

user.giu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
47 views4 pages

Laborator 5: Middle - C C - Sharp B - Flat

1. Upcasting allows calling overridden methods of derived classes at runtime. When an object of derived class is passed as a base class reference, the derived class's implementation of overridden methods will be called. 2. Static fields and methods are bound at compile time. Polymorphism does not work for fields - accessing a field returns the compile-time type's field value. 3. Within a constructor, overridden methods are called based on the constructor's class, not the object's runtime class. This can cause issues if the overridden method relies on fully initialized object state.

Uploaded by

user.giu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Laborator 5

1. Upcast se va remarca legarea dinamica a numelor de functii la referintele concrete catre


obiecte rog atentie la numele de fisiere in care trebuie scrise fiecare clasa

public enum Note { //fisier Note.java


MIDDLE_C, C_SHARP, B_FLAT; // Etc.
} ///:~
class Instrument {
public void play(Note n) {
System.out.println("Instrument.play()");
}
}
// Wind objects are instruments because they have the same interface:
public class Wind extends Instrument { //fisier Wind
// Redefine interface method:
public void play(Note n) { // metoda play este cea suprascrisa
System.out.println("Wind.play() " + n);
}
}
public class Music { //fisier Music.java
public static void tune(Instrument i) {
// ...
i.play(Note.MIDDLE_C);
}
public static void main(String[] args) {
Wind flute = new Wind(); //flute este in acelasi timp si Instrument
//tune asteapta un argument de tip Instrument
//dar accepta si obiecte de tip flute
tune(flute); // Upcasting se va executa metoda play din clasa Wind
}
}

2. Campurile si metodele statice sunt legate la compilare. Polimorfismul nu functioneaza in


cazul campurilor

class Super {
public int field = 0;
public int getField() { return field; }
}
class Sub extends Super {
public int field = 1;
public int getField() { return field; }
public int getSuperField() { return super.field; }
}
public class FieldAccess {
public static void main(String[] args) {
Super sup = new Sub(); // Upcast - construim clasa Super cu constructorul clasei Sub
//sup.field = 0 - se afiseaza valoarea din clasa de baza
//sup.getField()=1 - se afiseaza valoarea din clasa derivata (suprascrierea atributelor nu e posibila)
System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField());
Sub sub = new Sub();
System.out.println("sub.field = " + sub.field +
", sub.getField() = " + sub.getField() +
", sub.getSuperField() = " + sub.getSuperField());
}}
3. In constructor nu se realizeaz legare dinamic daca apelam o metoda legata dinamic
(suprascrisa in clasa derivata) in interiorul constructorului se va apela metoda suprascrisa
(pot aparea probleme)

class Glyph {
void draw() { System.out.println("Glyph.draw()"); }
Glyph() {
System.out.println("Glyph() before draw()");
draw(); // atentie: care draw va fi apelat?
//se va apela draw() din clasa derivata
//dar valoarea lui radius nu va fi 1
System.out.println("Glyph() after draw()");
}
}
class RoundGlyph extends Glyph {
private int radius = 1;
RoundGlyph(int r) {
//se face apel automat la constructorul fara
//argumenente din clasa de baza
radius = r;
System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
}
void draw() {
System.out.println("RoundGlyph.draw(), radius = " + radius);
}
}
public class PolyConstructors {
public static void main(String[] args) {
new RoundGlyph(5);
//Glyph - are constructor fara argumente
//constructorul RoundGlyph asigura apelul automat
//al cosntructorului fara argumente din clasa de baza
}
}

4. State design pattern: folositi mostenirea pentru a exprima si coda diferente de


comportament si compozitia pentru a exprima variatii de stare
class Actor {
public void act() {}
}
class HappyActor extends Actor {
//folosim mostenirea pentru a schimba
//comportamente specifice
public void act() { System.out.println("HappyActor"); }
}
class SadActor extends Actor {
public void act() { System.out.println("SadActor"); }
}
class Stage {
//folosim compozitia pentru a schimba starea obiectelor
//prin apel de contructor
private Actor actor = new HappyActor();

public void change() { actor = new SadActor(); }


public void performPlay() { actor.act(); }
}
public class Transmogrify {
public static void main(String[] args) {
Stage stage = new Stage();
//stare initiala a obiectului stage
stage.performPlay();
//modificare stare a obiectului stage
stage.change();
stage.performPlay();
}
}

5. Downcast si RRTI la conversie invers upcast, in caz de esec se arunca exceptie de tipul
ClassCastException

class Useful {
public void f() {}
public void g() {}
}
class MoreUseful extends Useful {
public void f() {}
public void g() {}
public void u() {}
public void v() {}
public void w() {}
}
public class RTTI {
public static void main(String[] args) {
Useful[] x = {
new Useful(),
new MoreUseful()
};
x[0].f();
x[1].g();
// Compile time: method not found in Useful:
//! x[1].u();
((MoreUseful)x[1]).u(); // Downcast/RTTI
//se face conversie dinspre tipul de baza
//spre tipul derivat x[1]-de tip MoreUseful
//x[0] - de tip Useful nu are metoda u()
//desi se face conversie catre tipul MoreUseful
((MoreUseful)x[0]).u(); // Exception thrown
}
}

You might also like