第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);
    }

}