import java.util.*;


// javac -source 1.5 Generics.java
// Will compile with warnings
// javac -source 1.5 -Xlint Generics.java
// Generics allows you to have type safe collections
// Generics is a compile time feature and not runtime so at runtime there is type erasure

public class Generics
{

  public static void generics()
  {
	LinkedList fooList = new LinkedList();
	fooList.add(new Integer(1));  // lint warning about unchecked add


	LinkedList<String> stringList = new LinkedList<String>();
	// LinkedList is called base type
	// String is called parameter type

	// primitive generics not allowed
	//LinkedList<int> intList = new LinkedList<int>();
	stringList.add("foo");
	// The line below will throw compilation error
	//stringList.add(new Integer(1));

	// Old Style iterator code will give compilation error for stringList
	for (Iterator<String> i = stringList.iterator(); i.hasNext();)
	{
	  String s = i.next();
	  System.out.println(s);
	}

	printStrings(stringList);
	oldStyle(stringList); // can still do old style

	// gives warning if compiled with -Xlint
	try
	{
	  for (Iterator<String> i = fooList.iterator(); i.hasNext();)
	  {
		String s = i.next(); // ClasscastException at runtime
		System.out.println(s);
	  }
	}
	catch (ClassCastException e) { e.printStackTrace(); }

	LinkedList<Integer> intList = new LinkedList<Integer>();
	intList.add(new Integer(1));
	intList.add(2); // autoboxing does automatic conversion to primitive types

	printAny(intList);

	List<Integer> intList2 = intList; // inhertiance rules are for base type and not parameter type
	// class Integer extends Number

	//Not Allowed for parameter type
	//List<Number> numberList = intList;
	// to prevent numberList.add(1.2)

	// can break type safety by casting and by reflection
	LinkedList numberList = intList;
	numberList.add(1.2); // allowed generated lint warning

	Map<String, List<String>> map = new HashMap<String, List<String>>();

	List objList1 = new LinkedList();
	objList1.add(1); // lint warning that collection is not type safe

	// for a collection which hold differnt objects so that you don't get lint warnings
	List<Object> objList2 = new LinkedList<Object>();

    MyList<Integer> myList = new MyList<Integer>();
    myList.add(101);
    System.out.println(myList.first());

    // Illegal
    //MyList2<String> f;

  }

  public static void printStrings(List<String> stringList)
  {
	for (Iterator<String> i = stringList.iterator(); i.hasNext();)
	{
	  String s = i.next();
	  System.out.println(s);
	}
  }


  // type wildcards
  // method that takes a List of any parameter type
  // can't do this as List<Object> as it won't take List<foo>
  // method is read only
  public static void printAny(List<?> anyList)
  {
	// The line below will not compile as Java does not the type of the collection at compile time
	//anyList.add(new Integer(1));
	for (Iterator<?> i = anyList.iterator(); i.hasNext();)
	{
	  System.out.println(i.next().toString());
	}
  }

  // restrict wildcards
  public static void printAnyNumber(List<? extends Number> anyList)
  {
	// The line below will not compile as Java does not the type of the collection at compile time
	//anyList.add(new Integer(1));
	for (Iterator<? extends Number> i = anyList.iterator(); i.hasNext();)
	{
	  System.out.println(i.next().toString());
	}
  }

  public static List<String> getStringList()
  {
	LinkedList<String> foo = new LinkedList<String>();
	foo.add("foo");
	return foo;
  }

  public static void oldStyle(List fooList) {}

  // should work but doesnt
  //public static int staticSize(MyList<T> list)
  //{
  //	return list.size();
  //}

  public static void main(String[] args)
  {
	generics();
  }
}

class MyList<T>
{
  public MyList() { list = new LinkedList<T>(); }
  public int size() { return list.size(); }
  public void add(T obj) { list.add(obj); }
  public T first() { return list.get(0); }



  private LinkedList<T> list;

  // not allowed with statics
  // private static LinkedList<T> list2;
}


// Restricting parameterized type to objects that are child of Number
class MyList2<T extends Number> extends MyList<T> {}