泛型和增强for循环

泛型的由来

通过Object转型问题引入,早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。因为存在这隐患，所以Java提供了泛型来解决这个安全问题。
泛型机制：是JDK1.5引入的，是一种将数据类型明确工作，推迟到创建对象，或调用方法时，再去明确的一种机制。

泛型类的概述及使用

泛型类

概述：把泛型定义在类上
定义格式: public class 类名<泛型类型1,…>
注意事项: 泛型类型必须是引用类型

public class ObjectTools<K> {
	
	private K k ;

	public K getK() {
		return k;
	}

	public void setK(K k) {
		this.k = k;
	}

}

泛型方法

概述:把泛型定义在方法上
定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)

public class Phone {
	
	/**
	 * 泛型方法
	 */
	public <E> void show(E e){
		System.out.println(e);
	}
}

泛型接口

概述: 把泛型定义在接口上
定义格式: public interface 接口名<泛型类型>

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

• 泛型接口的子类: 第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了

public class InterImpl implements Inter<String> {

		@Override  //重写父类方法
		public void show(String t) {
			System.out.println(t);
		}

}

• 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类也定义成泛型

public class InterImpl<T> implements Inter<T>  {

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

}

泛型高级之通配符

A:泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E:			向下限定，E及其子类
C:? super E:			向上限定，E及其父类

抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类。

//泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
		 
		Collection<Object> col1 = new ArrayList<Object>() ;
		Collection<Object> col2 = new ArrayList<Animal>() ;//报错
	
		// ? 表示任意的数据类型
		Collection<?> col5 = new ArrayList<Object>() ;
		Collection<?> col6 = new ArrayList<Animal>() ;
	
		// ? extends E : 向下限定	, ? 表示的是E或者E的子类
//		Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

		// ? super E:  向上限定 , ? 表示的是E或者E的父类
		Collection<? super Animal> col13 = new ArrayList<Object>() ;
		Collection<? super Animal> col14 = new ArrayList<Animal>() ;
//		Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错
	

增强for循环

概述:简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合(容器名称)) {
使用变量即可，该变量就是元素
}

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

//增强for循环 JDK1.5
        int[] arr={20,20,30,80};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        for (int i : arr) {

        }

        //遍历方式2
        // for(容器中元素的类型 当前元素变量名:容器名){
        //
        //     System.out.println(当前元素变量名);
        // }
        System.out.println("========================");
        for(int ele:arr){
            System.out.println(ele);
        }

        //增强for循环遍历集合

        ArrayList<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);

        for (Integer integer : list) {

        }

        for(Integer num:list){
            System.out.println(num);
        }

  ArrayList<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        list.add(200);
        //你要拿索引做判断，那你就使用普通for
      /*  for (int i = 0; i < list.size(); i++) {
            if(list.get(i).equals(200)){
                list.add(300);
            }
        }*/

        System.out.println("=========================");

        //如果只是遍历元素看一下，那就使用新式for循环
        //新式for循环底层用的是迭代器在迭代
        //你在用新式for循环在遍历途中，不能增删元素，否则会出现并发修改异常
        //ConcurrentModificationException
        for (Integer integer : list) {
            //System.out.println(integer);
            if(integer.equals(200)){
                list.add(300);
            }
        }