Admin: 1 версия

2010-06-01T05:20:56Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== A Generic Class with Two Type Parameters ==



<source lang="java">
class TwoGen<T, V> {
T ob1;
V ob2;
TwoGen(T o1, V o2) {
ob1 = o1;
ob2 = o2;
}
void showTypes() {
System.out.println("Type of T is " + ob1.getClass().getName());
System.out.println("Type of V is " + ob2.getClass().getName());
}
T getob1() {
return ob1;
}
V getob2() {
return ob2;
}
}
public class MainClass {
public static void main(String args[]) {
TwoGen<Integer, String> tgObj = new TwoGen<Integer, String>(88, "Generics");
tgObj.showTypes();
int v = tgObj.getob1();
System.out.println("value: " + v);
String str = tgObj.getob2();
System.out.println("value: " + str);
}
}</source>



<pre class=codeResult>Type of T is java.lang.Integer
Type of V is java.lang.String
value: 88
value: Generics</pre>

== A generic type can accept more than one type variables. ==



<source lang="java">
import java.util.HashMap;
import java.util.Map;
public class MainClass {
public static void main (String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put ("key1", "value1");
map.put ("key2", "value2");
String value1 = map.get("key1");
}
}</source>



== Generics Work Only with Objects ==



<source lang="java">
Gen<int> strOb = new Gen<int>(53); // Error, can"t use primitive type</source>



== Introducing Generic Types ==

<OL><LI>A generic type can accept parameters.</LI><LI>A generic type is often called a parameterized type.</LI><LI>You pass reference types in angle brackets to generic types.</LI></OL>



<source lang="java">
List<E> myList;</source>



E is called a type variable, namely a variable that will be replaced by a type.
<OL><LI>A generic type that uses a type variable E allows you to pass E when declaring or instantiating the generic type.</LI><LI>If E is a class, you may also pass a subclass of E</LI><LI>If E is an interface, you may also pass a class that implements E.</LI><LI>By convention, you use a single uppercase letter for type variable names.</LI></OL>

== Life without Generics ==

When retrieving a member from stringList1, you get an instance of java.lang.Object.
In order to work with the original type of the member element, you must first downcast it to String.



<source lang="java">
import java.util.ArrayList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
List stringList1 = new ArrayList ();
stringList1.add ("Java 5");
stringList1.add ("with generics");

String s1 = (String) stringList1.get (0);

}
}</source>



== Nested generic type ==

A generic type is itself a type and can be used as a type variable.
For example, if you want your List to store lists of strings:



<source lang="java">
List<List<String>> myListOfListsOfStrings;</source>



== Raw Types and Legacy Code ==

To handle the transition to generics, Java allows a generic class to be used without any
type arguments. This creates a raw type for the class.



<source lang="java">
// Demonstrate a raw type.
class Gen<T> {
T ob;

Gen(T o) {
ob = o;
}

T getob() {
return ob;
}
}

public class MainClass {
public static void main(String args[]) {
Gen<Integer> iOb = new Gen<Integer>(88);
Gen<String> strOb = new Gen<String>("Generics Test");

Gen raw = new Gen(new Double(98.6));
// Cast here is necessary because type is unknown.
double d = (Double) raw.getob();
System.out.println("value: " + d);
strOb = raw; // OK, but potentially wrong
String str = strOb.getob();

// This assignment also overrides type safety.
raw = iOb; // OK, but potentially wrong
d = (Double) raw.getob();

}
}</source>



<pre class=codeResult>Exception in thread "main" value: 98.6
java.lang.ClassCastException: java.lang.Double
at MainClass.main(MainClass.java:26)</pre>

== What Are Generics? A Simple Generics Example ==

The term generics means parameterized types.
(Java 2 V5.0 (Tiger) New Features by Herbert Schildt )
<OL><LI>T is a type parameter that will be replaced by a real type.</LI><LI>T is the name of a type parameter.</LI><LI>This name is used as a placeholder for the actual type
that will be passed to Gen when an object is created.</LI></OL>



<source lang="java">
class GenericClass<T> {
T ob;
GenericClass(T o) {
ob = o;
}
T getob() {
return ob;
}
void showType() {
System.out.println("Type of T is " + ob.getClass().getName());
}
}
public class MainClass {
public static void main(String args[]) {
// Create a Gen reference for Integers.
GenericClass<Integer> iOb = new GenericClass<Integer>(88);
iOb.showType();
// no cast is needed.
int v = iOb.getob();
System.out.println("value: " + v);
// Create a Gen object for Strings.
GenericClass<String> strOb = new GenericClass<String>("Generics Test");
strOb.showType();
String str = strOb.getob();
System.out.println("value: " + str);
}
}</source>



<pre class=codeResult>Type of T is java.lang.Integer
value: 88
Type of T is java.lang.String
value: Generics Test</pre>

== Working with generic List ==



<source lang="java">
import java.util.ArrayList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
List stringList1 = new ArrayList();
stringList1.add("Java 5");
stringList1.add("with generics");
String s1 = (String) stringList1.get(0);
System.out.println(s1.toUpperCase());

List<String> stringList2 = new ArrayList<String>();
stringList2.add("Java 5");
stringList2.add("with generics");

String s2 = stringList2.get(0);
System.out.println(s2.toUpperCase());
}
}</source>

← Предыдущая	Версия 05:20, 1 июня 2010
(нет различий)

Java Tutorial/Generics/Generics Basics - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010