java学习笔记（day23）

0x00 泛型

1.概述

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。

泛型也可以看出是一个变量，用来接收数据类型
E e:Element 元素
T t:Type 类型

例如：ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型。
E：未知的数据类型

创建集合对象的时候，就会确定泛型的数据类型

2.使用泛型的好处

package day23;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {    
      public static void main(String[] args) {  
        }    
/*    
创建集合对象，不使用泛型    
好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。    
弊端：不安全，会引发异常。     
*/    
      private static void show1(){        
            ArrayList list = new ArrayList();        
            list.add("adb");        
            list.add(1);        
            //使用迭代器遍历list集合        
            Iterator it = list.iterator();        
            while (it.hasNext()) {            
                  Object obj = it.next();            
                  System.out.println(obj);            
                  //想要使用String类特有的方法，length获取字符串长度，需要向下转型。            
                  //而在这时，会抛出类型转换一场，不能把Integer类型转换成String类型。            
                  String s = (String)obj;            
                  System.out.println(s.length());        
            }    
      }    
/*    
创建集合对象，使用泛型    
好处：    
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。    
2.把运行期异常（代码运行之后会抛出的异常），提升到了编译器（写代码的时候会报错）。    
弊端：    
泛型是什么类型，只能存储什么类型的数据。     
*/    
      private static void show2(){        
            ArrayList<String> list = new ArrayList<>();        
            list.add("abc");        
            //使用迭代器遍历list集合        
            Iterator<String> it = list.iterator();        
            while(it.hasNext()){                    
      }    
}

3.泛型的定义和使用

定义含有泛型的方法：泛型定义在方法和修饰符和返回值类型之间

格式：
修饰符 <泛型> 返回值类型 方法名（参数列表（使用泛型））｛
方法体；
｝

含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。

4.含有泛型的接口的定义和使用

1. 含有泛型的接口第一种使用方式：定义接口的实现类，视线接口，指定接口的泛型。
   public interface Iterator{
   E next();
   }
   Scanner类视线了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String
   public final class Scanner implements Iterator{
   public String next() { }
   }

2. 含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。
   public interface list{
   boolean add(E e);
   E get(int index);
   }
   public class ArrayList implements List{
   public boolean add(E e) {}
   public E get(int index) {}
   }

5.泛型通配符

泛型的通配符：
？：代表任意的数据类型
使用方式：
不能创建对象使用
只能作为方法的参数使用

使用环境
定义一个方法，能遍历所有类型的ArrayList集合。
这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符?来接受数据类型。

注意：泛型没有继承概念

0x01 斗地主案例

斗地主综合案例要求：
以斗地主的规则，完成洗牌和发牌的动作。

案例完成思路

1. 准备牌：54张牌，存储到一个集合中。
   特殊牌：大王，小王
   其他52张牌：
   定义一个数组/集合，存储四种花色：黑桃、红桃、梅花、方块。
   定义一个数组/集合，存储13个序号A，2，3...K。

2. 循环嵌套遍历两个数组/集合，组装52张牌。

3. 洗牌
   使用集合工具类Collection的方法
   static void shuffle(List<?>list)使用指定的随即元对指定列表进行置换。
   会随机的打乱集合中元素的顺序。

4. 发牌
   要求：1人17张牌，剩余3张作为底牌，一人一张轮流发牌：集合的索引（0-53）%3
   定义4个集合，存储3个玩家的牌和底牌
   索引%2，有两个值（0，1）0%2=0 1%2=1 2 2%2=0 3%2=1。
   索引%3，有三个值（0，1，2）0%3=0 1%3=1 2%3=2 3%3=0。
   索引>=51，该底牌发牌。

5. 看牌
   直接打印集合，遍历存储玩家和底牌的集合。

代码实现

package day23;
/*
斗地主综合案例：
1. 准备牌
2. 洗牌
3. 发牌
4. 看牌 
*/
import javafx.print.Collation;
import javax.lang.model.element.NestingKind;
import java.util.ArrayList;
import java.util.Collections;
public class doudizhu01 {    
      public static void main(String[] args) {        
            // 1.准备牌        
            //定义一个存储54张牌的ArrayList集合，泛型使用String        
            ArrayList<String> poker = new ArrayList<>();        
            // 定义一个数组，一个数组存储牌的花色，一个数组存储牌的序号。        
            String[] colors = {"♠","♥","♣","♦"};        
            String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};        
            //先把大王和小王存储到poker集合中        
            poker.add("大王");        
            poker.add("小王");        
            //循环嵌套遍历两个数组，组装52张牌        
            for (String number:numbers){            
                  for (String color : colors){              
                        // System.out.println(color+number);                
                        poker.add(color+number);            
                  }        
            }        
            // 2.洗牌        
            //使用集合的工具类Collections种的方法        
            //static void shuffle(list<?> list)使用默认随机源对指定列表进行置换。        
            Collections.shuffle(poker);        
            // 3.发牌        
            //定义四个集合，存储玩家的牌和底牌。        
            ArrayList<String> player1 = new ArrayList<>();        
            ArrayList<String> player2 = new ArrayList<>();        
            ArrayList<String> player3 = new ArrayList<>();        
            ArrayList<String> dipai = new ArrayList<>();        
            /*        
            遍历poker集合，获取每一张牌        
            使用poker集合的索引%3给3个玩家轮流发牌        
            剩余3张牌给底牌        
            注意：            
            首先判断底牌是不是大于51张，否则就没有底牌了、         
            */        
            for (int i = 0; i < poker.size(); i++) {            
                  //获取每一张牌            
                  String p = poker.get(i);            
                  //设置发牌循环            
                  if (i>=51){                
                        dipai.add(p);            
                  } else if (i%3 == 1){                
                        player1.add(p);            
                  } else if (i%3 == 2){                
                        player2.add(p);            
                  } else {                
                        player3.add(p);            
                  }        
            }        
            // 4.看牌        
            System.out.println("玩家1的牌："+player1);        
            System.out.println("玩家2的牌："+player2);        
            System.out.println("玩家3的牌："+player3);        
            System.out.println("底牌："+dipai);    
      }
}