import java.util.Random;

//5.用用面向对象的思想实现如下的骰子游戏：丢下两个骰子，若分值的总值为7点，则赢；否则输。public class Test4 {
        public static void main(String[] args){
                DiceGame c=new DiceGame();
                c.play();
                Die d=new Die();
                d.roll();
                Random r=new Random();
                int a=r.nextInt(6)+1;
                int b=r.nextInt(6)+1;
                System.out.println(a+"    "+b);
                d.getFaceValue(a,b);
        }
}
class DiceGame{
        int Die1;
        int Die2;
         void play(){
                System.out.println("开始啦");
        }
}
class Die{
        int faceValue;
         static void roll(){
                 System.out.println("请投掷骰子");
        }
        static void getFaceValue(int a,int b){
                int faceValue=a+b;
                if(faceValue==7){
                        System.out.println("您赢啦");       
                }else{
                System.out.println("很抱歉，您输了");}
        }
}//用面向的思维应该怎样改写该代码.

你要想万物皆对象。把掷骰子游戏看成一个对象，它有开始、判断输赢等功能。
这里是我的一点拙见。。因为我也是刚开始学的。
代码如下，主要是用到了面向对象的封装性。

1. import java.util.Random;
   
2. public class Test4 {
   
3.     public static void main(String[] args){
   
4.                 Game g= new Game();   //创建了一个Game类的对象g
   
5.                 g.play();
   
6.                 g.roll();
   
7.                 int a =g.random();
   
8.                 int b = g.random();
   
9.                 System.out.println(a+"    "+b);
   
10.                 g.getFaceValue(a,b);
    
11.         }
    
12. }
    
13. class Game{
    
14.         void play()
    
15.         {
    
16.                 System.out.println("Start!");
    
17.         }
    
18.         void roll(){
    
19.         System.out.println("请投掷骰子");
    
20.         }
    
21.         int random(){
    
22.                 Random r = new Random();
    
23.                 return r.nextInt(6)+1;
    
24.         }
    
25.         void getFaceValue(int a,int b){
    
26.         int faceValue=a+b;
    
27.         if(faceValue==7)
    
28.             System.out.println("您赢啦");        
    
29.                 else
    
30.                         System.out.println("很抱歉，您输了");
    
31.         }
    
32. }

复制代码

以下是我的想法，分离出两个对象，一个是游戏窗口本身对象，另一个是骰子对象，两者是组合关系。因为游戏中我们可以更换骰子，因此从面对象来考虑，两者互为组合关系。
以下是我的代码设计：

1. public class DiceGame {
   
2.         private Dice dice1;
   
3.         private Dice dice2;
   
4. 
   
5.         public DiceGame(Dice dice1, Dice dice2) {
   
6.                 this.dice1 = dice1;
   
7.                 this.dice2 = dice2;
   
8.         }
   
9. 
   
10.         // 更换骰子（比如骰子在游戏中找不到，需要更换一个）
    
11.         public void setDice1(Dice dice1) {
    
12.                 this.dice1 = dice1;
    
13.         }
    
14. 
    
15.         public void setDice2(Dice dice2) {
    
16.                 this.dice2 = dice2;
    
17.         }
    
18. 
    
19.         public void gameStar() {
    
20.                 System.out.println("游戏开始,掷下两个骰子");
    
21.                 dice1.roll();
    
22.                 dice2.roll();
    
23.                 System.out.println("两个骰子的值分别为：" + dice1.getFaceValue() + "、"
    
24.                                 + dice2.getFaceValue());
    
25.                 int value = dice1.getFaceValue() + dice2.getFaceValue();
    
26.                 if (value == 7)
    
27.                         System.out.println("您赢啦");
    
28.                 else
    
29.                         System.out.println("很抱歉，您输了");
    
30.         }
    
31. 
    
32.         public static void main(String[] args) {
    
33.                 Dice dice1 = new Dice();
    
34.                 Dice dice2 = new Dice();
    
35.                 DiceGame game = new DiceGame(dice1, dice2);
    
36.                 game.gameStar();
    
37.                 System.out.println("骰子1掉下水道去了（可能是马路上玩的）");
    
38.                 Dice dice3 = new Dice();// 拿来一个新骰子
    
39.                 game.setDice1(dice3);// 在游戏中使用新骰子
    
40.                 // 游戏再次开始
    
41.                 game.gameStar();
    
42.         }
    
43. 
    
44. }

复制代码

1. package cn.zuhe;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. // 骰子对象
   
6. public class Dice {
   
7.         private int faceValue = 1;// 筛子的值
   
8.         Random r = new Random();
   
9. 
   
10.         // 获取骰子的值
    
11.         public int getFaceValue() {
    
12.                 return faceValue;
    
13.         }
    
14. 
    
15.         // 掷骰子的方法
    
16.         public void roll() {
    
17.                 faceValue = r.nextInt(6) + 1;
    
18.         }
    
19. }

复制代码