泛型
泛型的益处
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);
发表回复