what is generics in jdk1.5? | |
|Answer |Hi, | |
|# 1 | | |
| |Generics is Template support added in JDK1.5 where in we can maintain templates of object with particular type and | |
| |also this object is restricted to accept type other than specified one at code time. | |
| |This help reducing runtime exception and also we can create predefined well formed templates of Type. | |
| | | |
| |Best Example. | |
| | | |
| |http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html#generics | |
| | | |
| |Code written to use the generics feature should not be a lot slower or a lot more memory-intensive than non-generic | |
| |code. Using ten percent more space or time than .... | |

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; public class Ex01 { public static void main(String[] args) throws IOException { BufferedReader userInput = new BufferedReader (new InputStreamReader(System.in)); ArrayList myArr = new ArrayList(); myArr.add("Italian Riviera"); myArr.add("Jersey Shore"); myArr.add("Puerto Rico"); myArr.add("Los Cabos Corridor"); myArr.add("Lubmin"); myArr.add("Coney Island"); myArr.add("Karlovy Vary"); myArr.add("Bourbon-l'Archambault"); myArr.add("Walt Disney World Resort"); myArr.add("Barbados"); System.out.println("Stupid Vacation Resort Adviser"); System.out.println("Enter your name:"); String name = userInput.readLine(); Integer nameLength = name.length(); if (nameLength == 0) { System.out.println("empty name entered"); return; } Integer vacationIndex = nameLength % myArr.size(); System.out.println("\nYour name is "+name+", its length is " + nameLength + " characters,\n" + "that's why we suggest you to go to " + myArr.get(vacationIndex)); }

Vectors (the java.util.Vector class)are commonly used instead of arrays, because they expandautomatically when new data is added to them. The Java 2 Collections API introduced the similar ArrayList data structure.ArrayLists are unsynchronized and thereforefaster than Vectors, but less secure in a multithreaded environment.The Vector class was changedin Java 2 to add the additional methods supported by ArrayList. See below for a reasons to use each. The description below is for the (new) Vector class.

Vectors can hold only Objects and not primitive types (eg, int).If you want to put a primitive type in a Vector, put it inside an object (eg, to save an integer value use the Integer classor define your own class). If you use the Integer wrapper,you will not be able to change the integer value, so it is sometimes usefulto define your own class.

To Create a Vector

You must import either import java.util.Vector;or import java.util.*;.Vectors are implemented with an array, and when that array is full and an additional elementis added, a new array must be allocated. Becauseit takes time to create a bigger array and copy theelements from the old array to the new array, it is a little fasterto create a Vector with a size that it will commonly be when full. Of course, if you knew thefinal size, you could simply use an array. However, for non-critical sections of codeprogrammers typically don't specify an initial size.

• Create a Vector with default initial size Vector v = new Vector();

• Create a Vector with an initial size Vector v = new Vector(300);

To Add elements to the end of a Vector

v.add(s); // adds s to the end of the Vector v

To get the elements from a Vector (ListIterator)

You can use a for loop to get all the elements from a Vector,but another very common way to go over all elements in a Vector is touse a ListIterator. The advantage of an iterator is that it it can be usedwith other data structures, so that if you later change to using a linkedlist for example, you won't have to change your code. Here is an exampleof using an iterator to print all elements (Strings) in a vector.The two most useful methods are hasNext(),which returns true if there are more elements, andnext(), which returns the next element.

ListIterator iter = v.listIterator();

while (iter.hasNext()) {

System.out.println((String)iter.next());

}

Common Vector Methods

There are many useful methods in the Vector class and its parent classes.Here are some of the most useful.v is a Vector,i is an int index,o is an Object.

|Method |Description |
|v.add(o) |adds Object o to Vector v |
|v.add(i, o) |Inserts Object o at index i, shifting elements up as necessary. |
|v.clear() |removes all elements from Vector v |
|v.contains(o) |Returns true if Vector v contains Object o |
|v.firstElement(i) |Returns the first element. |
|v.get(i) |Returns the object at int index i. |
|v.lastElement(i) |Returns the last element. |
|v.listIterator() |Returns a ListIterator that can be used to go over the Vector. This is a useful alternative to|
| |the for loop. |
|v.remove(i) |Removes the element at position i, and shifts all following elements down. |
|v.set(i,o) |Sets the element at index i to o. |
|v.size() |Returns the number of elements in Vector v. |
|v.toArray(Object[]) |The array parameter can be any Object subclass (eg, String). This returns the vector values in|
| |that array (or a larger array if necessary). This is useful when you need the generality of a |
| |Vector for input, but need the speed of arrays when processing the data. |

Old and New Vector Methods

When the new Collections API was introduced in Java 2 toprovide uniform data structure classes, the Vector classwas updated to implement the List interface. Use the List methods because they arecommon to other data structure. If you later decideto use something other than a Vector (eg, ArrayList, or LinkedList, your other codewill not need to change.

Even up thru the first several versions of Java 2 (SDK 1.4), thelanguage had not entirely changed to use the new Collections methods. For example, theDefaultListModel still uses the old methods, so if you are usinga JList, you will need to use the old method names. There are hints that they plan to change this, but still and interesting omission.

Replacements for old methods

The following methods have been changed from the old to the new Vector API.

|Old Method |New Method |
|void addElement(Object) |boolean add(Object) |
|void copyInto(Object[]) |Object[] toArray() |
|Object elementAt(int) |Object get(int) |
|Enumeration elements() |Iterator iterator() |
| |ListIterator listIterator() |
|void insertElementAt(Object, int) |void add(index, Object) |
|void removeAllElements() |void clear() |
|boolean removeElement(Object) |boolean remove(Object) |
|void removeElementAt(int) |void remove(int) |
|void setElementAt(int) |Object set(int, Object) |

Insuring use of the new API

When you create a Vector, you can assign it to a List (a Collections interface). This will guarantee that only the List methods are called.

Vector v1 = new Vector(); // allows old or new methods.

List v2 = new Vector(); // allows only the new (List) methods.

The Model 2 architecture for designing JSP pages is in reality, Model View Controller (MVC) applied to web applications. Hence the two terms can be used interchangeably in the web world. MVC originated in SmallTalk and has since made its way into Java community. Model 2 architecure and its derivatives are the cornerstones for all serious and industrial strength web applications designed in the real world. Hence it is essential for you understand this paradigm thoroughly. Figure 1.2 shows the Model 2 (MVC) architecture.

The main difference between Model 1 and Model 2 is that in Model 2, a controller handles the user request instead of another JSP. The controller is implemented as a Servlet. The following steps are executed when the user submits the request.

1. The Controller Servlet handles the user’s request. (This means the hyperlink in the JSP should point to the controller servlet). 2. The Controller Servlet then instantiates appropriate JavaBeans based on the request parameters (and optionally also based on session attributes). 3. The Controller Servlet then by itself or through a controller helper communicates with the middle tier or directly to the database to fetch the required data. 4. The Controller sets the resultant JavaBeans (either same or a new one) in one of the following contexts – request, session or application. 5. The controller then dispatches the request to the next view based on the request URL. 6. The View uses the resultant JavaBeans from Step 4 to display data. Note that there is no presentation logic in the JSP. The sole function of the JSP in Model 2 architecture is to display the data from the JavaBeans set in the request, session or application scopes.

[pic]

Model 2 Architecture.

Advantages of Model 2 Architecture

Since there is no presentation logic in JSP, there are no scriptlets. This means lesser nightmares. [Note that although Model 2 is directed towards elimination of scriptlets, it does not architecturally prevent you from adding scriptlets. This has led to widespread misuse of Model 2 architecture.]

With MVC you can have as many controller servlets in your web application. In fact you can have one Controller Servlet per module. However there are several advantages of having a single controller servlet for the entire web application. In a typical web application, there are several tasks that you want to do for every incoming request. For instance, you have to check if the user requesting an operation is authorized to do so. You also want to log the user’s entry and exit from the web application for every request. You might like to centralize the logic for dispatching requests to other views. The list goes on. If you have several controller servlets, chances are that you have to duplicate the logic for all the above tasks in all those places. A single controller servlet for the web application lets you centralize all the tasks in a single place. Elegant code and easier to maintain.

Web applications based on Model 2 architecture are easier to maintain and extend since the views do not refer to each other and there is no presentation logic in the views. It also allows you to clearly define the roles and responsibilities in large projects thus allowing better coordination among team members.