.      用面向对象的思想实现如下的骰子游戏：
      丢下两个骰子，若分值的总值为7点，则赢；否则输。

       对 面向对象思想的理解不透彻，多多谅解。 希望有答案。

http://zhidao.baidu.com/question/161443213.html

package cn.itzero;

public class Play {

        /**
         * @param args
         */
        public static void main(String[] args) {

                Deic a=new Deic();//定义a.b色子
                Deic b=new Deic();
                if(a.getNum()+b.getNum()==7){
                        System.out.println("win");
                }else{
                        System.out.println("lose");
                }
        }
}
class Deic{
        private int num;
        public Deic(){
                num=(int) (Math.random()*6+1);//获取随机数
        }
        public int getNum() {
                return num;
        }
       
}
你看看，像这样就行了

1. class Test1{
   
2. 
   
3.         public static void main(String[] args){
   
4.                
   
5.                  Die die1 = new Die();
   
6.                  Die die2 = new Die();
   
7.                  
   
8.                  int sum = play(die1,die2);
   
9.                  
   
10.                  if(sum == 7)
    
11.                          System.out.println("win");
    
12.                  else
    
13.                          System.out.println("lost");
    
14.                  
    
15.         }
    
16. 
    
17.         public static int play(Die die1,Die die2) {
    
18.                 int sum = die1.getFaceValue() + die2.getFaceValue();
    
19.                 return sum;
    
20.         }
    
21. }
    
22. 
    
23. class Die {
    
24.        
    
25.         private int faceValue;
    
26.        
    
27.         public int getFaceValue() {
    
28.                 int number = this.roll();
    
29.                 return number;
    
30.         }
    
31.        
    
32.         private int roll() {
    
33.                 int a = 0;
    
34.                 while(true)        {
    
35.                         a = (int) (Math.random()*10);
    
36.                         if(a>0 && a<7) {            //只有在1-6点间才能返回值
    
37.                                 break;
    
38.                         }
    
39.                 }
    
40.                 return a;
    
41.         }
    
42. }

复制代码

写的不好，见谅啊

1. import java.util.Random;
   
2. 
   
3. 
   
4. public class ThrowDice {
   
5.         public static void main(String[] args) {
   
6.                 Dice dice1 = new Dice(1, 2, 3, 4, 5, 6);
   
7.                 Dice dice2 = new Dice(1, 2, 3, 4, 5, 6);
   
8.                 while(true) {
   
9.                         if(getSum(dice1, dice2) == 7) {
   
10.                                 System.out.println("你赢了");
    
11.                                 break;
    
12.                         } else {
    
13.                                 System.out.println("你输了");
    
14.                         }
    
15.                 }
    
16.         }
    
17.         public static int getSum(Dice dice1, Dice dice2){
    
18.                 int i = dice1.throwDice();
    
19.                 int j = dice1.throwDice();
    
20.                 return i + j;
    
21.         }
    
22.        
    
23. }
    
24. 
    
25. 
    
26. class Dice {                //定义一个类，代表骰子
    
27.         public static final Random r = new Random();                //定义一个随机数产生器，将其声明为常量
    
28.         private int suface1;                //定义6个成员变量，代表骰子上的每一个面的点数
    
29.         private int suface2;
    
30.         private int suface3;
    
31.         private int suface4;
    
32.         private int suface5;
    
33.         private int suface6;
    
34.         public Dice(int suface1, int suface2, int suface3, int suface4,
    
35.                         int suface5, int suface6) {                //这个构造方法代表你要创造的骰子每个面对应的点数，貌似有点多余
    
36.                 super();
    
37.                 this.suface1 = suface1;
    
38.                 this.suface2 = suface2;
    
39.                 this.suface3 = suface3;
    
40.                 this.suface4 = suface4;
    
41.                 this.suface5 = suface5;
    
42.                 this.suface6 = suface6;
    
43.         }
    
44.         public int throwDice() {                //定义一个方法，扔骰子
    
45.                 return r.nextInt(6) + 1;
    
46.         }
    
47. }

复制代码

游戏类：该类用于根据玩家的点数来输出结果
玩家类：有一个掷骰子的方法，该方法返回一个随机数。