Question

我写了一个模拟纸牌游戏的程序。我为卡片的颜色选择了一些值，并为卡片的值选择了一些值。

我写了自己的例外，CarteException.java有两个孩子，CarteValeurException.java和CarteCouleurException.java，具体取决于Carte初始化时的异常类型

如果颜色的值不是1或4，那将抛出CarteCouleurExeception.java的异常，并且对于另一个异常则相同，如果值不是1或者在7和13中，那将是扔一个CarteValeurException.java

这是我的课程Carte.java的代码：

public Carte(int coul, int val) throws CarteException {
    if(coul < 1 || coul > 4) {
        throw new CarteCouleurException("Erreur d'initialisation lors de la création d'une carte.",coul);
    }
    if(val < 1 || (val > 1 && val < 7) || val > 13) {
        throw new CarteValeurException("Erreur d'initialisation lors de la création d'une carte.",val);
    }
    this.couleur = coul;
    this.valeur = val;
}

这是类CarteException.java的代码：

public class CarteException extends Exception {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    protected String message;

    protected CarteException() {
        this.message = "";
    }

    public CarteException(String chaine) {
        this.message = chaine;
    }

    public String getMessage() {
        return (this.message + " : Erreur non spécifiée de valeur ou de couleur de carte.");
    }
}

最后，在Belote.java中初始化卡片：

package TP.TP6.Exercice2;

import java.util.Random;
import java.util.Vector;
import java.util.Stack;

import TP.TP5.Exercice1.Question4.Carte;

public class Belote {
    private Stack<Carte> tasDistibution;
    private Vector<Stack<Carte>> mainsJoueurs;
    private Vector<Stack<Carte>> plisJoueurs;

    public Belote() {
        this.tasDistibution = new Stack<Carte>();
        this.mainsJoueurs = new Vector<Stack<Carte>>(4);
        this.plisJoueurs = new Vector<Stack<Carte>>(4);

        for(int i = 0 ; i < 4 ; i++) {
            this.mainsJoueurs.add(i, new Stack<Carte>());
            this.plisJoueurs.add(i, new Stack<Carte>());
        }

    }

    private void initialiserTasDistribution() throws CarteException {
        for (int i = 0; i <= 5; i++) {
            for (int j = 1; j <= 13; j++) {
                try {

                    //Initialisation right here

                    this.tasDistibution.push(new Carte(i,j));
                }
                catch(CarteException CE) {
                    System.err.println("Erreur : " + CE);
                }
            }
        }
    }

    private void couper() {
        Stack<Carte> tas1 = new Stack<Carte>();
        Stack<Carte> tas2 = new Stack<Carte>();

        Random r = new Random();
        int coupe = 1 + r.nextInt(33 - 1);

        for (int i = 0; i < coupe; i++) {
            Carte carte = this.tasDistibution.peek();
            this.tasDistibution.pop();
            tas1.push(carte);
        }

        while (tasDistibution.isEmpty() == false) {
            Carte carte = this.tasDistibution.peek();
            this.tasDistibution.pop();
            tas2.push(carte);
        }

        while (tas1.isEmpty() == false) {
            Carte carte = tas1.peek();
            tas1.pop();
            this.tasDistibution.push(carte);
        }

        while (tas2.isEmpty() == false) {
            Carte carte = tas2.peek();
            tas2.pop();
            this.tasDistibution.push(carte);
        }
    }

    private void melanger(int nbMelange) {
        Carte tabcarte[] = new Carte[32];

        for (int i = 0; i < tabcarte.length; i++) {
            Carte cartesommet = this.tasDistibution.peek();
            this.tasDistibution.pop();
            tabcarte[i] = cartesommet;
        }

        for (int i = 0; i < nbMelange; i++) {
            Random r = new Random();
            int pos1 = 1 + r.nextInt(32 - 1);
            int pos2 = 1 + r.nextInt(32 - 1);

            if (pos1 == pos2) {
                System.out.println("Pas de chance");
            } else {
                Carte temp;
                temp = tabcarte[pos1];
                tabcarte[pos1] = tabcarte[pos2];
                tabcarte[pos2] = temp;
            }
        }

        for (int i = 0; i < tabcarte.length; i++) {
            Carte carte = tabcarte[i];
            this.tasDistibution.push(carte);
        }
    }

    private void donnerCartesAJoueur(int nbcartedonnes, int numjoueur) {
        for (int i = 0; i < nbcartedonnes; i++) {
            Carte carte = this.tasDistibution.peek();
            this.tasDistibution.pop();
            Stack<Carte> stack = this.mainsJoueurs.get(numjoueur);
            stack.push(carte);
            this.mainsJoueurs.set(numjoueur, stack);
        }
    }

    private void distribuer() {
        for (int i = 0; i < 4; i++) {
            this.donnerCartesAJoueur(3, i);
        } 

        for (int i = 0; i < 4; i++) {
            this.donnerCartesAJoueur(2, i);
        }

        for (int i = 0; i < 4; i++) {
            this.donnerCartesAJoueur(3, i);
        }


        for (int i = 0; i < 4; i++) {
            System.out.println("\n\nDistribution pour joueur : " + (i+1) + " \n\nMain du joueur : " + (i+1));
            System.out.println(this.mainsJoueurs.get(i).toString());
        }
    }

    private void assemblerPlisJoueur() {
        for (int i = 0; i < 4; i++) {
            while (this.plisJoueurs.get(i).isEmpty() == false) {
                Carte carte = this.plisJoueurs.get(i).peek();
                Stack<Carte> stack = this.plisJoueurs.get(i);
                stack.pop();
                this.plisJoueurs.set(i, stack);
                this.tasDistibution.push(carte);
            }
        }
    }

    private void preparerPremiereManche() throws CarteException {
        try {
            this.initialiserTasDistribution();
        }
        catch(CarteException CE) {
            System.err.println("Erreur d'initilisation du tas à distribuer.");
            throw CE;
        }
        this.melanger(32);
        this.couper();
        this.distribuer();
    }

    private void preparerMancheSuivante() {
        this.assemblerPlisJoueur();
        this.couper();
        this.distribuer();
    }

    private void jouerPli() {
        Stack<Carte> tasIntermediaire = new Stack<Carte>();

        for (int i = 0; i < 4; i++) {
            Carte carte = this.mainsJoueurs.get(i).peek();
            Stack<Carte> stack = this.mainsJoueurs.get(i);
            stack.pop();
            this.mainsJoueurs.set(i, stack);
            tasIntermediaire.push(carte);
        }

        Random r = new Random();
        int gagnant = 0 + r.nextInt(4 - 0);
        System.out.println("Le joueur " + (gagnant+1) + " a gagné ce pli");

        for (int i = 0; i < 4; i++) {
            Carte carte = tasIntermediaire.peek();
            tasIntermediaire.pop();
            Stack<Carte> stack = this.plisJoueurs.get(gagnant);
            stack.push(carte);
            this.plisJoueurs.set(gagnant, stack);
        }
        System.out.println("Pli du joueur " + (gagnant+1));
        System.out.println(this.plisJoueurs.get(gagnant).toString());
    }

    private void jouerManche(int nbPlis) {
        for (int i = 1; i <= nbPlis; i++) {
            System.out.println("\n\nPli numéro : " + i);
            this.jouerPli();
        }
        this.preparerMancheSuivante();
    }

    public void jouerPartie(int nbManches) throws CarteException {
        try {
            this.preparerPremiereManche();
        }
        catch(CarteException CE) {
            System.err.println("Erreur d'initialisation de la première manche");
            throw CE;
        }
        for (int i = 1; i <= nbManches; i++) {
            System.out.println("\n\nManche numéro : " + i);
            this.jouerManche(8);
        }
        System.out.println("Jeu terminé");
    }
}

问题出在Belote.java，Eclipse在这里向我发送了一个错误catch(CarteException CE)：

CarteException的无法访问的catch块。永远不会从try语句主体

抛出此异常

但是我在第一节中放右：public Carte(int coul, int val) throws CarteException所以不明白这个问题。

我写了课程CarteValeurException.java和CarteCouleurException.java，但实际上与CarteException.java相同，所以我不会把这个类的代码放在这里。

感谢您的帮助！

Answer 1

你必须抛出或抓住你的例外。

您的方法的签名是：

private void initialiserTasDistribution() throws CarteException

因此，当您从方法中重新抛出Carte中的构造函数的异常时。因此，捕获无法到达。您必须为代码选择最佳方法。这里有一套经验法则：Throws or try+catch

Answer 2

您的问题是声明您的方法在调用堆栈的上方传播异常：

private void initialiserTasDistribution() throws CarteException {

这意味着调用方法initialiserTasDistribution的人将不得不处理此异常（或者执行相同操作并将其传播得更高）。这是一种推迟责任的形式。它说＆＃34;我不会处理这个错误，其他人可以＆＃34;。

这直接与您的方法的实现相矛盾，因为执行实际上处理了错误。

try {
    this.tasDistibution.push(new Carte(i,j));
}
catch(CarteException CE) {
    System.err.println("Erreur : " + CE);
}

如果您更改方法签名以删除throws声明，那么您应该没问题：

private void initialiserTasDistribution() {

我自己的例外不起作用

2 个答案: