泛型相关内容

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

这些参数类型可以用在类、方法和接口中，分别被称为泛型类，泛型方法和泛型接口

泛型定义格式：

<类型>：指定一种类型的格式,可以看作形参

<类型1，类型2 ，...>：指定多种类型的格式

好处：

        1、将运行时的异常提前到编译时期

        2、避免了强制类型转换

---

泛型类

格式：

修饰符 类名<类型>{}

例子：

public class <T>{}

class Person <T , E>{
	private E age;
	private T name;
	
	public E getAge() {
		return age;
	}
	public void setAge(E age) {
		this.age = age;
	}
	public T getName() {
		return name;
	}
	public void setName(T name) {
		this.name = name;
	}
	
	
}
public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person<String , Integer>per = new Person<String , Integer>();
		per.setName("林青霞");
		per.setAge(20);
		
	}

}

---

泛型方法

class Person <T>{

	private T name;
	
	
	public T getName() {
		return name;
	}
	public void setName(T name) {
		this.name = name;
	}
	public void show(T t) {
		System.out.println(t);
	}
	
	
}
public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person per = new Person();
		per.setName("林青霞");
		per.show(19);
		per.show("林青霞");        //创建对象的时候不明确数据类型，而是在调用方法的时候明确数据类型
		
		
		
	}

}





另一种情况：
class Person{
	public <T> void show(T t) {
		System.out.println(t);
	}
}
public class Main1 {

	public static void main(String[] args) {
		Person per = new Person();
		per.show("小红");
		per.show(19);
		
		
	}

}


调用方法的时候才进行明确数据类型

---

泛型接口

定义格式：

修饰符 interface 接口名 <类型>{}

public interface Student <T>{

}

interface Person<T>{
	public void show(T t);
}
 class Student3 <T> implements Person<T>{

	@Override
	public void show(T t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}
	 
 }
public class Main1 {

	public static void main(String[] args) {
		Person<String>stu = new Student3<String>();
		stu.show("林青霞");
		
	}

}





 interface Person{
	public <T> void show (T t);
}
 class Student3 implements Person{

	@Override
	public <T> void show(T t) {
		// TODO Auto-generated method stub
		System.out.println(t);
	}

	

	
 }
public class Main1 {

	public static void main(String[] args) {
		Person  stu = new Student3();
		stu.show("林青霞");
		
	}

}

---

类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

类型通配符：<?>

List<?>:表示元素类型未知的List,他的元素可以匹配任何类型

注意：这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果我们不希望List<?>是任何泛型List的父类只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

类型通配符的上限：<?extends Number>

List<?extends Number>:它代表的类型是Number或者其子类型

还可以指定类型通配符的下限

类型通配符的下限：<? super Number> 

List<? super Number> :Number或者其父类型

List<?>list = new ArrayList<Integer>();
		List<?>list1 = new ArrayList<String>();
		List<?>list2 = new ArrayList<Number>();
		System.out.println("---------");
		List<? extends Number>list3 = new ArrayList<Number>();
		List<? extends Number>list4 = new ArrayList<Integer>();
//		List<?extends Number>list5 = new ArrayList<String>();			报错
		System.out.println("---------");
		List<? super Number>list6 = new ArrayList<Object>();

---

可变参数

可变参数又称参数个数可变，用作方法的形参出现那么方法参数个数就是可变的了

格式：

修饰符 返回值类型方法名（数据类型...变量名）{    }

例如：

public static print(int...num){    }

---

public static void main(String[] args) {
	System.out.println(sum(1 , 2 , 3));
	System.out.println(sum(1 , 5 , 2 , 4));
	System.out.println(sum(1 , 2));
	
		
	}
	public static int sum(int...a) {			//a相当于一个数组
		
		int Sum = 0;
		for(int i : a) {
			
			Sum += i;
		}
		return Sum;
		
	}
}
	

注意事项：

这里的变量实际上是一个数组

如果一个方法有多个参数，可变参数要放在后面

public static int sum(int b , int...a){}

 

---