• Java Generic methods and generic classes enable programmers to specify, with a single method declaration, a set of related methods or, with a single class declaration, a set of related types, respectively.
  Generics also provide compile-time type safety that allows programmers to catch invalid types at compile time.
  
  Using Java Generic concept we might write a generic method for sorting an array of objects, then invoke the generic method with Integer arrays, Double arrays, String arrays and so on, to sort the array elements.
  
  
  
  

  Generic Methods:

  You can write a single generic method declaration that can be called with arguments of different types. Based on the types of the arguments passed to the generic method, the compiler handles each method call appropriately. Following are the rules to define Generic Methods:
  All generic method declarations have a type parameter section delimited by angle brackets (< and >) that precedes the method's return type ( < E > in the next example). 

   
  Each type parameter section contains one or more type parameters separated by commas. A type parameter, also known as a type variable, is an identifier that specifies a generic type name.
  The type parameters can be used to declare the return type and act as placeholders for the types of the arguments passed to the generic method, which are known as actual type arguments.
  A generic method's body is declared like that of any other method. Note that type parameters can represent only reference types not primitive types (like int, double and char).
  
  
  

  Example:

  Following example illustrate how we can print array of different type using a single Generic method:
  

  public class GenericMethodTest { // generic method printArray public static < E > void printArray( E[] inputArray ) { // Display array elements for ( E element : inputArray ){ System.out.printf( "%s ", element ); } System.out.println(); } public static void main( String args[] ) { // Create arrays of Integer, Double and Character Integer[] intArray = { 1, 2, 3, 4, 5 }; Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 }; Character[] charArray = { 'H', 'E', 'L', 'L', 'O' }; System.out.println( "Array integerArray contains:" ); printArray( intArray ); // pass an Integer array System.out.println( "\nArray doubleArray contains:" ); printArray( doubleArray ); // pass a Double array System.out.println( "\nArray characterArray contains:" ); printArray( charArray ); // pass a Character array } }

  
  
  
  

  This would produce following result:

  Array integerArray contains: 1 2 3 4 5 6 Array doubleArray contains: 1.1 2.2 3.3 4.4 Array characterArray contains: H E L L O

• Strengths and Weaknesses of Generics

  If you want to take an element from the Collection, you have to cast the type of element that is stored in the collection.The compiler does not check that your cast is the same as the collection's type or not, which makes the cast fail at run time.To overcome this situation Generics provides a way to communicate the collection type to the compiler which aware the compiler about the element type of the collection, and can insert the correct casts on values being taken out of the collection.
  
  Generics provide a mechanism for annotating type information for the use of the compiler. By providing this information, the compiler can in turn verify the consistent use of "genericized" classes and automatically insert explicit casts, eliminating the need for programmers to do so manually.
  
  The Generics makes its information available only at compile time and not translated into the compiled bytes. This allows genericized classes to interoperate cleanly with legacy, or raw, types.
  
  It has the ability for library authors to express their intent more cleanly. Generics help to enforce the contents of collections and other genericized classes.
  Generics can be used in more than just collection classes which allows developers to write their own genericized classes and genericized methods with generics.

• Generic Wildcards

  The generic wildcard operator is a solution to the problem explained above. The generic wildcards target two primary needs:
  

  • Reading from a generic collection
  • Inserting into a generic collection

  There are three ways to define a collection (variable) using generic wildcards. These are:
  

  List<?>           listUknown = new ArrayList<A>();
  List<? extends A> listUknown = new ArrayList<A>();
  List<? super   A> listUknown = new ArrayList<A>();
  

  
  The following sections explain what these wildcards mean.
  
  

  The Unknown Wildcard

  List<?> means a list typed to an unknown type. This could be a List<A>, a List<B>, a List<String> etc.
  Since the you do not know what type the List is typed to, you can only read from the collection, and you can only treat the objects read as being Object instances. Here is an example:
  

  public void processElements(List<?> elements){
     for(Object o : elements){
        System.out.println(o);
     }
  }
  

  The processElements() method can now be called with any generic List as parameter. For instance a List<A>, a List<B>, List<C>, a List<String> etc. Here is a legal example:
  

  List<A> listA = new ArrayList<A>();
  
  processElements(listA);
  

  
  

  The extends Wildcard Boundary

  List<? extends A> means a List of objects that are instances of the class A, or subclasses of A (e.g. B and C).
  When you know that the instances in the collection are of instances of A or subclasses of A, it is safe to read the instances of the collection and cast them to A instances. Here is an example:
  

  public void processElements(List<? extends A> elements){
     for(A a : elements){
        System.out.println(a.getValue());
     }
  }
  

  You can now call the processElements() method with either a List<A>, List<B> or List<C>. Hence, all of these examples are valid:
  

  List<A> listA = new ArrayList<A>();
  processElements(listA);
  
  List<B> listB = new ArrayList<B>();
  processElements(listB);
  
  List<C> listC = new ArrayList<C>();
  processElements(listC);
  

  The processElements() method still cannot insert elements into the list, because you don't know if the list passed as parameter is typed to the class A, B or C.
  
  

  The super Wildcard Boundary

  List<? super A> means that the list is typed to either the A class, or a superclass of A.
  When you know that the list is typed to either A, or a superclass of A, it is safe to insert instances of A or subclasses of A (e.g. B or C) into the list. Here is an example:
  

  public static void insertElements(List<? super A> list){
      list.add(new A());
      list.add(new B());
      list.add(new C());
  }
  

  All of the elements inserted here are either A instances, or instances of A's superclass. Since both B and C extend A, if A had a superclass, B and C would also be instances of that superclass.
  You can now call insertElements() with either a List<A>, or a List typed to a superclass of A. Thus, this example is now valid:
  

  List<A>      listA      = new ArrayList<A>();
  insertElements(listA);
  
  List<Object> listObject = new ArrayList<Object>();
  insertElements(listObject);
  
  

  The insertElements() method cannot read from the list though, except if it casts the read objects to Object. The elements already present in the list when insertElements() is called could be of any type that is either an A or superclass of A, but it is not possible to know exactly which class it is. However, since any class eventually subclass Object you can read objects from the list if you cast them to Object. Thus, this is legal:

A Simple Thread Example

The simple example shown in full on the first page of this lesson defines two classes: SimpleThread and TwoThreadsTest. Let's begin our exploration of the application with the SimpleThread class--a subclass of the Thread class, which is provided by the java.lang package:

class SimpleThread extends Thread {
    public SimpleThread(String str) {
        super(str);
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i + " " + getName());
            try {
                sleep((int)(Math.random() * 1000));
            } catch (InterruptedException e) {}
        }
        System.out.println("DONE! " + getName());
    }
}

The first method in the SimpleThread class is a constructor that takes a String as its only argument. This constructor is implemented by calling a superclass constructor and is interesting to us only because it sets the Thread's name, which is used later in the program.
The next method in the SimpleThread class is the run() method. The run() method is the heart of any Thread and where the action of the Thread takes place. The run() method of the SimpleThread class contains a for loop that iterates ten times. In each iteration the method displays the iteration number and the name of the Thread, then sleeps for a random interval of up to 1 second. After the loop has finished, the run() method prints "DONE!" along with the name of the thread. That's it for the SimpleThread class.

Lists: always ordered, may contain duplicates and can be handled the same way as usual arrays.

Sets: cannot contain duplicates and provide random access to their elements.

Maps: connect unique keys with values, provide random access to its keys and may host duplicate values.

Maps are defined by the java.util.Map interface in Java. Maps are simple data structures that associate a key with a value. The element is the value. This lets the map be very flexible. If the key is the hash code of the element, the map is essentially a set. If it's just an increasing number, it becomes a list. Maps are implemented by java.util.HashMap, java.util.LinkedHashMap, and java.util.TreeMap. HashMap uses a hash table. The hashes of the keys are used to find the values in various buckets. LinkedHashMap extends this by creating a doubly linked list between the elements. This allows the elements to be accessed in the order in which they were inserted into the map. TreeMap, in contrast to HashMap and LinkedHashMap, uses a red-black tree. The keys are used as the values for the nodes in the tree, and the nodes point to the values in the map.

The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided. Using, once again, the compareTo() method or a method provided in the constructor to the sorted map, the key-value pairs are sorted by the keys. The first and last keys in the map can be called. Additionally, submaps can be created from minimum and maximum keys. SortedMap is implemented by java.util.TreeMap.

The java.util.NavigableMap interface extends java.util.SortedMap in various ways. Methods can be called that find the key or map entry that's closest to the given key in either direction. The map can also be reversed, and an iterator in reverse order can be generated from it. It's implemented by java.util.TreeMap.

Java defines a set of annotations that are built into the language.

Annotations applied to java code:

@Override - Checks that the function is an override. Causes a compile warning if the function is not found in one of the parent classes.

@Deprecated - Marks the function as obsolete. Causes a compile warning if the function is used.

@SuppressWarnings - Instructs the compiler to suppress the compile time warnings specified in the annotation parameters.

@Retention - Specifies how the marked annotation is stored—Whether in code only, compiled into the class, or available at runtime through reflection.

@Documented - Marks another annotation for inclusion in the documentation.

@Target - Marks another annotation to restrict what kind of java elements the annotation may be applied to

@Inherited - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited to subclasses).

public final void writeObject(Object x) throws IOException

public final Object readObject() throws IOException, 
                                 ClassNotFoundException

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public int transient SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

• The class must implement the java.io.Serializable interface.
• All of the fields in the class must be serializable. If a field is not serializable, it must be marked transient.

Serializing an Object:

import java.io.*;

public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("employee.ser");
         ObjectOutputStream out =
                            new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
          fileOut.close();
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}Deserializing an Object:

import java.io.*;
   public class DeserializeDemo
   {
      public static void main(String [] args)
      {
         Employee e = null;
         try
         {
            FileInputStream fileIn =
                          new FileInputStream("employee.ser");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            e = (Employee) in.readObject();
            in.close();
            fileIn.close();
        }catch(IOException i)
        {
            i.printStackTrace();
            return;
        }catch(ClassNotFoundException c)
        {
            System.out.println(.Employee class not found.);
            c.printStackTrace();
            return;
        }
        System.out.println("Deserialized Employee...");
        System.out.println("Name: " + e.name);
        System.out.println("Address: " + e.address);
        System.out.println("SSN: " + e.SSN);
        System.out.println("Number: " + e.number);
    }
}

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

• The try/catch block tries to catch a ClassNotFoundException, which is declared by the readObject() method. For a JVM to be able to deserialize an object, it must be able to find the bytecode for the class. If the JVM can't find a class during the deserialization of an object, it throws a ClassNotFoundException.
• Notice that the return value of readObject() is cast to an Employee reference.
• The value of the SSN field was 11122333 when the object was serialized, but because the field is transient, this value was not sent to the output stream. The SSN field of the deserialized Employee object is 0.

Program to an interface not an implementation

Favor object composition over inheritance

Design Patterns can be divided into:  
1. Creational Patterns
2. Structural Patterns
3. Behavioral Patterns