class Person<T>{//使用T类型定义变量 private T info;//使用T类型定义一般方法 public T getInfo(){ return info; } public void setInfo(T info){ this.info = info; } //使用T类型定义构造器 public Person(){} public Person(T info){ this.info = info; } //static的方法中不能声明泛型 //public static void show(T t){ //} //不能在try-catch中使用泛型定义 //try{} //catch(T t){} }
public class DAO { public <E> E get(int id, E e){ E result = null; return result; } }
此信息属性的类型就可以通过泛型进行声明,然后只要设计相应的信息类即可。
package com.atguigu.javae.generic; import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Set; import java.util.Vector; import org.junit.Test; /** * 自定义泛型类, 类名<X> * 泛型和对象相关, 类型的信息最终会在创建对象时确定! */ class Person<X> { // X代表某类型, 既然是类型,声明变量,作为返回值... // 当在创建对象时未指定X的具体类型, 它的类型就是Object //private static int X x; private X info; public Person() { } public Person(X info) { this.info = info; } public void setInfo(X info) { try { this.info = info; //} catch (X e) { // catch 中只能捕捉Throwable及其子类 ,不可以使用类型不一定的X类型 } catch (Throwable e) { // catch 中只能捕捉Throwable及其子类 e.printStackTrace(); } } public X getInfo() { return info; } @Override public String toString() { return "某人, 信息[" + info + "]"; } /* public static void test(X t) { // 静态环境中不允许使用和对象相关的泛型 System.out.println(t); }*/ // 泛型方法, 在返回值前面加<类型>, 一定要在形参中带上类型信息 public static <Y> Y testY(Y y) { // 如果泛型方法中的泛型类型名和类中的一样, 则会屏蔽类中的泛型 return null; } } class Student extends Person<String> { // 在Student子类中,info属性就是固定的String类型 } public class GenericTest { // 写一个方法参数是(Collection<? extends Comparable> coll) // 在方法中返回这个集合中的最小值 // 写一个测试方法, 创建List集合,保存一些字符串, 再创建Set集合, 保存一些char, 分别使用这两个集合调用以上方法,打印输出结果 @SuppressWarnings({ "rawtypes", "unchecked" }) public Comparable getMin(Collection<? extends Comparable> coll) { if (coll.size() == 0) { return null; } Iterator<? extends Comparable> iterator = coll.iterator(); Comparable min = iterator.next(); while (iterator.hasNext()) { Comparable comp = iterator.next(); if (comp.compareTo(min) < 0) { min = comp; } } return min; } @Test public void test7() { List<String> list = new LinkedList<String>(); list.add("xxx"); list.add("bbb"); list.add("aaa"); list.add("ddd"); System.out.println(getMin(list)); Collection<Character> set = new HashSet<Character>(); set.add('我'); set.add('好'); set.add('a'); set.add(' '); System.out.println(getMin(set)); } public double sumList(List<? extends Number> list) { // list就可以指向以Number及其子类为泛型的集合, 但是引用不能添加元素, 但是可以获取元素,并且Number Iterator<? extends Number> iterator = list.iterator(); double sum = 0; while (iterator.hasNext()) { Number number = iterator.next(); sum += number.doubleValue(); } return sum; } public double getMax(Collection<? extends Number> coll) { Iterator<? extends Number> iterator = coll.iterator(); if (!iterator.hasNext()) { throw new RuntimeException("集合为空,没法找最大值"); } Number maxNumber = iterator.next(); while (iterator.hasNext()) { Number tmpNumber = iterator.next(); if (tmpNumber.doubleValue() > maxNumber.doubleValue()) { maxNumber = tmpNumber; } } return maxNumber.doubleValue(); } // 写一个方法参数是(Collection<? extends Number> coll) // 在方法中返回这个集合中的最大值 // 写一个测试方法, 创建List集合,保存一些整数, 再创建Set集合, 保存一些float, 分别使用这两个集合调用以上方法,打印输出结果 @Test public void test6() { ArrayList<Integer> list1 = new ArrayList<Integer>(); list1.add(100); list1.add(20); list1.add(30); list1.add(1000); list1.add(7); System.out.println(getMax(list1)); Set<Float> set = new HashSet<Float>(); set.add(234.23f); set.add(1234.23f); set.add(3234.23f); set.add(2334.23f); set.add(234.23f); System.out.println(getMax(set)); } @Test public void test5() { ArrayList<Integer> list1 = new ArrayList<Integer>(); list1.add(100); list1.add(20); list1.add(30); list1.add(10); list1.add(7); List<Double> list2 = new Vector<Double>(); list2.add(3.1); list2.add(2.1); list2.add(4.1); list2.add(5.1); list2.add(1.1); double sum = sumList(list1); System.out.println(sum); sum = sumList(list2); System.out.println(sum); /* List<? extends Number> list2 = list; // list2就可以指向以Number及其子类为泛型的集合, 但是引用不能添加元素, 但是可以获取元素,并且Number Iterator<? extends Number> iterator = list2.iterator(); while (iterator.hasNext()) { Number number = iterator.next(); sum += number.intValue(); } System.out.println(sum); list2 = list3; */ } @Test public void test4() { ArrayList<Integer> list = new ArrayList<Integer>(); list.add(100); list.add(20); list.add(30); list.add(10); list.add(7); List<?> list2 = list;// 只读访问 Object object = list2.get(1); System.out.println(object); } @SuppressWarnings("unused") @Test public void test3() { // 使用?通配符 通常用于只读访问 Person<?> person = new Person<>(); //person.setInfo("abc"); person.setInfo(null); Object object = person.getInfo(); } @SuppressWarnings({ "static-access", "rawtypes", "unchecked", "unused" }) @Test public void test2() { //Person<Object> person = new Person<String>("张三"); Person<Integer> person = new Person<Integer>(30); String string = person.testY("abc"); System.out.println(string); ArrayList list = new ArrayList(); list.add(100); list.add(200); list.add(50); list.add(10); Integer[] tmp = new Integer[0]; //Integer[] arr = list.toArray(tmp); } @SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void test1() { Person person = new Person(true); Object valaueObject = person.getInfo(); System.out.println(valaueObject); Person<String> person2 = new Person<String>("张三"); String name = person2.getInfo(); System.out.println(name); Person<Integer> person3 = new Person<Integer>(30); Integer integer = person3.getInfo(); System.out.println(integer); } }