Java泛型

泛型定义在接口上
package org.westos.org.westos.demo3;
public interface MyInterface<M> {
   M set(M str);
}
泛型定义在类和方法上
package org.westos.org.westos.demo3;
public class Teacher<T> {
    private T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }

public <E> void show(E e){
System.out.println(e);}

泛型

泛型是一种把类型明确工作，推迟到创建对象或调用方法时再去明确的机制，泛型把类型问题，提前到编译期，在编译期有效，在运行期擦除

泛型的格式:<数据类型>        这里的数据类型是指引用数据类型

例如：ArrayList<String> list = new ArrayList<String>();在JDK1.8之后，后面的<>里面的数据类型可以不写

泛型很好的避免了向下转型

泛型可以加在  类型、接口、方法 上

泛型的接口的子类

 第一种情况：在定义子类的时候我们已经可以明确数据类型了

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

}

泛型的通配符号<?>  

表示任意类型，没有明确给出，就可以是Object类或者任意的java类

向上限定      Animal<?  super   Dog>   a=new Animal <可以填Dog以及Dog的父类>()

向下限定     Animal<? extends Animal> a2=new Animal<可以填Animal以及Animal的子类>();

 例如：

 ArrayList<String> strings = new ArrayList<>();
        ArrayList<Integer> strings2 = new ArrayList<Integer>();
       strings.addAll(strings2); //报错,因为两个集合的类型不同

 泛型如果明确了数据类型，那么左右两边的数据类型必须一致

package org.westos.demo;
import java.util.ArrayList;
import java.util.Collection;
public class Test {
	public static void main(String[] args) {
		ArrayList<Object> list = new ArrayList<Object>();
		ArrayList<String> list2 = new ArrayList<String>();
		//ArrayList<Integer> list3 = new ArrayList<String>();//报错，前后类型不同
		//Type mismatch: cannot convert from ArrayList<String> to ArrayList<Integer>
		ArrayList<?> list4 = new ArrayList<Object>();
		ArrayList<?> list5 = new ArrayList<Integer>();
		//向上限定
		Collection<? super Animal> arrayList = new ArrayList<Object>();
		//先下限定
		Collection<? extends Animal> arrayList2 = new ArrayList<Integer>();
		//报错
		//Collection<? super Object> arrayList3 = new ArrayList<Integer>();
	}
}

新式for循环（加强for循环）

for（int      a  :  arr）{     }

先写容器中的元素类型       在写一个元素的变量名  ：  需要遍历的容器

可变参数          数据类型   ...   数组

可变参数是在JDK1.5之后提出来的，他的本质是一个数组，当有多个参数的时候，可变参数需要放在最后。

public static double add(double    a   ， double ... b)

package org.westos.demo;
import java.util.Arrays;
import java.util.List;
public class MyTest2 {
	public static void main(String[] args) {
		double add = add(1, 2);
		double add1 = add(1, 2, 3);
		double add2 = add(1, 2, 3, 4);
		System.out.println(add);
		System.out.println(add1);
		System.out.println(add2);
		List<String> strings = Arrays.asList("abc", "aaaa", "ddddd", "ddddd");
		System.out.println(strings);
	}
	public static double add(double... b) {
		System.out.println(b.length);
		int sum = 0;
		for (double num : b) {
			sum += num;
		}
		return sum;
	}
}