1. Generic Classes
1.1 Normal generics
The code copy is as follows:
package test.lujianing;
/**
* Generic class
* @param <T>
*/
class Test<T>{
private T obj;
public void setValue(T obj){
this.obj =obj;
}
public T getValue(){
System.out.println(obj.getClass().getName());
return obj;
}
}
/**
* Test generic classes
*/
public class TestOne {
public static void main(String[] args) {
//Test the Integer generic
Test<Integer> t1 = new Test<Integer>();
t1.setValue(5);
Integer i = t1.getValue();
System.out.println(i);
//Test the Double generic
Test<Double> t2 = new Test<Double>();
t2.setValue(5.55D);
Double d = t2.getValue();
System.out.println(d);
//Test String generic
Test<String> t3 = new Test<String>();
t3.setValue("hello world");
String str =t3.getValue();
System.out.println(str);
}
}
Output result:
The code copy is as follows:
java.lang.Integer
5
java.lang.Double
5.55
java.lang.String
hello world
1.2 K/V generics
The code copy is as follows:
package test.lujianing;
import java.util.HashMap;
import java.util.Map;
/**
* Created by Administrator on 14-3-30.
*/
class TestKV<K,V>{
private Map<K,V> map=new HashMap<K,V>();
public void put(K k, V v) {
map.put(k,v);
}
public V get(K k) {
return map.get(k);
}
}
public class TestFour{
public static void main(String[] args) {
TestKV<String,String> t = new TestKV<String, String>();
t.put("name","jianing");
System.out.println(t.get("name"));
TestKV<String,Integer> t2 = new TestKV<String, Integer>();
t2.put("age",24);
System.out.println(t2.get("age"));
}
}
Output result:
The code copy is as follows:
jianing
twenty four
2. Generic interface
The code copy is as follows:
package test.lujianing;
/**
* Generic interface
* @param <T>
*/
public interface TestImpl<T> {
public void setValue(T t);
public T getValue();
}
Output result:
The code copy is as follows:
1
hello word
3. Generic methods
The code copy is as follows:
package test.lujianing;
/**
* Generic method class
*/
class TestMethod{
/**
* Generic methods
*/
public <T>T getValue(Object s,Class<T> clazz) {
System.out.println(clazz.getName());
T t = null;
if(clazz.getName().equals("java.lang.Integer")){
Double d = Double.parseDouble(s.toString());
int i =d.intValue();
t=(T)new Integer(i);
}
if(clazz.getName().equals("java.lang.Double")){
t=(T)new Double(s.toString());
}
return t;
}
}
/**
* Generic method test class
*/
public class TestThree {
public static void main(String[] args) {
TestMethod t = new TestMethod();
int i =t.getValue("30.0011",Integer.class);
System.out.println(i);
double d =t.getValue("40.0022",Double.class);
System.out.println(d);
}
}
Output result:
The code copy is as follows:
java.lang.Integer
30
java.lang.Double
40.0022
4. Restrict generics
In the above example, there is no limit on the range of class Test<T> type holder T, and the default restriction type is equivalent to Object. For example, we need to limit T to the digital interface type. Just do this: class Test<T extends Number>. The generic T in such a class can only be the implementation class of the Number interface. There will be an error in compiling the non-Number interface when passing in.
5. Wild generics
The code copy is as follows:
package test.lujianing;
import java.util.HashMap;
import java.util.Map;
/**
* Wild generics
*/
public class TestFive {
public static void main(String[] args) {
Map<String,Class<? extends Number>> map = new HashMap<String,Class<? extends Number>>();
map.put("Integer",Integer.class);
map.put("Double",Double.class);
for (Map.Entry<String,Class<? extends Number>> entry : map.entrySet()) {
System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());
}
}
}
Output result:
The code copy is as follows:
key: Double value: class java.lang.Double
key: Integer value: class java.lang.Integer
Simple example: Example for 1.1
The code copy is as follows:
public static void main(String[] args) {
//Test the Integer generic
Test<Integer> t1 = new Test<Integer>();
t1.setValue(5);
fun(t1);
//Test the Double generic
Test<Double> t2 = new Test<Double>();
t2.setValue(5.55D);
fun(t2);
}
public static void fun(Test<?> t){
System.out.println("wild generic" + t.getValue());
}
Output result:
The code copy is as follows:
java.lang.Integer
Wild Generics 5
java.lang.Double
Wild generics 5.55
6. Supplement
In generics, you may encounter <T><E>, etc., T and E are the initials of Type and Element, respectively. E is generally used to represent the type of elements in the collection type, such as the definition of the List interface, public interface List<E> extends Collection<E>. This is just a naming habit, and there is no essential difference between the two.