Que sont les génériques en Java ? Introduction détaillée aux génériques Java

Le contenu de cet article porte sur que sont les génériques en Java ? L'introduction détaillée des génériques Java a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer, j'espère qu'elle vous sera utile.

1. Que sont les génériques ?
Principes de conception générique Java : tant qu'il n'y a pas d'avertissements lors de la compilation, il n'y aura pas d'exception ClassCastException pendant l'exécution

Génériques : travaillez avec des types clairs Retardez le. type spécial explicite jusqu'au moment de la création de l'objet ou de l'appel de la méthode

Type paramétré :

Le E dans ArrayList >L'entier dans ArrayList est appelé le paramètre de type réel

L'intégralité de ArrayList le type générique

L'intégralité de ArrayList est appelée le type paramétré ParameterizedType

2. Pourquoi les génériques sont-ils nécessaires ?

Avec les génériques :

Le code est plus concis [pas de conversion forcée]
Le programme est plus robuste [Tant qu'il n'y a pas d'avertissements lors de la compilation, il n'y aura pas d'exception ClassCastException pendant l'exécution]
Lisibilité et stabilité [Lors de l'écriture d'une collection, le le type est limité]
Lors de la création de la collection, nous spécifions le type de la collection, nous pouvons donc utiliser amélioré pour parcourir la collection !

3. Bases des génériques

//创建集合对象
ArrayList<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");

//遍历,由于明确了类型.我们可以增强for
for (String s : list) {
    System.out.println(s);
}

Une classe générique consiste à définir un type générique sur la classe Lorsque l'utilisateur utilise la classe, le type est clarifié... Dans ce cas, à quoi sert. l'utilisateur précise-t-il ? Type, cette classe représente quel type... Les utilisateurs n'ont pas à s'inquiéter de la conversion forcée ou des exceptions de conversion d'exécution lorsqu'ils l'utilisent.

Les génériques définis sur une classe peuvent également être utilisés dans les méthodes de classe !

Quel type l'utilisateur souhaite utiliser, spécifiez simplement le type lors de la création. Lorsqu'elle est utilisée, la classe sera automatiquement convertie dans le type que l'utilisateur souhaite utiliser.

/*
    1:把泛型定义在类上
    2:类型变量定义在类上,方法中也可以使用
 */
    public class ObjectTool<T> {
        private T obj;
    
        public T getObj() {
            return obj;
        }
    
        public void setObj(T obj) {
            this.obj = obj;
        }
    }

public static void main(String[] args) {

}

//创建对象并指定元素类型
ObjectTool<String> tool = new ObjectTool<>();

tool.setObj(new String("钟福成"));
String s = tool.getObj();
System.out.println(s);


//创建对象并指定元素类型
ObjectTool<Integer> objectTool = new ObjectTool<>();
/**
 * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
 */
objectTool.setObj(10);
int i = objectTool.getObj();
System.out.println(i);

Définir les méthodes génériques.... Les génériques sont d'abord définis puis utilisés

Le type transmis par l'utilisateur sera le type de valeur de retour

//定义泛型方法..
public <T> void show(T t) {
    System.out.println(t);
}

La sous-classe définit clairement la variable de paramètre de type de la classe générique

public static void main(String[] args) {
    //创建对象
    ObjectTool tool = new ObjectTool();

    //调用方法,传入的参数是什么类型,返回值就是什么类型
    tool.show("hello");
    tool.show(12);
    tool.show(12.5);

}

Implémentation de classes d'interface de type génériques...

/*
    把泛型定义在接口上
 */
public interface Inter<T> {
    public abstract void show(T t);
}

4. Applications génériques

/**
 * 子类明确泛型类的类型参数变量:
 */

public class InterImpl implements Inter<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

Lorsque nous écrivons des pages Web, il y a souvent plusieurs DAO Nous devons écrire plusieurs DAO à chaque fois. un peu gênant.

Hérite du DAO abstrait et la classe d'implémentation a des méthodes correspondantes d'ajout, de suppression, de modification et de vérification.

public abstract class BaseDao<T> {

    //模拟hibernate....
    private Session session;
    private Class clazz;


    //哪个子类调的这个方法，得到的class就是子类处理的类型（非常重要）
    public BaseDao(){
        Class clazz = this.getClass();  //拿到的是子类
        ParameterizedType  pt = (ParameterizedType) clazz.getGenericSuperclass();  //BaseDao<Category>
        clazz = (Class) pt.getActualTypeArguments()[0];
        System.out.println(clazz);

    }


    public void add(T t){
        session.save(t);
    }

    public T find(String id){
        return (T) session.get(clazz, id);
    }

    public void update(T t){
        session.update(t);
    }

    public void delete(String id){
        T t = (T) session.get(clazz, id);
        session.delete(t);
    }

}

public class CategoryDao extends BaseDao<Category> {

}
BookDao

public class BookDao extends BaseDao<Book> {

}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!