Legare static/dinamic

static/dynamic binding n Java

Programare Orientat pe Obiecte

Polimorfism

Polimorfism abilitatea unui obiect de a se

comporta diferit la acelai mesaj
Dou tipuri: static i dinamic

Suprancrcarea (overloading)
Supradefinirea (overriding)

class A {
void metoda() {
System.out.println("A: metoda fara parametru");
}
// Suprancrcare
void metoda(int arg) {
System.out.println("A: metoda cu un parametru");
}
}
class B extends A {
// Supradefinire
void metoda() {
System.out.println("B: metoda fara parametru");
}
}
Static/dynamic binding n Java

Binding procesul de a stabili ce metod

sau variabil va fi apelat

Static binding i dynamic binding - dou

concepte importante n Java
Legate direct de execuia codului
Mai multe metode cu acelai nume (method
overriding) sau dou variabile cu acelai nume n
aceeai ierarhie de clase, care este utilizat?
Majoritatea referinelor sunt rezolvate n timpul
compilrii, dar cele care depind de obiect i
polimorfism sunt rezolvate la execuie, atunci cnd
este de fapt disponibil obiectul.

Dynamic binding late binding (la execuie)

Static binding early binding (la compilare)
Static/dynamic binding n Java

Diferena ntre static i dynamic binding n

Java

ntrebare popular la angajarea n domeniu

Exploreaz cunotinele candidailor legate

de cine determin ce metod va fi apelat
dac exist mai multe metode cu acelai
nume, ca n cazul metodelor suprancrcate
sau supradefinite (method overloading and
overriding).

Compilatorul sau JVM maina virtual

Java?
Legare static/dinamic
Static/dynamic binding n Java

class Vehicle {
public void drive() {
System.out.println("A");
}
}

class Car extends Vehicle {

public void drive() {
System.out.println("B");
}
}
class TestCar {
public static void main(String args[]) {
Vehicle v;
Car c;
v = new Vehicle();
c = new Car();
v.drive();
c.drive();
v = c;
v.drive();
}
}
Output

A
B
B
Polimorfism

Legarea dinamic are loc n Java pentru

orice metod care nu are atributul final sau
static, metod numit polimorfic.
In Java majoritatea metodelor sunt
polimorfice.
Metodele polimorfice Java corespund
functiilor virtuale din C++.
Apelul functiilor polimorfice este mai putin
eficient ca apelul functiilor cu o singura
form.
Fiecare clas are asociat un tabel de
pointeri la metodele (virtuale) ale clasei.
Static Binding vs Dynamic
binding n Java

Diferene ntre legarea static i cea dinamic n Java:

Static binding se realizeaz la Compilare n timp
ce Dynamic binding se realizeaz la Rulare -
Execuie.

Metodele i variabilele private, final sau static

utilizeaz static binding n timp ce metodele
virtuale - abstracte utilizeaz dynamic binding.

Static binding se face pe baza informaiei legate

de Tip (clasa n Java), n timp ce Dynamic binding
utilizeaz Obiectul pentru a realiza legarea.

Static binding este folosit frecvent la metodele

suprancrcate (overloaded methods), Dynamic
binding (dynamic dispatch) este asociat n general
cu metodele supradefinite (overriding methods).
Static Binding: Exemplu Java

public class StaticBindingTest {

public static void main(String args[]) {
Collection c = new HashSet();
StaticBindingTest et = new StaticBindingTest();
et.sort(c);
}
// metoda supraincarcata cu argument Collection
public Collection sort(Collection c){
System.out.println("In metoda sort(Collection)!");
return c;
}
/*metoda supraincarcata cu argument HashSet, subclasa
a lui Collection */
public Collection sort(HashSet hs){
System.out.println(In metoda sort(HashSet )!");
return hs;
}
}
Output: In metoda sort(Collection)!
Dynamic Binding: Exemplu Java

class Vehicle {
public void start() {
System.out.println("In metoda start din Vehicle!");
}
}
class Car extends Vehicle {
public void start() {
System.out.println ("In metoda start din Car!");
}
}
public class DynamicBindingTest {
public static void main(String args[]) {
Vehicle vehicle = new Car(); //tip Vehicle, dar obiect Car
vehicle.start(); //start din clasa Car - start() e supradef
}
}

Output: In metoda start din Car!

Dynamic Binding

Conceptul de overriding
Car extends Vehicle - supradefinete start()
Apelul lui start() pentru un obiect Vehicle,
apeleaz start() din subclasa Car deoarece
obiectul referit de tipul Vehicle este un obiect
Car
Aceasta se petrece la execuie pentru c
obiectul este creat doar la execuie ->
Dynamic binding in Java.
Dynamic binding este mai ncet dect static
binding pentru c apare n momentul execuiei
i necesit timp pentru a determina care
metod este apelat de fapt.
Exemplu Static Binding vs
Dynamic binding

public class Animal {

public String type = "mamifer";
public void show() {
System.out.println(Animalul este un: " + type);
}
}
public class Dog extends Animal {
public String type;
public Dog(String type){
this.type = type;
}
public void show() {
System.out.println(Cainele este un: " + type);
}
}

Animal doggie = new Dog(ciobanesc");
doggie.show();
System.out.println (Tipul este: " + doggie.type);
....
Exemplu Static Binding vs
Dynamic binding

Output:
Cainele este un: ciobanesc
(dynamic binding)
Tipul este: mamifer
(static binding)

Ce se afiseaza daca comentam in clasa Dog:

public String type;

Output:
Cainele este un: ciobanesc
Tipul este: ciobanesc
Observaii

Datele nu sunt niciodat supradefinite, doggie.type

folosete Animal.type -- "static binding
Avantaj: comportamentul este legat de tipul obiectului
invocat, fr ca noi s tim precis tipul acestuia.
Exemplu: Daca trimitem un Animal, nu tim dac
este Cat/Dog/altceva, dar el va adopta
comportamentul adecvat:
public void makeNoise(List<Animal> animals) {
for (Animal a : animals) {
a.makeNoise();
}
}
Fiecare animal din lista va produce propriul zgomot
(va mieuna, ltra, etc)
Observaie: Clasa Animal poate fi abstracta. Astfel,
comportamentul va fi definit de clasele concrete
derivate din ea.
Exemplu

public class Shape {

int x= 10;
void draw() {
System.out.println(Shape);
}
}
public class Circle extends Shape{
int x=5;
void draw(){
System.out.println(Circle);
}
}
public class Test{
public static void main(String[] args) {
Shape shape = new Circle();
shape.draw(); // DYNAMIC BINDING
System.out.println(shape.x); // STATIC BINDING
}
}
Explicaii

Atunci cnd compilatorul vede apelul draw(), el tie c

obiectul respectiv este de tipul Shape, dar el tie i c
acel obiect poate fi o referin la orice clas derivat din
Shape.
De aceea, compilatorul nu tie ce versiune a metodei
draw() este de fapt apelat. Aceasta se va ti doar n
momentul execuiei instruciunii respective:
shape.draw(); - metoda draw din Circle

n unele cazuri, compilatorul poate determina versiunea

corect
n Java, variabilele membru prezint static binding,
deoarece Java nu permite comportament polimorfic
pentru variabilele membru.
Aceasta nseamn c att clasa Shape ct i clasa
Circle au o cte o variabil membru cu acelai nume:
System.out.println(shape.x); - valoarea lui x din Shape.
Concluzie - dynamic binding

metodele suprascrise n clasele derivate vor

fi apelate folosind dynamic binding (late
binding).
este un mecanism prin care compilatorul, n
momentul n care nu poate determina
implementarea unei metode n avans, las
la latitudinea JVM-ului (mainii virtuale)
alegerea implementrii potrivite, n funcie
de tipul real al obiectului.
aceast legare a implementrii de numele
metodei la momentul execuiei st la baza
polimorfismului.
Ce va afia urmtorul program?

class TestEgal{
public boolean equals ( TestEgal other ) {
System.out.println( "In equals din TestEgal" ); return false;
}
public static void main( String [] args ) {
Object t1 = new TestEgal(), t2 = new TestEgal();
TestEgal t3 = new TestEgal();
Object o1 = new Object();
int count = 0;
System.out.println( count++ ); // afiseaza 0
t1.equals( t2 ) ;
System.out.println( count++ ); // afiseaza 1
t1.equals( t3 );
System.out.println( count++ ); // afiseaza 2
t3.equals( o1 );
System.out.println( count++ ); // afiseaza 3
t3.equals(t3);
System.out.println( count++ ); // afiseaza 4
t3.equals(t2);
}
}
Rezolvare

Output:
0
1
2
3
In equals din TestEgal
4

Atenie! Este vorba de overload nu override!

Metoda public boolean equals ( TestEgal other )
Nu supradefinete metoda public boolean equals (
Object other ) din clasa Object, ci o suprancarc!
Deci, static binding! Singurul loc n care se apleeaz
equals din TestEgal este t3.equals(t3); !
Exerciiu propus

Cum ar trebui s fie definite clasele Adult, Student i

Inginer astfel nct urmtoarea secven s dea
eroare la compilare doar unde este specificat?

class Test {
public static void main(String args[]) {
Adult a = new Student(); /* fara
eroare */
Adult b = new Inginer();/* fara
eroare */
a.explorare(); // fara eroare
b.explorare(); // fara eroare
a.afisare(); //fara eroare
b.afisare(); //eroare la compilare!
}
}
Exerciiu propus

class Ana {
public void print(Ana p) {
System.out.println("Ana 1\n");
}
}
class Mihai extends Ana {
public void print(Ana p) {
System.out.println("Mihai 1\n");
}
public void print(Mihai l) {
System.out.println("Mihai 2\n");
}
}
class Dana extends Mihai {
public void print(Ana p) {
System.out.println("Dana 1\n");
}
public void print(Mihai l) {
System.out.println("Dana 2\n");
}
public void print(Dana b) {
System.out.println("Dana 3\n");
}
}
Exerciiu propus

public class Test{

public static void main (String [] args) {
Mihai stud1 = new Dana();
Ana stud2 = new Mihai();
Ana stud3 = new Dana();
Dana stud4 = new Dana();
Mihai stud5 = new Mihai();
1 stud1.print(new Ana());
2 ((Dana)stud1).print(new Mihai());
3 ((Mihai)stud2).print(new Ana());
4 stud2.print(new Dana());
5 stud2.print(new Mihai());
6 stud3.print(new Dana());
7 stud3.print(new Ana());
8 stud3.print(new Mihai());
9 ((Dana)stud3).print(new Mihai());
10 ((Dana)stud3).print(new Dana());
11 stud4.print(new Dana());
12 stud4.print(new Ana());
13 stud4.print(new Mihai());
14 stud5.print(new Dana());
15 stud5.print(new Mihai());
16 stud5.print(new Ana()); } }
Ierarhie

Ana print (Ana)

|
Mihai print (Ana), print (Mihai)
|
Dana print (Ana), print (Mihai), print (Dana)

Tip nume -> obiect

Mihai - stud1 -> Dana

Ana - stud2 -> Mihai
Ana - stud3 -> Dana
Dana - stud4 -> Dana
Mihai - stud5 -> Mihai
 Colecii

Programare Orientat pe Obiecte

Colecii

Ce sunt coleciile ?
Interfee ce descriu colecii
Implementri ale coleciilor
Folosirea eficient a coleciilor
Algoritmi polimorfici
Tipuri generice
Iteratori i enumerri
Ce sunt coleciile ?

O colecie este un obiect care grupeaz mai

multe elemente ntr-o singur unitate.
Tipul de date al elementelor dintr-o colecie
este Object.

Tipuri de date reprezentate:

vectori
liste nlnuite
stive
mulimi matematice
tabele de dispersie
dicionare, etc.
Arhitectura coleciilor

Interfee: tipuri abstracte de date ce descriu

coleciile i permit utilizarea lor independent de
detaliile implementrilor.
Implementri: implementri concrete ale interfeelor
ce descriu colecii (clase); reprezint tipuri de date
reutilizabile.
Algoritmi polimorifici: metode care efectueaz
diverse operaii utile(cutare, sortare) definite
pentru obiecte ce implementeaz interfeele ce
descriu colecii. Aceti algoritmi se numesc i
polimorfici deoarece pot fi folosii pe implementri
diferite ale unei colecii, reprezentnd elementul de
funcionalitate reutilizabil.

Avantaje:
Reducerea efortului de programare
Creterea vitezei i calitii programului
 Interfee ce descriu colecii

Collection - modeleaz o colecie la nivelul cel mai

general, descriind un grup de obiecte (elementele sale).
Map - descrie structuri de date de tip cheie valoare,
asociaz fiecarui element o cheie unic, dup care poate
fi regsit.

Collection
Map
Set List
SortedMap
SortedSet

AbstractCollection
AbstractMap

AbstractSet AbstractList
Collection

public interface Collection {

// Metode cu caracter general
int size();
boolean isEmpty();
void clear();
Iterator iterator();
// Operatii la nivel de element
boolean contains(Object element);
boolean add(Object element);
boolean remove(Object element);
// Operatii la nivel de multime
boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
// Metode de conversie in vector
Object[] toArray();

}
Set

Mulime n sens matematic.

O mulime nu poate avea elemente duplicate:
nu poate conine dou obiecte o1 i o2 cu
proprietatea o1.equals(o2).
Implementri: HashSet, LinkedHashSet i
TreeSet.
Set (I)
AbstractSet
(clasa abstract)
SortedSet (I)

HashSet

TreeSet
LinkedHashSet
SortedSet

mulime cu elemente sortate.

ordonarea elementelor se face
conform ordinii lor naturale, sau
conform cu ordinea dat de un
comparator specificat la crearea
coleciei
ordinea este meninut automat la
orice operaie efectuat asupra
mulimii.
pentru orice dou obiecte o1, o2 ale
coleciei, apelul o1.compareTo(o2)
(sau comparator.compare(o1, o2),
dac este folosit un comparator)
trebuie s fie valid i s nu provoace
excepii
SortedSet

public interface SortedSet extends Set {

// Subliste
SortedSet subSet(Object fromElement,
Object toElement);
SortedSet headSet(Object toElement);
SortedSet tailSet(Object fromElement);
// Capete
Object first();
Object last();
Comparator comparator();
}
Implementare: TreeSet help
HashSet, LinkedHashSet

HashSet: tabel de dispersie (hash table);

implementarea cea mai performant
calculeaz codul de dispersie al elementelor pe
baza metodei hashCode, definit n clasa
Object
nu avem garanii asupra ordinii de parcurgere.
doi iteratori diferii pot parcurge elementele
mulimii n ordine diferit.

LinkedHashSet : tabel de dispersie.

Diferena fa de HashSet - menine o list dublu-
nlnuit peste toate elementele sale. =>
elementele rmn n ordinea n care au fost
inserate.
List

liste de elemente indexate.

pot contine duplicate i permit un control precis
asupra poziiei unui element prin intermediul indexului
acelui element.
exist metode pentru acces poziional, cutare i
iterare avansat.
Implementri: ArrayList, LinkedList, Vector, Stack.

List (I)

AbstractList (A)

ArrayList LinkedList Vector

Stack
List (2)

public interface List extends Collection {

// Acces pozitional
Object get(int index);
Object set(int index, Object element);
void add(int index, Object element);
Object remove(int index);
abstract boolean addAll(int index, Collection c);
// Cautare
int indexOf(Object o);
int lastIndexOf(Object o);
// Iterare
ListIterator listIterator();
ListIterator listIterator(int index);
// Extragere sublista
List subList(int from, int to);
}
Map

structuri de tip: cheie element, ce asociaz

fiecarui element o cheie unic, dup care
poate fi regsit.
nu pot conine chei duplicate i fiecare cheie
este asociat unui singur element.

public interface Map {

// Metode cu caracter general
int size();
boolean isEmpty();
void clear();
// Operatii la nivel de element
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
Map(2)

// Operatii la nivel de multime

void putAll(Map t);
// Vizualizari ale colectiei
public Set keySet();
public Collection values();
public Set entrySet();
// Interfata pentru manipularea unei inregistrari
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
}
Implementri: HashMap, TreeMap,
LinkedHashMap - i Hashtable.
SortedMap

Mulimea cheilor este sortat conform ordinii

naturale sau unui comparator.
public interface SortedMap extends Map {
// Extragerea de subtabele
SortedMap subMap(Object fromKey, Object
toKey);
SortedMap headMap(Object toKey);
SortedMap tailMap(Object fromKey);
// Capete
Object first();
Object last();
// Comparatorul folosit pentru ordonare
Comparator comparator();
}
Implementare: TreeMap - help
Interfaa Map.Entry

desemneaz o pereche (cheie, valoare) din

map.
Metode:
getKey: ntoarce cheia
getValue: ntoarce valoarea
setValue: permite stabilirea valorii asociat
cu aceast cheie
Implementri ale coleciilor

< Implementare >< Interfata >

Interfaa Clasa
Set HashSet, LinkedHashSet
SortedSet TreeSet
List ArrayList, LinkedList,Vector, Stack
Map HashMap, Hashtable
SortedMap TreeMap
Organizare ierarhic
AbstractCollection - AbstractSet, AbstractList -
HashSet, TreeSet... Vector-Stack
AbstractMap - HashMap, TreeMap, HashTable
In vechea ierarhie:
Dictionary - Hashtable Properties
se observ existena unor clase care ofer aceeai
funcionalite, cum ar fi ArrayList i Vector, HashMap i
Hashtable.
Caracteristici comune

permit elementul null

sunt serializabile
au definit metoda clone
au definit metoda toString
permit crearea de iteratori
au att constructor fr argumente ct
i un constructor care accept ca
argument o alt colecie
exceptnd clasele din arhitectura
veche, nu sunt sincronizate.
Folosirea eficient a coleciilor

ArrayList sau LinkedList ?

import java . util .*;
public class TestEficienta {
final static int N = 100000;
public static void testAdd ( List lst) {
long t1 = System . currentTimeMillis ();
for (int i=0; i < N; i++)
lst.add (new Integer (i));
long t2 = System . currentTimeMillis ();
System . out. println ("Add: " + (t2 - t1));
}
public static void testGet ( List lst) {
long t1 = System . currentTimeMillis ();
for (int i=0; i < N; i++)
lst.get (i);
long t2 = System . currentTimeMillis ();
System . out. println ("Get: " + (t2 - t1));
}
ArrayList sau LinkedList ?

public static void testRemove ( List lst ) {

long t1 = System . currentTimeMillis ();
for (int i=0; i < N; i++)
lst. remove (0);
long t2 = System . currentTimeMillis ();
System . out. println (" Remove : " + (t2 - t1));
}
public static void main ( String args []) {
System . out. println (" ArrayList ");
List lst1 = new ArrayList ();
testAdd ( lst1 );
testGet ( lst1 );
testRemove ( lst1 );
System . out. println (" LinkedList ");
List lst2 = new LinkedList ();
testAdd ( lst2 );
testGet ( lst2 );
testRemove ( lst2 );
}
}
ArrayList sau LinkedList ?

ArrayList LinkedList
add 0.12 0.14
get 0.01 87.45
remove 12.05 0.01

Concluzii:
exist diferene substaniale n reprezentarea
i comportamentul diferitelor implementri
alegerea unei anumite clase pentru
reprezentarea unei mulimi de elemente trebuie
s se fac n funcie de natura problemei ce
trebuie rezolvat.
Algoritmi polimorfici

Metode definite n clasa Collections:

cutare, sortare, etc.

Caracteristici comune:
sunt metode de clas (statice);
au un singur argument de tip colecie;
apelul lor general va fi de forma:
Collections.algoritm(colectie,[argumente]);
majoritatea opereaz pe liste dar i
pe colecii arbitrare.
Exemple de algoritmi

sort
shuffle
binarySearch
reverse
fill
copy
min
max
swap
enumeration
unmodifiableTipColectie
synchronizedTipColectie
Tipuri generice

Tipizarea elementelor unei colecii:

TipColectie < TipDeDate >
// Inainte de 1.5
ArrayList list = new ArrayList();
list.add(new Integer(123));
int val = ((Integer)list.get(0)).intValue();
// Dupa 1.5, folosind tipuri generice
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(123));
int val = list.get(0).intValue();
// Dupa 1.5, folosind si autoboxing
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(123);
int val = list.get(0);
Avantaje: simplitate, control (eroare la compilare
vs. ClassCastException)
Iteratori i enumerri

Parcurgerea secvenial a unei colecii, indiferent dac

este indexat sau nu.
Toate clasele care implementeaz colecii au metode ce
returneaz o enumerare sau un iterator pentru
parcurgerea elementelor lor.
Deoarece funcionalitatea interfeei Enumeration se
regsete n Iterator, aceasta din urm este preferat n
noile implementri ale coleciilor.

Enumeration:
// Parcurgerea elementelor unui vector v
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
// sau, varianta mai concisa
for(Enumeration e=v.elements(); e.hasMoreElements();){
System.out.println(e.nextElement());
}
Iterator, ListIterator

Iterator: hasNext, next, remove

// Parcurgerea elementelor unui vector si eliminarea
elementelor nule
for (Iterator it = v.iterator(); it.hasNext();) {
Object obj = it.next();
if (obj == null) it.remove();
}

ListIterator: hasNext, hasPrevious, next, previous,

remove, add, set
// Parcurgerea elementelor unui vector si inlocuirea
elementelor nule cu 0
for (ListIterator it = v.listIterator(); it.hasNext();) {
Object obj = it.next();
if (obj == null) it.set(new Integer(0));
}
Folosirea unui iterator

import java . util .*;

class TestIterator {
public static void main ( String args []) {
ArrayList a = new ArrayList ();
// Adaugam numerele de la 1 la 10
for (int i=1; i <=10; i++) a.add(new Integer (i));
// Amestecam elementele colectiei
Collections . shuffle (a);
System . out. println (" Vectorul amestecat : " + a);
// Parcurgem vectorul
for ( ListIterator it=a. listIterator (); it. hasNext (); ) {
Integer x = ( Integer ) it. next ();
// Daca elementul curent este par , il facem 0
if (x % 2 == 0) it. set( 0 );
}
System . out. print (" Rezultat : " + a);
}
}
Varianta simplificat (1.5)

Atenie!
Deoarece coleciile sunt construite peste tipul de date
Object, metodele de tip next sau prev ale iteratorilor
vor returna tipul Object, fiind responsabilitatea noastr
de a face conversie (cast) la alte tipuri de date, dac
este cazul.

ArrayList<Integer> list=new ArrayList<Integer>();

for (Iterator i = list.iterator(); i.hasNext();) {
Integer val=(Integer)i.next();
// Proceseaza val
...
}
sau:
ArrayList<Integer> list=new ArrayList<Integer>();
for (Integer val : list) {
// Proceseaza val
...
}
Exemple

Collection<String> c = new ArrayList<String>();

c.add("Test");
c.add(2); // EROARE!
Iterator<String> it = c.iterator();
while (it.hasNext()) {
String s = it.next();
}
O iterare obinuit pe un map se va face n
felul urmtor:
for (Map.Entry<String,Student> entry:
students.entrySet())
System.out.println("Media + entry.getKey()+este
+entry.getValue().getAverage());
bucla for-each iteratorul mulimii de perechi
ntoarse de entrySet.
Exemplu

1. S se defineasc o clas MyArray" pentru vectori

de obiecte care nu se extind dinamic i o clas
iterator pe acest vector care s implementeze
interfaa "Enumeration". Program pentru crearea
unui obiect MyArray" prin adugri succesive de
iruri i afiarea lui folosind un obiect iterator. Clasa
MyArray" are un constructor cu argument ntreg
(dimensiune vector) i metodele:
add(Object): adugare obiect la sfrit
elements(): creare iterator pentru acest vector
get(int): obiect dintr-o poziie data
size(): dimensiune vector
toString: ir cu elementele din vector.
Rezolvare

import java.util.*;

class MyArray {

private Object v[];

private int n;

public MyArray (int nmax) {

v= new Object[nmax];
n=0;
}

public void add (Object e) {

if ( n < v.length)
v[n++]=e;
}
Rezolvare

public Enumeration elements() {

return new ArrayEnum(this);
}

public String toString () {

String s="";
for (int i=0;i<n;i++)
s=s+v[i]+" ";
return s;
}

public int size() {

return n;
}

public Object get(int i) {

return v[i];
}
}
Rezolvare

// clasa iterator pentru vectori

class ArrayEnum implements Enumeration {
private int i;
private MyArray a;

ArrayEnum (MyArray a) {
this.a =a;
i=0;
}

public Object nextElement() {

return a.get(i++);
}

public boolean hasMoreElements() {

return i < a.size();
}
}
Rezolvare

class ArrayDemo {
// afisare prin enumerare
public static void main ( String av[]) {
MyArray a = new MyArray(10);
for (int i=1;i<11;i++)
a.add(""+i);
Enumeration it = a.elements();
while (it.hasMoreElements())
System.out.print (it.nextElement()+",");
System.out.println();
System.out.println(a);
}
}