第1章 增强for循环
增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。
它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
for(元素的数据类型 变量 : Collection集合or数组){
}
它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
public class Demo04 {
public static void main(String[] args) {
Collection<Person> arr=new ArrayList<Person>();
arr.add(new Person("小懒猫",18));
arr.add(new Person("小紫毛",20));
arr.add(new Person("小黑毛",20));
for(Person i:arr){//增强for遍历
System.out.println(i);
}
Iterator<Person> it=arr.iterator();
while(it.hasNext()){//while迭代遍历
System.out.println(it.next());
}
System.out.println();
//遍历Person数组
Person[] brr={new Person("小白猫",18),
new Person("小黑猫",20),
new Person("小绿帽",21)};
for(Person i:brr){
System.out.println(i);
}
}
}
增强for循环和老式的for循环有什么区别？
注意：新for循环必须有被遍历的目标。目标只能是Collection或者是数组。
建议：遍历数组时，如果仅为遍历，可以使用增强for如果要对数组的元素进行 操作，使用老式for循环可以通过角标操作。
泛型
1.1.1 含有泛型的类
定义格式：修饰符 class 类名<代表泛型的变量> { }
例如，API中的ArrayList集合：
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
}
使用格式：创建对象时，确定泛型的类型
例如，ArrayList<String> list = new ArrayList<String>();
此时，变量E的值就是String类型
class ArrayList<String>{
public boolean add(String e){ }
public String get(int index){ }
}
1.1.1 含有泛型的接口
定义格式：修饰符 interface接口名<代表泛型的变量> { }
例如，API中的Iterator迭代器接口
public interface Iterator<E> {
public abstract E next();
}
使用格式：
1、定义类时确定泛型的类型
public final class Scanner implements Iterator<String> {
public String next(){
}
}
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
例如
ArrayList<String> list = new ArrayList<String>();
Iterator<String> it = list.iterator();
public interface Iterator<String> {
public abstract String next();
}
1.1 使用泛型的好处
将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
避免了类型强转的麻烦。
public class GenericDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("oracle");
//list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
//集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
}
泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。
但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
泛型限定
限定泛型的上限：
格式：? extends E
? 代表接收E类型或者E的子类型的元素
例如，泛型限定为：? extends Person
则 ? 代表接收Person类型或者Person子类型的元素
限定泛型的下限：
格式：? super E
? 代表接收E类型或者E的父类型的元素
例如，泛型限定为：? super Student
则 ? 代表接收Student类型或者Student父类型的元素
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import com.oracle.demo01.Person;
public class Demo01 {
public static void main(String[] args) {
Student s1=new Student("小白",8);
Student s2=new Student("小黑",8);
Worker s3=new Worker("小子",22);
Worker s4=new Worker("小兰",20);
Collection<Student> col=new ArrayList<Student>();
col.add(s1);
col.add(s2);
Collection<Worker> col2=new ArrayList<Worker>();
col2.add(s3);
col2.add(s4);
Collection<String> col3=new ArrayList<String>();
col3.add("111");
col3.add("qqq");
get(col);
get(col2);
//get(col3);
}
//泛型通配符？
//? extends Person限定泛型的上限
//? super Person限定泛型的下限
public static void get(Collection<? extends Person> c){//E用在定义类或接口上，不能使用
//学生和工人的共性类型Person。那么，泛型的限定可以这样书写：
//? extends Person : 接收Person类型或者Person的子类型。
Iterator<?> it=c.iterator();
while(it.hasNext()){
//System.out.println(it.next());遍历
Object obj=it.next();
//向下转型
Person p=(Person)obj;
System.out.println(p.getName());//调子类独有的方法
}
}
}
import com.oracle.demo01.Person;
public class Student extends Person {
public Student() {
super();
}
public Student(String name, int age) {
super(name, age);
}
}
import com.oracle.demo01.Person;
public class Worker extends Person {
public Worker() {
super();
}
public Worker(String name, int age) {
super(name, age);
}
}