FilesExpand file tree

 master

/

Fill2.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

89 lines (83 loc) · 2.36 KB

 master

/

Fill2.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

89 lines (83 loc) · 2.36 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

//: generics/Fill2.java

package generics; /* Added by Eclipse.py */

// Using adapters to simulate latent typing.

// {main: Fill2Test}

import generics.coffee.*;

import java.util.*;

import net.mindview.util.*;

import static net.mindview.util.Print.*;

interface Addable<T> { void add(T t); }

public class Fill2 {

// Classtoken version:

public static <T> void fill(Addable<T> addable,

Class<? extends T> classToken, int size) {

for(int i = 0; i < size; i++)

try {

addable.add(classToken.newInstance());

} catch(Exception e) {

throw new RuntimeException(e);

}

}

// Generator version:

public static <T> void fill(Addable<T> addable,

Generator<T> generator, int size) {

for(int i = 0; i < size; i++)

addable.add(generator.next());

}

}

// To adapt a base type, you must use composition.

// Make any Collection Addable using composition:

class AddableCollectionAdapter<T> implements Addable<T> {

private Collection<T> c;

public AddableCollectionAdapter(Collection<T> c) {

this.c = c;

}

public void add(T item) { c.add(item); }

}

// A Helper to capture the type automatically:

class Adapter {

public static <T>

Addable<T> collectionAdapter(Collection<T> c) {

return new AddableCollectionAdapter<T>(c);

}

}

// To adapt a specific type, you can use inheritance.

// Make a SimpleQueue Addable using inheritance:

class AddableSimpleQueue<T>

extends SimpleQueue<T> implements Addable<T> {

public void add(T item) { super.add(item); }

}

class Fill2Test {

public static void main(String[] args) {

// Adapt a Collection:

List<Coffee> carrier = new ArrayList<Coffee>();

Fill2.fill(

new AddableCollectionAdapter<Coffee>(carrier),

Coffee.class, 3);

// Helper method captures the type:

Fill2.fill(Adapter.collectionAdapter(carrier),

Latte.class, 2);

for(Coffee c: carrier)

print(c);

print("----------------------");

// Use an adapted class:

AddableSimpleQueue<Coffee> coffeeQueue =

new AddableSimpleQueue<Coffee>();

Fill2.fill(coffeeQueue, Mocha.class, 4);

Fill2.fill(coffeeQueue, Latte.class, 1);

for(Coffee c: coffeeQueue)

print(c);

}

} /* Output:

Coffee 0

Coffee 1

Coffee 2

Latte 3

Latte 4

----------------------

Mocha 5

Mocha 6

Mocha 7

Mocha 8

Latte 9

*///:~