1.为什么要有泛型?
ArrayList<String> strings = new ArrayList<>();
strings.add("123");//只能添加字符串
@Test
public void test(){
ArrayList arrayList = new ArrayList();
//存放学生的成绩
arrayList.add(123);
arrayList.add(214);
arrayList.add(187);
arrayList.add(1877);
arrayList.add(1321);
arrayList.add(12311);
//问题一:类型不安全
arrayList.add("Tom");
for (Object object : arrayList){
//问题二:强转时可能出错 java.lang.ClassCastException
int stuScore = (Integer)object;
System.out.println(stuScore);
}
}
//z在集合中使用泛型的情况
@Test
public void test2(){
ArrayList<Integer> ints = new ArrayList<Integer>();
//ints.add("dsd");编译不通过
ints.add(123);
ints.add(123);
ints.add(123);
ints.add(123);
ints.add(123);
Iterator<Integer> iterator = ints.iterator();
while (iterator.hasNext()){
//避免了强转操作
System.out.println(iterator.next());
}
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("tom",15);
map.put("tom2",15);
map.put("tom3",15);
map.put("tom4",15);
//Map.put(123,123)
Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Map.Entry<String, Integer> next = iterator1.next();
String key = next.getKey();
Integer value = next.getValue();
System.out.println(key + " " + value);
}
}
map循环
HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
hashMap.put("sd",12);
hashMap.put("sd1",12);
hashMap.put("sd2",12);
hashMap.put("sd3",12);
hashMap.put("sd4",12);
hashMap.put("sd5",12);
Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> next = iterator.next();
String key = next.getKey();
Integer value = next.getValue();
System.out.println(key);
System.out.println(value);
}
2.在集合中使用泛型
3 自定义泛型结构
自定义泛型类
自定义泛型接口
自定义泛型方法
@Test
public void test(){
//如果定义了泛型类,实例化没有指明泛型类型,则认为此泛型类为object类型
//要求:如果大家定义的类时带泛型的,建议在实例化时指明类的泛型
Order order = new Order();
order.setOrderT(123);
order.setOrderT("dsd000");
//建议:实例化时指明泛型;
Order<String> stringOrder = new Order<>();
//stringOrder.setOrderT(123);编译错误
stringOrder.setOrderT("AA");
stringOrder.setOrderT("CC");
stringOrder.setOrderT("DD");
stringOrder.getOrderT();
SubOrder subOrder = new SubOrder();
subOrder.setOrderT(123);//由于子类在继承带泛型的父类时,指明了泛型类型,则实例化子类对象时,不再需要指明泛型
// subOrder.setOrderT(123);
SubOrder1<String> subOrder1 = new SubOrder1();
subOrder1.setOrderT("123");
//subOrder1.setOrderT(123);
}
@Test
public void test2(){
//泛型不同的引用不能相互赋值
ArrayList<String> arr = new ArrayList<>();
ArrayList<Integer> arr1 = new ArrayList<>();
//arr = arr1;
//arr.addAll(arr1);
}
//泛型方法:在方法中出现了泛型结构,泛型参数与类的泛型参数没有任何关系
public static <E> List<E> copyFromArrayToList(E[] arr){//可以使用静态static,因为它不需要类的泛型确定,而是调用方法时确认;
//第一个<E> 是方法中参数的泛型
//第二个是List<E>返回类型list是带泛型的
ArrayList<E> list = new ArrayList<>();
for (E e : arr){
list.add(e);
}
return list;
}
//下面方法不是泛型方法
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Test
public void test3(){
Order<String> objectOrder = new Order<String>();
ArrayList<Integer> integerss = new ArrayList<>();
integerss.add(223);
integerss.add(223);
integerss.add(223);
integerss.add(223);
Integer[] integers = new Integer[]{1, 2, 3, 4};
int[] arr = new int[10];
List<Integer> integers1 =objectOrder.copyFromArrayToList(integers);
System.out.println(integers1);
// System.out.println(integers12);
}
creature没有继承Person,不能作为参数
4 泛型在继承上的体现
5 通配符的使用
第一个extends 必须是object或者是他的子类:上限extends:使用时指定的类型必须是继承某个类,或者实现某个接口,即<=
第二个super必须是本类或者是他的父类:使用时指定的类型不能小于操作的类,即>=
6 泛型应用举例
/**
* describe:
*
* DAO: data(base) access object
* @author suoliang
* @create 2021-04-17:16
*/
public class DAO<T>//操作表的共性操作dao
{
//添加一条记录;
//....
public void addC(T t){
}
//删除一条记录;
//....
public void remove(){}
//修改一条记录;
//....
public void replace(){}
//查询一条记录;
//....
public T getIndex(int index){
return null;
}
//查询多条记录;
//泛型方法:
//举例:获取表中一共有多少条记录?long 获取最大员工入职时间:Date
public <E> E getValue(){
return null;
}
}
class Customer{
//此类对应数据库中的customers表
}
class CustomerDAO extends DAO<Customer>{//只能操作一个表的dao
}
class DAOTest{
@Test
public void test(){
CustomerDAO customerDAO = new CustomerDAO();
customerDAO.addC(new Customer());
}
}
/**
* describe:
* 自定义泛型类
*
* @author suoliang
* @create 2021-04-0:21
*/
public class Order<T> {
String orderName;
int orderid;
//T类的内部结构就可以使用类的泛型
T orderT;
public Order(){
T[] arr = (T[])new Object[10];//编译通过
}
public Order(String orderName,int orderid, T orderT){
this.orderName = orderName;
this.orderid = orderid;
this.orderT = orderT;
}
//泛型方法:在方法中出现了泛型结构,泛型参数与类的泛型参数没有任何关系
public static <E>List<E> copyFromArrayToList(E[] arr){//可以使用静态static,因为它不需要类的泛型确定,而是调用方法时确认;
//第一个<E> 是方法中参数的泛型
//第二个是List<E>返回类型list是带泛型的
ArrayList<E> list = new ArrayList<>();
for (E e : arr){
list.add(e);
}
return list;
}
//下面方法不是泛型方法
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderid=" + orderid +
", orderT=" + orderT +
'}';
}
//静态方法不能使用类的泛型
//异常类不能声明为泛型
// public static void show(){ 错误:因为静态方法,可以不new对象直接创建;但是没有
// System.out.println(orderT);
// }
}
class SubOrder extends Order<Integer>{//suborder不是泛型
//子类继承带泛型的父类时,指明了泛型的类型,则在实例化子类对象时,不再需要指明泛型
}
class SubOrder1<T> extends Order<T>{}
class Creature{}
class Person extends Creature{}
class Man extends Person{}
class PersonTest {
public static <T extends Person> void test(T t){
System.out.println(t);
}
public void printCollection1(Collection c) {
Iterator i = c.iterator();
for (int k = 0; k < c.size(); k++) {
System.out.println(i.next());
} }
public void printCollection(Collection<Object> c) {
for (Object e : c) {
System.out.println(e);
} }
public static void main(String[] args) {
test(new Person());
test(new Man());
ArrayList arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(1);
arrayList.add(1);
new PersonTest().printCollection(arrayList);
//The method test(T) in the type PersonTest is not
//applicable for the arguments (Creature)
//test(new Creature());//
}
public static void addStr(List<? super Object> list){
list.add(1);
list.add(2);
list.add(1);
}
}