JAVA泛型 及 可变参数
1 泛型定义
2 使用泛型的优点
2.1 创建集合对象，不使用泛型
好处：
集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
弊端：
不安全，会引发异常
import java.util.ArrayList;
import java.util.Iterator;
public class DemoGeneric {
public static void main(String[] args) {
show01();
}
private static void show01(){
ArrayList list=new ArrayList<>();
list.add("abc");
list.add(1);
//使用迭代器遍历list集合
//获取迭代器
Iterator it=list.iterator();
//使用迭代器中的方法hasNext和next遍历集合
while (it.hasNext()){
//取出元素也是Object类型
Object obj=it.next();
System.out.println(obj);
//想要使用String类特有的方法，length获取字符串的长度；不能使用 多态 Object obj=“abc”；
//需要向下转型
//会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型
String s=(String)obj;
System.out.println(s.length());
}
}
}
输出：
2.2 创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常（代码运行之后会抛出的异常），提升到了编译期（写代码的时候会报错）
弊端：
泛型是什么类型，只能存储什么类型的数据
import java.util.ArrayList;
import java.util.Iterator;
public class DemoGeneric {
public static void main(String[] args) {
show02();
}
private static void show02(){
ArrayList list=new ArrayList<>();
list.add("abc");
list.add("cici");
//使用迭代器遍历list集合
Iterator it=list.iterator();
while (it.hasNext()){
//取出元素也是Object类型
String s=it.next();
System.out.println(s);
System.out.println(s.length());
}
}
} 3 泛型的定义和使用
格式：
修饰符 class 类名<代表泛型的变量>{ }
3.1 含有泛型的类
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定什么数据类型那个的时候，可以使用泛型
泛型可以接收任意的数据类型，可以使用Integer 、String、Student……
创建对象的时候确定泛型的数据类型
public class GenericClass {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
} public class DemoGenericClass {
public static void main(String[] args) {
//不写泛型默认是Object类型
GenericClass gc=new GenericClass();
gc.setName("只能是字符串");
Object obj=gc.getName();
System.out.println(obj);
//创建一个GenericClass对象，泛型使用Integer类型
GenericClass gc2=new GenericClass<>();
gc2.setName(1);
Integer name= gc2.getName();
System.out.println(name);
//创建一个GenericClass对象，泛型使用String类型
GenericClass gc3=new GenericClass<>();
gc3.setName("abc");
String name2= gc3.getName();
System.out.println(name2);
}
}
输出：
3.2 含有泛型的方法
定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
格式：
修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{
方法体
}；
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
public class GenericMethod {
//定义一个含有泛型的方法
public void method01(E e){
System.out.println(e);
}
//定义一个含有泛型的静态方法
public static void method02(E e){
System.out.println(e);
}
} public class DemoGenericMethod {
public static void main(String[] args) {
//创建GenericMethod对象
GenericMethod gm=new GenericMethod();
/**
* 调用含有泛型的方法method01
* 传递什么类型，泛型就是什么类型
*/
gm.method01(10);
gm.method01("abc");
gm.method01(8.8);
gm.method01(true);
gm.method02("静态方法，不建议创建对象使用");
//静态方法，通过类名.方法名（参数）可以直接使用
GenericMethod.method02("静态方法");
GenericMethod.method02(1);
}
}输出：
3.3 含有泛型的接口
public interface GenericInterface {
public abstract void method(I i);
}第一种使用方式：
定义接口的实现类，实现接口，指定接口的泛型
public interface Iterator
E next();
}
Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String
public final class Scanner implement Iterator
public String next(){}
}
public class GenericInterfaceImpl implements GenericInterface{
@Override
public void method(String s) {
System.out.println(s);
}
}
第二种使用方式：
接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
public Interface List
boolean add（E e）；
E get （int index）；
}
public class ArrayList
public boolean add（E e）{}
public E get（int index）{}
·}
/**
* 含有泛型的接口第二种使用方式：
*/
public class DemoInterfaceImpl2 implements GenericInterface{
@Override
public void method(I i) {
System.out.println(i);
}
}/**
* 测试含有泛型的接口
*/
public class DemoGenericInterface {
public static void main(String[] args) {
//创建GenericInterfaceImpl对象
GenericInterfaceImpl gi1=new GenericInterfaceImpl();
gi1.method("字符串");
//创建GenericInterfaceImpl2对象
DemoInterfaceImpl2 gi2=new DemoInterfaceImpl2<>();
gi2.method(11);
DemoInterfaceImpl2 gi3=new DemoInterfaceImpl2<>();
gi3.method(11.23);
}
} 输出：
4 泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符表示。但是一旦使用泛型的通配符之后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
4.1 通配符的基本使用
泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用？。
？表示未知通配符，代表任意的数据类型
此时只能接受数据，不能往集合中存储数据
使用方式：
不能创建对象使用
只能作为方法的参数使用
import java.util.ArrayList;
import java.util.Iterator;
public class DemoGeneric2 {
public static void main(String[] args) {
ArrayList list1=new ArrayList<>();
list1.add(1);
list1.add(2);
ArrayList list2=new ArrayList<>();
list2.add("a");
list2.add("b");
printArray(list1);
printArray(list2);
}
/**
* 定义一个方法，能遍历所有类型的ArrayList集合
* 这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符？来接收数据类型
* 注意：
* 泛型没有继承概念，所以<>里面不能写Obj，只能写？
*/
public static void printArray(ArrayList list){
Iterator it=list.iterator();
while (it.hasNext()){
//it.next()方法，取出的元素是Object，可以接收任意的数据类型
Object obj=it.next();
System.out.println(obj);
}
}
}
输出：
4.2 通配符的高级使用——受限泛型
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在Java的泛型中，可以指定一个泛型的上限和下限。
泛型的上限：
格式：类型名称对象名称
意义：只能接收该类型及其子类
泛型的下限：
格式：类型名称对象名称
意义：只能接收该类型及.其父类型
5 斗地主案例练习
按照斗地主的规则，完成洗牌发牌的动作
具体规则：
使用54张牌打乱顺序，三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
/**
* 1.准备牌
* 2.洗牌
* 3.发牌
* 4.看牌
*/
public class DouDiZhu {
public static void main(String[] args) {
//1.准备牌
//定义一个存储54张牌的ArrayList集合，泛型使用String
ArrayList puke=new ArrayList<>();
//定义两个数组，一个数组存储牌的花色，一个存储序号
String[] colors={"♠","♥","♣","♦"};
String[] numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//先把大王小王存储到扑克集合中
puke.add("大王");
puke.add("小王");
//循环嵌套遍历两个数组，组装52张牌
//使用增强for循环
for (String number:numbers){
for (String color : colors) {
puke.add(color+number);
}
}
System.out.println(puke);
//2.洗牌
Collections.shuffle(puke);
System.out.println(puke);
//3.发牌
ArrayList player1=new ArrayList<>();
ArrayList player2=new ArrayList<>();
ArrayList player3=new ArrayList<>();
ArrayList dipai=new ArrayList<>();
//遍历扑克集合，获取每一张牌
//使用扑克集合的索引%3个玩家轮流发牌
//剩余三张给底牌
//注意：
// 先判断底牌（i>=51)，否则牌就没了
for (int i = 0; i < puke.size(); i++) {
//获取每一张牌
String p=puke.get(i);
//轮流发牌
if (i>=51){
dipai.add(p);
} else if (i%3==0) {
player1.add(p);
}else if (i%3==1) {
player2.add(p);
}else if (i%3==2) {
player3.add(p);
}
}
//看牌
System.out.println(player1);
System.out.println(player2);
System.out.println(player3);
System.out.println(dipai);
}
} 输出：
6 可变参数
是JDK1.5之后 出现的新特性
6.1 使用前提
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
6.2 使用格式
定义方法时使用
修饰符 返回值类型 方法名（数据类型……变量名）{ }
6.3 原理
可变参数底层就是一个数组，根据传递参数的个数不同，会创建不同长度的数组，来存储这些参数
传递参数的个数，可以是0个（不传递）、1、2……多个
//可变参数
public class DemoVarArgs {
public static void main(String[] args) {
int i=add(1,2,3,4,5);
System.out.println(i);//0
}
//定义计算0-n个整数和的方法，
//已知计算整数的和，数据类型已经确定int
//但是参数个数不确定,不知道要计算几个整数的和，这个时候可以使用可变参数
/**
*add（）：就会创建一个长度为0的数组，new int[0]
* add():就会创建一个长度为1的数组，new int[]{10};
*/
public static int add(int...arr){
System.out.println(arr);//[I@b4c966a，底层是一个数组
//定义初始化变量，记录累加求和
int sum=0;
//遍历数组，获取数组中每一个元素
for (int i : arr) {
sum=i+sum;
}
return sum;
}
//定义一个方法，计算两个int类型整数的和
public static int add(int a,int b){
return a+b;
}
}输出：
可变参数的终极写法：
public static void method（Object...obj）{ }
6.4 注意事项
1.一个方法的参数列表，只能有一个可变参数
2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾