第三季最后练习-扑克牌（手牌属性，异常处理，最简单的比较大小方法）

输入正常时：

输入异常时：

扑克类Poker

package PokerSystem;
import java.util.ArrayList;
import java.util.List;

public class Player {
    //定义玩家的属性id和name
    public int id;
    public String name;

    /*
     * 定义泛型为Poker的List Pokers,即玩家的手牌属性,这样就不用单独定义List来存放每个玩家取到的手牌。如下：
     * playerList.get(j).pokers 表示第j个玩家的手牌，根据j的变化表示不同玩家的手牌List。playList表示用户输入所有的玩家集合
     */
    public List <Poker> pokers;
    //定义有参构造方法，实例化时传入参数
    public Player(int id,String name){
        this.id=id;
        this.name=name;

        //List是一个接口，不能直接实例化，用到List的实现类ArrayList()实现List接口如： 
        //List <Poker> pokers=new ArrayList <Poker>(),上面已经定义泛型为Poker的List Pokers，下面只用this调用即可;
        this.pokers=new ArrayList<Poker>();

    }

}   

玩家类Player

package PokerSystem;

public class Poker {
    //定义玩扑克的属性点数point和花色属性color
    public String point;
    public String color;

    ////定义有参构造方法，实例化时传入参数
    public Poker(String point,String color){
        this.point=point;
        this.color=color;

    }

    //定义无参构造方法,洗牌时会实例化无参构造方法
    public Poker(){

    }

    //重写equals()方法，因为最后比较大小时使用，Eclipse中菜单中Source下直接生成，点数和花色都要比较；
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Poker other = (Poker) obj;
        if (color == null) {
            if (other.color != null)
                return false;
        } else if (!color.equals(other.color))
            return false;
        if (point == null) {
            if (other.point != null)
                return false;
        } else if (!point.equals(other.point))
            return false;
        return true;
    }   
}

主程序TestPoker

package PokerSystem;
import java.util.*;

/*
 * 主程序TestPoker继承了Comparator<Poker>接口，因为要重写Compare()方法进行玩家各自的手牌排序
 * 例如：Collections.sort(playerList.get(0).pokers,new TestPoker());对第一个玩家的手牌进行排序
 * Player玩家类中定义了Poker泛型的List手牌属性pokers，所以playerList.get(0).pokers代表第一个玩家的手牌集合
 */
public class TestPoker implements Comparator<Poker>{

    public List<Poker> pokerList;            //创建扑克存放的集合
    public List<Poker> pokerListAfterShuffle;//洗完牌后存放牌的集合
    public Scanner console;                  //定义Scanner对象console,获取用户用键盘输入的值，方法中可以多次使用
    public int ID;                           //记录输入玩家的id
    public String Name;                      //记录输入玩家的name
    public Poker getPoker;                   //洗牌后玩家获取的牌
    public List<Player> playerList;          //创建List类型属性，用来承装玩家类型对象      

    /*
     * 有参构造方法，实例化对象时传入参数，实例化List接口
     */
    public TestPoker(){
        //List是一个接口，不能直接实例化，用到List的实现类ArrayList()实现List接口如： List playerList=new ArrayList <Player>();
        this.playerList=new ArrayList <Player>();
        //用List的实现类ArrayList()实例化存放扑克的List接口：PokerList
        this.pokerList=new ArrayList <Poker>();
        //用List的实现类ArrayList()实例化存放洗牌后扑克的List接口：pokerListAfterShuffle
        this.pokerListAfterShuffle=new ArrayList <Poker>();
        //实例化Scanner对象console，获取用户用键盘输入的值，方法中可以多次使用
        console=new Scanner(System.in);

        //创建一副扑克，放在pokerList中，按照从（方片2、梅花2······红桃A、黑桃A）的大小依次创建，方便后续利用取扑克在List位置来比较大小
        //另外在构造方法中创建扑克主要是为了其他方法中用到生成的这副扑克牌来比较大小
        String[] pokerPoint={"2","3","4","5","6","7","8","9","10","J","Q","K","A"}; 
        String[] pokerColor={"方片","梅花","红桃","黑桃"};
        //foreach遍历扑克的点数和花色，生成（方片2、梅花2······红桃A、黑桃A）从小到大的一副扑克
        for(String point:pokerPoint){
            for(String color:pokerColor){
               Poker pk=new Poker(point,color);
               pokerList.add(pk);
            }
        }

    }

    /*
     * 主程序TestPoker继承了Comparator<Poker>接口，这里重写compare()方法来比较拍的大小
     * 因为扑克牌pokerList是按照从小到大生成的，运用List的indexOf()方法获取扑克的索引位置，索引位置越大，扑克越大。
     */
    @Override
    public int compare(Poker o1, Poker o2) {
          // TODO Auto-generated method stub

          if(pokerList.indexOf(o1)-pokerList.indexOf(o2)>0){
              return 1; 
          }else{
          //return整数，负数表示后面大于前面，0表示相等，正数表示前面大于后面
          return -1;
          }
    }

    /*创建52张扑克并进行洗牌（顺序打乱）
     * 
     */
    public void creatPokerAndShuffle(){
        System.out.println("----------创建扑克牌----------");
        System.out.println("---------扑克牌创建成功---------");
        //foreach遍历pokerList的每张扑克，打印输出
        for(Poker poker:pokerList){
                System.out.print(poker.color+poker.point+",");  
        }

        System.out.println("\n----------开始洗牌----------");
        //实例化Random对象random生成一个随机数，进行洗牌
        Random random=new Random();
        //实例化Poker对象poker,获取从PokerList取出的扑克
        Poker poker=new Poker();

        //从PokerList中取随机取52次，用do···while循环确保每张扑克只能被取到一次，取到重复值再重新取
        for(int i=0;i<52;i++){
           do{
               //生成一个0到51的随机整数，如：random.nextInt(52)随机生成0到51的整数，不含52；
              int position=random.nextInt(pokerList.size());
              //获取每次取到的扑克
              poker=pokerList.get(position);
              //如果洗牌后的扑克集合pokerListAfterShuffle中包含刚取到的这张扑克，重新进行取
           }while(pokerListAfterShuffle.contains(poker));
           //不重复的每张扑克放入到洗牌后的扑克集合pokerListAfterShuffle中
            pokerListAfterShuffle.add(poker);
        }

        System.out.println("----------洗牌结束----------");

    }

    /*
     * 创建玩家
     */
    public void creatPlayer(){

            System.out.println("----------创建玩家----------");

        //for循环，提示输入2位玩家的ID和Name
        for(int i=1;i<3;i++){
                System.out.println("请输入第"+i+"位玩家信息：");
        //while循环，当出现输入的值部位整数的错误时，重新进行循环，提示输入ID     
        while(true){        
            try{
                System.out.println("请输入ID：");
                //获取输入的玩家ID
                ID=console.nextInt();
                System.out.println("请输入玩家姓名:");
                //获取输入的玩家Name
                Name=console.next();    
            //实例化玩家Palyer对象newplayer，调用Player的有参构造方法，并将输入的玩家ID,Name传入到属性值中  
            Player newplayer=new Player(ID,Name);
            //将输入的玩家添加到玩家集合playerList中
            playerList.add(newplayer);

            //出现输入异常时进行的处理
            }catch(InputMismatchException e){
                //获取输入异常时的值，避免死循环
                String token=console.next();
                System.out.println("请输入整数类型的ID");
                //输入异常，continue结束本次循环，进行下次循环，提示输入ID
                continue;
            }
            break;//输入正常时，break跳出while循环
        }

    }
        //foreach输出每个玩家
        for(Player player:playerList){
            System.out.println("欢迎玩家："+player.name);
        }        
    }           

    /*各发牌2张并比较大小
     * 
     */
    public void sendPokerAndPaly(){

        System.out.println("----------开始发牌----------");

        //每个玩家每次发一张牌，发两次。定义两个循环：A拿牌-B拿牌-A拿牌-B拿牌；即A拿List中0和2位置的牌，B拿1和3位置的牌
        for(int i=0;i<2;i++){
            for(int j=0;j<2;j++){
                System.out.println("玩家："+playerList.get(j).name+"-拿牌");
                //取牌的位置i*2+j：确保A拿List中0和2位置的牌，B拿1和3位置的牌
                getPoker=pokerListAfterShuffle.get(i*2+j);
                //Player类中定义了玩家的手牌属性pokers,将取到的牌放到玩家各自的手牌属性pokers中，这样就不用单独定义List来存放每个玩家取到的手牌。
                playerList.get(j).pokers.add(getPoker);

            }   
        }
        System.out.println("----------发牌结束----------"); 
        System.out.println("----------开始游戏----------");
        System.out.println("玩家各自的手牌为：");
        //for循环输入每个玩家取到的牌，playerList.get(n).pokers表示第n个玩家取到牌的集合，因为Player类中定义了玩家的手牌属性pokers
        for(int n=0;n<2;n++){
            System.out.print(playerList.get(n).name+":");
            for(int m=0;m<2;m++){
                System.out.print(playerList.get(n).pokers.get(m).color+playerList.get(n).pokers.get(m).point+",");
            }
        }

        //重新对每个玩家的手牌集合进行排序，利用每张扑克在pokerList中的索引位置，因为扑克pokerList是按从小到大生成的，已重写Poker类的equals()方法
        Collections.sort(playerList.get(0).pokers,new TestPoker());
        Collections.sort(playerList.get(1).pokers,new TestPoker());

        //打印每个玩家最大的牌
        for(int k=0;k<2;k++){
            System.out.println("\n玩家："+playerList.get(k).name+"最大手牌为："+playerList.get(k).pokers.get(1).color+playerList.get(k).pokers.get(1).point+",");
        }

        //比较每个玩家最大的牌，还是利用在扑克pokerList中的索引位置，利用List的indexOf()方法，已重写Poker类的equals()方法
        if(pokerList.indexOf(playerList.get(0).pokers.get(1))>pokerList.indexOf(playerList.get(1).pokers.get(1))){
            System.out.println("玩家："+playerList.get(0).name+"获胜");
            }else{
            System.out.println("玩家："+playerList.get(1).name+"获胜");
        }

        }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        TestPoker tp=new TestPoker();
        tp.creatPokerAndShuffle();
        tp.creatPlayer();
        tp.sendPokerAndPaly();
    }

}