Der Inhalt dieses Artikels befasst sich mit der Frage, was Generika in Java sind. Die ausführliche Einführung in Java-Generika hat einen gewissen Referenzwert. Ich hoffe, dass sie für Sie hilfreich ist.
1. Was sind Generika?
Generische Java-Designprinzipien: Solange während der Kompilierung keine Warnungen auftreten, gibt es zur Laufzeit keine ClassCastException-Ausnahme
Generika: Arbeiten Sie mit klaren Typen. Verzögern Sie die expliziter Spezialtyp bis zum Zeitpunkt der Erstellung des Objekts oder des Aufrufs der Methode
Parameterisierter Typ:
Das E in ArrayList
Integer in ArrayList
Der gesamte generische Typ ArrayList
Mit Generika:
Der Code ist prägnanter [keine erzwungene Konvertierung]
Das Programm ist robuster [Solange es beim Kompilieren keine Warnungen gibt, gibt es zur Laufzeit keine ClassCastException-Ausnahme]
Lesbarkeit und Stabilität [Beim Schreiben einer Sammlung ist der Typ limitiert]
Beim Erstellen der Sammlung geben wir den Typ der Sammlung an, damit wir die Sammlung mit „Enhanced for“ durchqueren können!
//创建集合对象
ArrayList<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
//遍历,由于明确了类型.我们可以增强for
for (String s : list) {
System.out.println(s);
}/*
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);}
Generische Methoden definieren.... Generische Methoden werden zuerst definiert und dann
//定义泛型方法..
public <T> void show(T t) {
System.out.println(t);
}public static void main(String[] args) {
//创建对象
ObjectTool tool = new ObjectTool();
//调用方法,传入的参数是什么类型,返回值就是什么类型
tool.show("hello");
tool.show(12);
tool.show(12.5);
}/*
把泛型定义在接口上
*/
public interface Inter<T> {
public abstract void show(T t);
}/**
* 子类明确泛型类的类型参数变量:
*/
public class InterImpl implements Inter<String> {
@Override
public void show(String s) {
System.out.println(s);
}
}Wenn wir Webseiten schreiben, müssen wir jedes Mal mehrere DAOs schreiben, was etwas mühsam sein kann.
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);
}
}Erbt abstraktes DAO und die Implementierungsklasse verfügt über entsprechende Methoden zum Hinzufügen, Löschen, Ändern und Überprüfen.
public class CategoryDao extends BaseDao<Category> {
}
BookDao
public class BookDao extends BaseDao<Book> {
}Das obige ist der detaillierte Inhalt vonWas sind Generika in Java? Detaillierte Einführung in Java-Generika. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
