泛型 笔记

泛型

泛型的好处

Collection c = new ArrayList();//创建集合对象
//添加元素 没有指定类型的时候默认是Object类型   字符串赋给object类型时向上转型
c.add("hello");
c.add("World");
c.add("java");
c.add(100);//加了这个报错，存储的时候是Integer类型，结果在下面强转成了String类型，会出现ClassCastException，这个时候采用泛型解决，看下面
//遍历集合
Iterator it = c.iterator();
while(it.hasNext()){
    Object obj = it.next();//添加的时候是object类型，所以只能是object类型，
    //不想要object类型，因为输入是String类型 ，所以向下转型
    String s = (String)it.next();
    sout(obj);
    sout(s);
}

//Collection c = new ArrayList();//创建集合对象
//添加元素 没有指定类型的时候默认是Object类型   字符串赋给object类型时向上转型

Collection<String> c = new ArrayList<String>();//这样就是只能加String类型，int再写的时候就会报错
c.add("hello");
c.add("World");
c.add("java");

//c.add(100);//加了这个报错，存储的时候是Integer类型，结果在下面强转成了String类型，会出现ClassCastException，这个时候采用泛型解决
//遍历集合
Iterator<String> it = c.iterator();
while(it.hasNext()){
    //Object obj = it.next();//添加的时候是object类型，所以只能是object类型，
    //不想要object类型，因为输入是String类型 ，所以向下转型
    String s = it.next();//就不需要转换了
    sout(obj);
    sout(s);
}

泛型类

Student s = new Student();
s.setName("林青霞");
sout(s.getName());

Teacher t = new Teacher();
t.setAge(30);
sout(s.getAge());

//定义一个泛型类Generic
private T t;
alt+insert 生成get set方法

//泛型类
Generic<String> g1 = new Generic<String>();
g1.setT("林青霞");
sout(g1.getT());

Generic<Integer> g2 = new Generic<Integer>();
g2.setT(30);
sout(g2.getT());

Generic<Boolean> g3 = new Generic<Boolean>();
g3.setT(true);
sout(g3.getT());

泛型方法

上面是方法名相同，参数类型不同是方法重载

用泛型类改进

public class Generic<T>{
    public void show(T t){
        sout(t);
    }
}
//测试
Generic<String> g1 = new Generic<String>();
g1.show(t:"林青霞");

Generic<Integer> g2 = new Generic<Integer>();
g2.show(t:30);

Generic<Boolean> g3 = new Generic<Boolean>();
g3.show(t:true);

上面那个例子用泛型方法改进

public class Generic{
    public<T> void show(T t){
        sout(t);
    }
}

//测试
Generic g = new Generic();

g.show(t:"林青霞");

g.show(t:30);

g.show(t:true);

g.show(t:12.34);
//你输入了什么类型就返回什么类型

泛型接口

泛型接口

因为接口无法实例化，所以需要给出泛型接口的实现类

public class GenericImpI<T> implements Generic<T>{
    @Override
    public void show(T t){
        sout(t);
    }
}

//测试
Generic<String> g1 = new GenericImpI<String>();
g1.show(t:"林青霞");

Generic<Integer> g2 = new GenericImpI<Integer>();
g2.show(t:30);

Generic<Boolean> g3 = new GenericImpI<Boolean>();
g3.show(t:true);

类型通配符

//类型通配符
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
//表示任意类型的list的集合

//类型通配符上限 限定的是最大的类型
List<? extends Number> list4 = new ArrayList<Number>();
List<? extends Number> list5 = new ArrayList<Integer>();

//类型通配符下限 限定的是最小的类型
List<? super Number> list6 = new ArrayList<Object>();
List<? super Number> list7 = new ArrayList<Number>();

可变参数

就是参数个数可变，用作方法的形参出现


由上图可以看出可变参数把方法输入的每一个参数的数据都封装到一个数组里去了，上面的那个int…a的那个a实际上是一个数组，所以就相当于return数组中的元素和，也就是给数组元素求和

定义一个求和sum，然后用增强for遍历数组求和
如果方法中包含多个参数，应该把可变参数放在后面，放在前面会报错，这样的话第一个参数就会给了b，后面的参数就会封装到a里

注意事项

可变参数的使用

//测试
//Array的返回由指定数组支持的固定大小的列表
List<String> list = Array.asList("Hello","World","Java");

list.add("javaee");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

list.remove(o:"Hello");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

list.set(1:"javaee");//不会报错 也就是可以修改内容，但是不能添加删除元素
//因为添加删除元素会修改集合的大小，而这个是固定大小的列表
sout(list);

//测试
//List的返回包含任意数量元素的不可变列表
List<String> list = List.of("Hello","World","Java","World");//list集合可以有重复元素

list.add("javaee");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

list.remove(o:"Hello");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

list.set(1:"javaee");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许
//也就是说通过list得到的增删改都不行
sout(list);

//测试
//Set的返回包含任意数量元素的不可变集合
Set<String> set = Set.of("Hello","World","Java","World");//没有后面那个world不会报错，有了后面那个world会报错IllegalArgumentException 也就是非法或不正确的参数，因为set集合不允许有重复元素


Set<String> set = Set.of("Hello","World","Java");

set.add("javaee");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

set.remove(o:"Hello");//会报错 UnsupportedOperationException 也就是不支持请求的操作 也就是说添加操作不允许

//也就是说通过set得到的增删都不行
sout(set);