1. Generic class
1.1 Ordinary generic
package test.lujianing; /** * 泛型类 * @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; } } /** * 测试泛型类 */ public class TestOne { public static void main(String[] args) { //测试Integer泛型 Test<Integer> t1 = new Test<Integer>(); t1.setValue(5); Integer i = t1.getValue(); System.out.println(i); //测试Double泛型 Test<Double> t2 = new Test<Double>(); t2.setValue(5.55D); Double d = t2.getValue(); System.out.println(d); //测试String泛型 Test<String> t3 = new Test<String>(); t3.setValue("hello world"); String str =t3.getValue(); System.out.println(str); } }
Output result:
java.lang.Integer 5 java.lang.Double 5.55 java.lang.String hello world
1.2 K/V generic
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 :
jianing 24
2. Generic interface
package test.lujianing; /** * 泛型接口 * @param <T> */ public interface TestImpl<T> { public void setValue(T t); public T getValue(); }
Output result:
1 hello word
3. Generic method
package test.lujianing; /** * 泛型方法类 */ class TestMethod{ /** * 泛型方法 */ 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; } } /** * 泛型方法测试类 */ 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:
java.lang.Integer 30 java.lang.Double 40.0022
4. Restrict generics
In the above example, there is no restriction on the scope of class Test8742468051c85b06f0a0af9e3e506b5c type holder T, and the default limited type is equivalent to Object. For example, we want to limit T to a digital interface type. Just do this: class Test7bac7e57b1a28a76cdacdabd991c2663. In this way, the generic T in the class can only be the implementation class of the Number interface. If a non-Number interface is passed in, a compilation error will occur.
5. Wildcard generics
package test.lujianing; import java.util.HashMap; import java.util.Map; /** * 通配泛型 */ 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 results:
key:Double value:class java.lang.Double key:Integer value:class java.lang.Integer
Simple example: example for 1.1
public static void main(String[] args) { //测试Integer泛型 Test<Integer> t1 = new Test<Integer>(); t1.setValue(5); fun(t1); //测试Double泛型 Test<Double> t2 = new Test<Double>(); t2.setValue(5.55D); fun(t2); } public static void fun(Test<?> t){ System.out.println("通配泛型"+t.getValue()); }
Output results:
java.lang.Integer 通配泛型5 java.lang.Double 通配泛型5.55
6. Supplement
In generics, you may encounter 8742468051c85b06f0a0af9e3e506b5c1a4db2c2c2313771e5742b6debf617a1, etc. T and E are the first letters of Type and Element respectively. E is generally used to represent the type of elements in a collection type, such as the definition of the List interface, public interface List1a4db2c2c2313771e5742b6debf617a1 extends Collection1a4db2c2c2313771e5742b6debf617a1. This is just a naming convention, there is no essential difference between the two.
For more java generic examples and related articles, please pay attention to the PHP Chinese website!