Home  >  Article  >  Java  >  Sharing multiple java generic examples

Sharing multiple java generic examples

高洛峰
高洛峰Original
2017-01-18 11:00:051309browse

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!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn