泛型
-
解决元素存储的安全性问题
-
解决获取数据元素时，需要类型强转的问题
-
核心思想：把一个集合中的内容限制为一个特定的数据类型 静态方法中不能使用类的泛型
-
不能在catch中使用泛型
-
如果泛型类是一个接口或抽象类，则不可创建泛型类的对象
-
从泛型类派生子类，泛型类型需要具体化
1.在集合中使用泛型
import java.util.*;
public class Test{
//在集合中没有使用泛型的情况下
@org.junit.Test
public void test1(){
List list = new ArrayList();
list.add(1003);
list.add(1004);
list.add(1005);
//任何的Object及其子类对象都可以添加
list.add("CA");
for(int i = 0; i < list.size();i++){
//强制转为int型时,报ClassCastException异常
int id = (Integer)list.get(i);
System.out.println(id);
}
}
//在集合中使用泛型的情况下
@org.junit.Test
public void test2(){
List<Integer> list = new ArrayList<Integer>();这里的泛型是规定输入的要是Integer类型的数据
list.add(1003);
list.add(1004);
list.add(1005);
//list.add("CA");//此处输入其他数据类型，就会报错，不让输入
// for(int i = 0; i < list.size();i++){
// //强制转为int型时,报ClassCastException异常
// int id = (Integer)list.get(i);
// System.out.println(id);
// }
Iterator<Integer> i = list.iterator();
while(i.hasNext()){
System.out.println(i.next());
}
}
//在集合Map中使用泛型的情况下
@org.junit.Test
public void test3(){
Map<String,Integer> map = new HashMap<String,Integer>();//这里的泛型是规定的key要是String类型，Value要是Integer类型
map.put("AA",23);
map.put("AB",23);
map.put("AC",23);
map.put("AA",23);
Set<Map.Entry<String,Integer>> set = map.entrySet();
for(Map.Entry<String,Integer> o : set ){
System.out.println(o.getKey() + "------>" + o.getValue());
}
}
}
2.自定义泛型类，泛型接口，泛型方法
-
当实例化泛型类的对象时，指明泛型的类型，即指明之后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
-
如果我们自定义了泛型类，但在实例化时没有使用，那么默认类型是
Object类
DAO（database access object）:数据访问对象
例：
//自定义泛型类
import java.util.ArrayList;
import java.util.List;
public class Customer<T>{
private Integer id;
private String name;
private T t;
List<T> list = new ArrayList<>();
public void add(){
list.add(t);
}
public T getT(){
return t;
}
public void setT(T t){
this.t = t;
}
//声明泛型方法
public <C> C getC(C c){
return c;
}
public Integer getId(){
return id;
}
public void setId(Integer id){
this.id = id;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public Customer(String name,Integer id){
super();
this.name = name;
this.id = id;
}
public Customer(){
super();
}
@Override
public String toString(){
return "Customer [name= " + name + ", id=" + id + "t= " + t + "]";
}
}
//继承泛型类或接口时,可以指明泛型的类型
class Scustomer extends Customer<Integer>{
}
import java.util.List;
import org.junit.Test;
public class Test1{
//自定义泛型类的使用
@Test
public void test1(){
Customer<Boolean> customer = new Customer<Boolean>();
customer.setT(true);
System.out.println(customer.getT());//true
customer.add();
List<Boolean> list = customer.list;
System.out.println(list);//true
Scustomer s = new Scustomer();
List<Integer> list1 = s.list;
System.out.println(list1);
//泛型方法测试(当通过对象调用泛型方法时，指明泛型方法的类型)
Integer a = customer.getC(66);
Double b = customer.getC(8.8);
}
}
3.泛型与继承的关系
若类A是类B的子类，那么List<A>就不是List<B>的子接口
4.通配符（?）
List<A>,List<B>…都是List<?>的子类? extends A：可以存放A及其子类? super A：可以存放A及其父类- 可以读取声明为通配符的集合的对象，但不能写入声明为通配符的集合的对象（null除外，它能写入）
例：
public class Test{
@Test
public void test3(){
List<?> list = null;
List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();
list = list1;
list = list2;
//Integer 是 Number 的子类型
// ? extends A：可以存放A及其子类（上限通配符）
List<? extends Number> list3 = null;
List<Integer> list4 = null;
list3 = list4;//成功
list3 = list1;//不能执行
// ? super A：可以存放A及其父类（下限通配符）
List<? super Number> list5 = null;
list5 = list1;//可以
}
@Test
public void test4(){
List<String> listed = new ArrayList<String>();
listed.add("AA");
listed.add("BB");
listed.add("CC");
List<?> listes = listed;
//可以读取声明为通配符的集合的对象
Iterator<?> iterator = listes.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
listes.add("DD");//添加失败，除null外都不可以写入
listes.add(null);//null可以写入
}
}
5.泛型练习
interface Info{ //此接口的子类表示人的信息
}
class Contact implements Info{//联系方式
private String phone_id;//联系方式
private String zipcode;//邮编
private String address;//联系地址
public String getAddress(){
return address;
}
public void setAddress(String address){
this.address = address;
}
public String getId(){
return phone_id;
}
public void setId(String phone_id){
this.phone_id = phone_id;
}
public void setZipcode(String zipcode){
this.zipcode = zipcode;
}
public String getZipcode(){
return zipcode;
}
public Contact(String phone_id,String zipcode,String address){
super();
this.zipcode = zipcode;
this.phone_id = phone_id;
this.address = address;
}
public Contact(){
super();
}
@Override
public String toString(){
return "Contact [address= " + address + ", phone_id=" + phone_id + "zipcode= " + zipcode + "]";
}
}
class Information implements Info{//个人信息
private String name; //姓名
private int age; //年龄
private String sex; //性别
public Information(String name,int age,String sex){
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public Information(){
super();
}
public String getSex(){
return sex;
}
public void setSex(String sex){
this.sex = sex;
}
public int getId(){
return age;
}
public void setId(int age){
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
@Override
public String toString(){
return "Information [name= " + name + ", age=" + age + "sex：" + sex + "]";
}
}
class Person<T extends Info>{
private T info;
public Person(T info){
this.info = info;
}
public T getInfo(){
return info;
}
public void setIinfo(T info){
this.info = info;
}
@Override
public String toString(){
return "Person [ info= " + info + "]";
}
}
public class Test5{
public static void main(String[] args) {
Person<Contact> per = null;
per = new Person<Contact>(new Contact("13599988881","05123","上海市"));
System.out.println(per);
Person<Information> per1 = null;
per1 = new Person<Information>(new Information("黄某",18,"男"));
System.out.println(per1);
}
}
感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础中部
