泛型
泛型的益处
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);