泛型

1. 像在源码中见到的ArrayList，就是后面有个，就表示可以使用泛型机制
2. 泛型只在编译阶段有效。只是给编译器看的

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Test03 {

	public static void main(String[] args) {
//		List my = new ArrayList();
//		//准备对象
//		Cat c = new Cat();
//		Bird b = new Bird();
//		//将对象添加到集合中
//		my.add(b);
//		my.add(c);
//		//遍历集合，取出每个Animal 让他move()
//		Iterator it = my.iterator();
//		while(it.hasNext()) { 
//			Object obj = it.next();
////			obj.move(); 或者  Animal obj = it.next(); 都是错误的，此时通过迭代器取出的是Object
////			Object中没有move()方法，要向下转型
//			if(obj instanceof Animal) {
//				 Animal a = (Animal)obj;
//			}
//		}
		//使用泛型,用来指定集合中存储的数据类型
		List my = new ArrayList();
		//my.add("hei"); 报错，不可以再存储String类型，使用泛型，使得集合中的数据类型统一，在此处ArrayList集合中只能存放Animal类型及其子集
		Cat c = new Cat();
		Bird b = new Bird();
		my.add(b);
		my.add(c);
		
		
		//源码发现可以使用泛型  Iterator 
		Iterator it = my.iterator();
		while(it.hasNext()) {
			//那么使用迭代器取出的都是Animal类型，就不需要要向下转型，直接调用move()方法
			Animal a = it.next();
			a.move();
			//遍历集合，取出Cat实现zhua()，取出Bird实现fly() 调用子类特有的方法，还是需要向下转型
			if(a instanceof Cat) {
				Cat x = (Cat)a;
				 x.zhua();
			}
			if(a instanceof Bird) {
				Bird x = (Bird)a;
				 x.fly();
			}
		}
//		在JDK8后，有了类型自动判断：List my = new ArrayList<>();后面的小括号不写类型
		List shu = new ArrayList<>();
		
		shu.add("hewwww");
		shu.add("adcf");
		shu.add("abcdef");
		
		Iterator i = shu.iterator();
		while(i.hasNext()) {//直接通过迭代器获取了String类型的数据
			String s = i.next();
			String s1 = s.substring(1);//String类的substring()方法，从下标为1处截取字符串
			 System.out.println(s1);
			
		}
/*动物在移动
鸟在飞翔
 动物在移动
猫咪抓老鼠
ewwww
dcf
bcdef
*/		
	}

}
 class Animal{
	 public void move() {
		 System.out.println(" 动物在移动");
	 }
 }
 
 class Bird extends Animal {
	 public void fly() {
		 System.out.println("鸟在飞翔");
	 }
 }
 
 class Cat extends Animal{
	 public void zhua() {
		 System.out.println("猫咪抓老鼠");
	 }
 }

优点：

集合中存储的元素类型统一，从集合中取出的元素类型是泛型指定的类型，不需要大量的“向下转型”

缺点：

导致集合中元素缺乏多样性

自定义泛型

public class Test05 {
	public static void main(String[] args) {
	 
		//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
		//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
		Generic genericInteger = new Generic(123456);

		//传入的实参类型需与泛型的类型参数类型相同，即为String.
		Generic genericString = new Generic("key_vlaue");
		 System.out.println(genericInteger.getKey());
		 System.out.println( genericString.getKey());
		 
		 /*定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，
		  * 则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。
		  * 如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。*/
		 Generic generic2 = new Generic(55.55);
		 Generic generic3 = new Generic(false);
		 System.out.println(generic2.getKey());
		 System.out.println(generic3.getKey());
	}

}
//此处T可以随便写为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时（创建此泛型类型的对象时），必须指定T的具体类型
 class Generic{ 
  //key这个成员变量的类型为T,T的类型由外部指定  
  private T key;

  public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
      this.key = key;
  }

  public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
      return key;
  }
}

增强for循环（又叫做foreach）

1.语法

for( 元素类型 变量名 ：数组/集合){
System.out.println(变量名);
}

用于遍历很方便，但不适用于要使用下标的情况

int[] arr = {1,2,3};
		 //遍历数组
		 for(int i:arr) {
			 System.out.println(i);
		 }
		//i代表数组中的每一个元素，类型一致

package 集合练习;

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

public class MyList {

	public static void main(String[] args) {
		  //创建List集合
		List list = new ArrayList<>();
		//添加元素
		list.add("asd");
		list.add("asdfg");
		list.add("asdhj");
		//遍历1（用迭代器，可以使用泛型）
		Iterator it  = list.iterator();
		while(it.hasNext()) {
			String string = it.next();
			System.out.println(string);
		}
		
		//遍历2（针对于有下标的集合）
		for(int i=0;i