public class ArrayList<E>

• Compiler errors are easier to track down (error messages reported by compiler with line numbers) than errors at run-time.
• Also, casting is not needed, as the compiler keeps track of the type of data stored in the generic class.

Defining Generic Classes and Interfaces

• Consider another example of a class called Twin, that stores some data, and has some accessor and mutator methods.
• Prior to the introduction of generics, we might have defined this class to store data of type Object.
  

public class Twin {
    private Object twin1;
    private Object twin2

    public void setTwin1(Object object) { 
        twin1 = object; 
    }

    public void setTwin2(Object object) { 
        twin2 = object; 
    }

    public Object getTwin1() { 
        return twin1; 
    }
    
    public Object getTwin12() { 
        return twin2; 
    } 
}

• Since its methods accept or return an Object, you are free to pass in whatever you want, provided that it is not one of the primitive types.

public class TwinTest {
    public static void main(String args[]) {
        Twin twins = new Twin();
        twins.setTwin1("Mo");
        twins.setTwin2(555);
       

        String s1 = (String) twins.getTwin1(); //method returns type Object, so must cast

        String s2 = (String) twins.getTwin2(); //Mistake!
        System.out.println("Twin 1: " + s1 + "\nTwin2: " + s2);
    }
}

• There is no way to verify, at compile time, how the class is used.
  
• One part of the code may place an Integer in the Twin and expect to get String out of it, while another part of the code may mistakenly pass in a String, and expect an Integer to be returned.
• The above code produces a run-time error:

A Generic Version of the Twin Class

• A generic class is defined with the following format:

  public class name<T1, T2, ..., Tn> {
  

• The type parameter section, delimited by angle brackets (<>), follows the class name.
  
• It specifies the type parameters (also called type variables) T1, T2, ..., and Tn.
• To update the Twin class to use generics, you create a generic type declaration by changing the code public class Twin to public class Twin<T>.
  
• The above statement declares the type variable, T, that can be used anywhere inside the class.
• With this change, the Twin class becomes:

public class Twin<T> {
    private T twin1;
    private T twin2;
	
    public void setTwin1(T t) {
        twin1 = t;
    }
	
    public void setTwin2(T t) {
	twin2 = t;
    }
	
    public T getTwin1() {
	return twin1;
    }
	
    public T getTwin2() {
	return twin2;
    }

}

• The T stands in place of the type that will later be declared when an instance of the class is created.
• Then, our test class would be updated as follows 

public class TwinTest {
    public static void main(String args[]) {
        Twin<String> twins = new Twin<String>();
        twins.setTwin1("Mo");
        //twins.setTwin2(555); //will not compile

        twins.setTwin2("Bo");

       
        String s = twins.getTwin2(); //no cast needed
        System.out.println(s);
    }
}

Multiple Type Parameters - Updated Twin.java Class

• It is also possible to store data of more than one generic type inside of the same class.
• For example, below is a revision of the Twin class, where each twin stores a different type of data
  

• In some cases, there is no purpose in making an entire class generic, if only a generic method is required.
• To create a generic method, you place the <T> (or whatever letter has been selected) before the return type of the method.
  
• Then, you are free to use this type throughout the method to stand in for any data type:

Raw Types

• Create a new generic class, as follows:
• The name of the class is GiftBag
• It stores two private member variables:
• One is of generic type and is named gift
• The other is of type boolean and is named open
• It has two constructors:
• A default constructor, which sets gift to be null, and open to be false
• A one argument constructor, which takes in a value for gift (and assigns this value to gift) and assigns open to be false
• An accessor method called getGift, which returns the current value of gift
• An accessor method called isOpen, which returns the current value of open
• A mutator method called openGift that sets the value of open to be true
• A toString() method which returns the value returned by calling the toString() of gift
• Additionally, in the same project folder as GiftBag.java, open up a new class called Phone.java (from one of our class examples).
  
• Copy and paste the below code into that class file:

• Next, locate Candy.java from a prior activity and copy and paste the contents into a new file named Candy.java in your new project folder, or use the one provided below
  

• Next, copy and paste the child class MilkyWay.java into a new file in your project folder. Locate the one from your prior activity or use the code provided below:

• Run the code to make sure your GiftBag.java class is working properly.
• You should get the below output:

• Next, it is your job to add one more GiftBag into the gifts ArrayList.
• Note that the type of gift in the GiftBag must be of a different data type than the other 3 gifts (no Phones, MilkyWays or Strings)
• When you have successfully added your gift, and gotten the correct output, upload GiftBag.java and Birthday.java, as well as any additional new class used in Birthday.java, to Canvas.

Wrap Up: