集合
泛型
概述
- jdk1.5之后引入的特性,提供了编译时类型安全检查机制,该机制允许在编译时检测到非法的类型,它的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数
- 将类型由原来的具体的类型参数化,然后在使用或调用时传入具体的类型
- 这种参数类型可以用在类、方法和接口中,分别被称为泛型类、泛型方法和泛型接口
- 定义格式:
- <类型>,指定一种类型的格式,这里的类型可以被看作形参
- <类型1,类型2…> 指定多种类型的格式,多种类型之间用逗号隔开,这里的类型可以被看作形参
- 将来具体调用时候给定的类型可以看作是实参,且实参的类型只能是引用数据类型
- 好处:
public static void main(String[] args) {
Collection c=new ArrayList();
c.add("zs");
c.add("ls");
c.add("ww");
c.add(112);
Iterator iterator = c.iterator();
while (iterator.hasNext()){
String next = (String) iterator.next();
System.out.println(next);
}
}
************************
Collection<String> c=new ArrayList();
c.add("zs");
c.add("ls");
c.add("ww");
c.add(112);
Iterator<String> iterator = c.iterator();
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
泛型类
public class Demo02 {
public static void main(String[] args) {
Teacher teacher=new Teacher();
teacher.setName("zs");
System.out.println(teacher.getName());
Student student=new Student();
student.setAge(18);
System.out.println(student.getAge());
Generic<String> generic=new Generic<>();
generic.setT("zs");
System.out.println(generic.getT());
Generic<Integer> generic1=new Generic<>();
generic1.setT(18);
System.out.println(generic1.getT());
}
}
class Teacher{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Student{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
class Generic<T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
泛型方法
public class Demo03 {
public static void main(String[] args) {
Test test=new Test();
test.show(13);
test.show("zs");
test.show(true);
Generic2 generic2=new Generic2();
generic2.show(12.5);
generic2.show("sa");
}
}
class Test{
public void show(String str){
System.out.println("Hello,"+str);
}
public void show(Integer integer){
System.out.println("Hello,"+integer);
}
public void show(boolean b){
System.out.println("Hello,"+b);
}
}
class Generic2{
public<T> void show(T t){
System.out.println("Hello,"+t);
}
}
泛型接口
public class Demo04 implements Genetic{
public static void main(String[] args) {
Genetic demo04=new Demo04();
demo04.show("zs");
demo04.show(18);
demo04.show(true);
}
@Override
public void show(Object o) {
System.out.println(o);
}
}
interface Genetic<T> {
public void show(T t);
}
类型通配符
public static void main(String[] args) {
List<?> list1=new ArrayList<Object>();
List<?> list2=new ArrayList<Integer>();
List<?> list3=new ArrayList<Number>();
System.out.println("================");
List<? extends Number> list4=new ArrayList<Integer>();
List<? extends Number> list5=new ArrayList<Number>();
List<? super Number> list6=new ArrayList<Number>();
List<? super Number> list7=new ArrayList<Object>();
}
可变参数
- 可变参数:又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了
- 格式:修饰符 返回值类型 方法名 (数据类型…参数名){}
- 注意事项:
- 可变参数的变量其实是一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数必须放在最后面
public static void main(String[] args) {
sum(1,2);
sum(2,3,4);
sum(3,4,5,6);
}
public static void sum(int ...a){
int sum=0;
for (int i = 0; i < a.length; i++) {
sum+=a[i];
}
System.out.println("和为:"+sum);
}
可变参数的使用
public class Demo07 {
public static void main(String[] args) {
List<String> list = Arrays.asList("zs","ls","ww");
System.out.println(list);
String xx = list.set(1, "xx");
System.out.println(list);
}
}