Partager plusieurs exemples génériques Java

1. Classe générique

1.1 Génériques ordinaires

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);
    }
}

Résultats de sortie :

java.lang.Integer
5
java.lang.Double
5.55
java.lang.String
hello world

1.2 Génériques K/V

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"));
    }
}

Résultat de sortie :

jianing
24

2. Interface générique

package test.lujianing;
/**
 * 泛型接口
 * @param <T>
 */
public interface TestImpl<T> {
    public void setValue(T t);
    public T getValue();
}

Résultat de sortie :

1
hello word

3. Méthode générique

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);
    }
}

Résultat de sortie :

java.lang.Integer
30
java.lang.Double
40.0022

4. Restreindre les génériques

Dans l'exemple ci-dessus, il n'y a aucune restriction sur la portée de la classe Test8742468051c85b06f0a0af9e3e506b5c équivalent à Objet. Par exemple, nous souhaitons limiter T à un type d’interface numérique. Faites simplement ceci : la classe Testb801d5a2dc63d0953bf2465650b8fadc. De cette façon, le T générique dans la classe ne peut être que la classe d'implémentation de l'interface Number. Si une interface non-Number est transmise, une erreur de compilation se produira.

5. Génériques génériques

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());
        }
    }
}

Résultats de sortie :

key：Double value：class java.lang.Double
key：Integer value：class java.lang.Integer

Exemple simple : exemple pour 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());
    }

Résultat de sortie :

java.lang.Integer
通配泛型5
java.lang.Double
通配泛型5.55

6. Supplément

Dans les génériques, vous pouvez rencontrer 8742468051c85b06f0a0af9e3e506b5c1a4db2c2c2313771e5742b6debf617a1 etc. T et E sont respectivement les en-têtes de la lettre Type et Élément. E est généralement utilisé pour représenter le type d'éléments dans un type de collection, comme la définition de l'interface List, l'interface publique List1a4db2c2c2313771e5742b6debf617a1 étend Collection1a4db2c2c2313771e5742b6debf617a1. Ceci est juste une convention de dénomination, il n'y a pas de différence essentielle entre les deux.

Pour plus d'exemples génériques Java et d'articles connexes, veuillez faire attention au site Web PHP chinois !