Java视频学习笔记-11-（泛型，增强for，静态导入，可变参数，集合嵌套）

1. 泛型

是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也被称为参数化类型，即把类型当做参数一样的传递
格式：<数据类型> 此处的数据类型只能是引用类型（即<E>）

好处：
（1）把运行时的问题提前到了编译期间
（2）避免了强制类型转换
（3）优化了程序设计，解决了黄色警告线

使用场景：一般在集合中（如果类，接口，抽象类后面有<E>就说明要使用泛型）

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo {
	public static void main(String[] args) {
		ArrayList<String> array = new ArrayList<String>();
		
		array.add("hello");
		array.add("world");
		array.add("java");
		
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
	}
}

ArrayList存储自定义对象并遍历泛型版（泛型明确写的时候等号左右的类型必须一致）

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		//JDK7的新特性：泛型推断 ，即后面的<>可以不用谢
		ArrayList<Student> array = new ArrayList<Student>();
		
		Student s1 = new Student("曹操",40);
		Student s2 = new Student("蒋干",30);
		Student s3 = new Student("诸葛亮",26);
		
		array.add(s1);
		array.add(s2);
		array.add(s3);
		
		//遍历
		Iterator<Student> it = array.iterator();
		while(it.hasNext()) {
			Student s = it.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
		for(int i = 0; i < array.size();i++) {
			Student s = array.get(i);
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}

泛型类：
把泛型定义在类上
格式：public class 类名<泛型类型1...>
注意：泛型类型必须是引用类型

public class ObjectTool<T> {
	private T obj;
	
	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}

    public void show(T t){
        System.out.println(t);
    }
}

泛型方法：
把泛型定义在方法上
格式：public <泛型类型> 返回类型 方法名(泛型类型)

public class ObjectTool {
	//可以接收任意类型的参数
	public <T> void show(T t) {
		System.out.println(t);
	}
}

泛型接口：
把泛型定义在接口上
格式：public interface 接口名<泛型类型1...>

public interface Inter<T> {
    public abstract void show(T t);
}

//实现类在实现接口的时候
//第一种情况：已经知道是什么类型的了

/*public class InterImpl<T> implements Inter<T> {
	public void show(T t) {
		System.out.println(t);
	}
}*/

//第二种情况：还不知道是什么类型的
public class InterImpl<T> implements Inter<T> {
	public void show(T t) {
		System.out.println(t);
	}
}

public class InterDemo {
	public static void main(String[] args) {
		//第一种情况的测试，实现的时候已经知道是String类型
		//Inter<String> i = new InterImpl();
		//i.show("hello");
		
		//第二种情况的测试
		Inter<String> i = new InterImpl<String>();
		i.show("hello");
		
		Inter<Integer> ii = new InterImpl<Integer>();
		ii.show(100);
	}
}

泛型高级之通配符：
泛型通配符：
（1）<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类
（2）<? entends E>：向下限定，E及其子类
（3）<? super E>：向上限定，E及其父类

2. 增强for

是简化数组和Collection集合的遍历

格式：
for(元素数据类型 变量: 数组或者Collection集合){
           使用变量即可，该变量就是元素
}

好处：简化了数组和集合遍历
注意事项：增强for的目标要判断是否为null

增强for是用来替代迭代器的

ArrayList存储字符串并遍历，要求加入泛型，并用增强for遍历

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo {
	public static void main(String[] args) {
		ArrayList<String> array = new ArrayList<String>();
		
		array.add("hello");
		array.add("world");
		array.add("java");
		
		//增强for
		for(String s : array) {
			System.out.println(s);
		}
	}
}

3. 静态导入

格式：import static 包名...类名. 方法名;
可以直接导入到方法的级别

注意事项：
（1）方法必须是静态的
（2）如果有多个同名的静态方法，这个时候使用必须要加前缀，由此可见，一般不用

4. 可变参数

可变参数：定义方法的时候不知道该定义多少个参数
格式：
        修饰符 返回值类型 方法名 （数据类型...  变量名）{
                  
         }
注意：这里的变量实际是一个数组。如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

Arrays工具类的asList方法：
public static <T> List<T> asList(T... a)：把数组转成集合
注意事项：虽然可以把数组转成集合，但是集合的长度不能改变

import java.util.Arrays;
import java.util.List;

public class ArrayListDemo {
	public static void main(String[] args) {
		//定义一个数组
//		String[] strArray = {"Hello","world","java"};
//		List<String> list = Arrays.asList(strArray);
		
		//可变参数，想给几个就给几个
		List<String> list = Arrays.asList("hello","world","java");
		
		for(String x : list) {
			System.out.println(x);
		}
	}
}

5. 集合嵌套

集合嵌套的遍历方法：（先遍历大的集合，再遍历小的集合）

for(ArrayList<Student> array : bigArrayList) {
	for (Student s : array) {
		System.out.println(s);
	}
}