第1个练习面向对象设计

第1次练习的记录

效果图1

效果图2

总结

  1 package first;
  2 
  3 import java.text.DecimalFormat;
  4 import java.text.NumberFormat;
  5 import java.util.ArrayList;
  6 import java.util.Scanner;
  7 
  8 public class ygopro {        //主程序
  9     public static void main(String[] args) {
 10         System.out.println("《游戏王怪兽卡大乱斗》比赛，比赛开始！！！");
 11         AP ap = new AP();
 12         xh xianhou = new xh();
 13         BiPin bp = new BiPin();                
 14         ArrayList<Card> ai = new ArrayList<Card>();    
 15         ai = ap.aiSelectCare();                    //电脑选择卡组
 16         
 17         ArrayList<Card> p = new ArrayList<Card>();        
 18         System.out.println("数字1(自然卡组),数字2(高攻卡组),数字3(卡通卡组)");
 19         Scanner sp = new Scanner(System.in);
 20         int spselectCard = sp.nextInt();
 21         p = ap.selectCard(spselectCard);        //玩家选择卡组
 22         
 23         ap.diedai(p);                             //显示卡组信息
 24         System.out.println(" ");
 25         
 26         int playerS = 0;                         //用来存储玩家猜拳游戏的值
 27         int aic = 0;
 28         do{    
 29             playerS = ap.caiquanyouxi();        //猜拳游戏时，玩家输入的值，检测有无异常    
 30             int aiS = ap.APrandom5(3);            //电脑获得的值0、1、2
 31             aic = aiS + 1;                        //电脑获得的值1、2、3
 32             int aiSShow = aiS+1;                
 33             System.out.println(aiSShow);        //显示电脑获得的的值
 34             bp.caiquan(playerS, aic);            //进行猜拳方法,会导致猜拳计分+1
 35             
 36             if(playerS ==aic) {
 37                 System.out.println("平局，需要再次猜拳");
 38             }
 39         } while(playerS == aic);                //经过do-while循环后,必出一个猜拳胜者
 40         
 41         int pp = 0 ;                             //玩家抽到的怪兽攻击力
 42         int pa = 0;                                 //电脑抽到的怪兽攻击力
 43         int wxn = 0;                             //无限对局的局数n
 44         int nn = 0;                                //无限对局中卡组卡片剩余数量,循环中另有赋值
 45         
 46         do {                                    //直接进行无限对局,直到某一方率先获得2分
 47             ap.newn++;
 48             
 49             try{        //此处应该有个延时会更好? 延时3秒
 50                 Thread.sleep(3000);
 51             } catch (InterruptedException ex) {
 52                 ex.printStackTrace();
 53             }
 54             
 55             System.out.println("======================第"+ ap.newn +"局开始了======================");
 56                 
 57             wxn ++;                                //do-while每循环一次,wxn就加1,初始为0
 58             if(bp.BPX ==1)    {                    //玩家先抽卡        
 59                 nn = 5 - wxn;    
 60                 if(nn==0){
 61                     System.out.println("没有卡可以抽了");
 62                     System.exit(0);
 63                 }
 64                     
 65                 p = xianhou.player(p);            //玩家抽卡
 66                 pp = xianhou.ppshow();
 67                     
 68                 ai = xianhou.ai(ai);
 69                 pa = xianhou.pashow();
 70                 
 71                 bp.bipin(pa, pp);                //玩家先抽卡,电脑后抽卡时,比拼攻击力
 72                 System.out.println("这场比赛的比分，现在是玩家vs电脑" + 
 73                 bp.BPPWIN +":" + bp.BPAWIN);
 74                     
 75             } else if(bp.BPA ==1) {                //当电脑猜拳游戏胜利时
 76                 nn = 5 - wxn;    
 77                 if(nn==0){
 78                     System.out.println("没有卡可以抽了");
 79                     System.exit(0);
 80                 }
 81                     
 82                 ai = xianhou.ai(ai);            //电脑先抽卡
 83                 pa = xianhou.pashow();
 84                     
 85                 p = xianhou.player(p);            //玩家后抽卡    
 86                 pp = xianhou.ppshow();
 87                     
 88                 bp.bipin(pa, pp);                //电脑先抽卡,玩家后抽卡,比拼攻击力
 89                 System.out.println("这场比赛的比分，现在是玩家vs电脑" + 
 90                 bp.BPPWIN +":" + bp.BPAWIN);
 91             } //if-else的else 结束括号
 92         } while (bp.BPAWIN < 2 & bp.BPPWIN <2);    //如果哪一方都没有率先获得2分,就无限对局
 93             
 94         NumberFormat jj = new DecimalFormat("¥###,####");    //设置奖金显示的格式
 95         String  y= jj.format(10000000);                
 96         System.out.println("赢家将得到" + y);
 97         bp.shuying(bp.BPPWIN,bp.BPAWIN);        //判定这场比赛最终的胜利者
 98 
 99     }//main方法的结束括号
100 }

主程序

 1 package first;
 2 
 3 public class Card {
 4     private String name;
 5     private int atk;
 6 
 7     public Card() {                                    //无参构造
 8         super();
 9     }
10 
11     public Card(String name, int atk) {                //有参构造
12         super();
13         this.name = name;
14         this.atk = atk;
15     }
16 
17     public String getName() {                        //Name的get和set方法
18         return name;
19     }
20 
21     public void setName(String name) {
22         this.name = name;
23     }
24 
25     public int getAtk() {                            //atk的get和set方法
26         return atk;
27     }
28 
29     public void setAtk(int atk) {
30         this.atk = atk;
31     }
32     
33     @Override
34     public String toString() {                        //toString方法
35         return "Card [name=" + name + ", atk=" + atk + "]";
36     }
37 }

Card类

面向过程到面向对象的转换

 1 package first;
 2 
 3 import java.util.ArrayList;
 4 
 5 public class xh {
 6     static int pp = 0;            //玩家怪兽攻击力
 7     static int pa = 0;            //电脑怪兽攻击力
 8     
 9     static int nnnp =5;            //每次调用player方法,即玩家抽卡,nnnp自减1
10     static int nnna =5;
11     
12     public ArrayList<Card> player(ArrayList<Card>p) {
13         AP ap = new AP();
14         nnnp--;
15         int pn = nnnp;
16         if(pn < 0) {
17             System.exit(0);
18         }
19         int p1r = ap.APrandom5(pn);            //第一次猜拳游戏中,让玩家先抽卡,电脑再抽
20         int pshow = p1r + 1;        
21         String pN1 = p.get(p1r).getName();    
22         pp = p.get(p1r).getAtk();
23         ap.Pshowprint(pshow, pN1, pp);    
24         p.remove(p1r);                        //返回索引值,玩家卡组删除掉抽到的那张卡
25         return p;
26     }
27     
28     public ArrayList<Card> ai(ArrayList<Card>ai) {
29         AP ap = new AP();
30         nnna --;
31         int an = nnna;
32         if(an < 0) {
33             System.exit(0);
34         }
35         int air1 = ap.APrandom5(an) ;        //第一次猜拳中,电脑在玩家后面抽卡        
36         int airshow = air1 + 1;                        
37         String aiN1 = ai.get(air1).getName();   
38         pa = ai.get(air1).getAtk();            
39         ap.Ashowprint(airshow,aiN1, pa);
40         ai.remove(air1);                    //电脑卡组删除掉抽到的那张卡
41         return ai;
42     }
43     
44     public int ppshow() {    //每次抽卡时,玩家怪兽的攻击力.pp是静态变量,由抽卡时抽到值赋值而来
45         int p = this.pp;
46         return p;
47     }
48     
49     public int pashow() {    //电脑怪兽攻击力值
50         int a = this.pa;
51         return a;
52     }
53 }

抽取的相同的方法

  1 package first;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Iterator;
  5 import java.util.Random;
  6 import java.util.Scanner;
  7 
  8 public class AP {        //尽可能的将主方法中的代码写成方法，存放在这里    
  9     static int newn = 0;
 10     
 11     public static int caiquanyouxi(){        //方法:  猜拳游戏玩家输入的检测有无异常
 12         System.out.println("猜拳决定，哪一方先抽卡。石头（1）剪刀（2）布（3）");
 13         int playerS = 0;//如果这个值是1-3这3个数以外的值,就是出现异常了.出现异常后如何捕获呢?
 14         int playerSN = 0; //在catch中声明的值,测试看看能不能使用catch中声明的scanner对象的值
 15         
 16         try {
 17             Scanner playerScanner = new Scanner(System.in);        
 18             playerS = playerScanner.nextInt();                //playerS是玩家输入的数值
 19             
 20             if(playerS !=1 & playerS !=2 & playerS!=3){        //准备抛出异常
 21                 throw new Exception();
 22             }
 23             
 24         } catch (Exception e) {        //抛出的异常跳转到这里    catch块中的对象,外面无法使用
 25             System.out.println("输入的数值只能是1,2,3这3个数值");
 26             System.out.println("由于输入错误的数值,程序运行出现异常");
 27             
 28             System.out.println("请输入符合规范的数值,否则程序将停止运行");    //再给一次机会
 29             Scanner playerScanner = new Scanner(System.in);        //再次获得用户输入的信息
 30             playerSN = playerScanner.nextInt();    
 31             
 32             try {
 33                 if(playerSN !=1 & playerSN !=2 & playerSN!=3){        
 34                     throw new Exception();
 35                 }
 36             } catch (Exception e1) {        //抛出的异常跳转到这里
 37                     System.out.println("输入的数值只能是1,2,3这3个数值");
 38                     System.out.println("由于再次输入错误的数值,程序运行出现异常,这次就会停止了,哈哈");
 39                     System.exit(0);
 40                     }    //第二次检测异常时catch的结束括号
 41         } //第一次检测异常时catch的结束括号
 42         
 43         if(playerSN != 0) {            //如果playerSN=0,说明之前的猜拳游戏时没有异常
 44             playerS = playerSN;        //playerSn是异常抛出,因为给了一次机会,所以出现第2次猜拳值
 45         }     //当猜拳的数值没有异常时,使用第一次猜拳数值,如果有异常则抛出
 46         return playerS;
 47     }
 48     
 49     
 50     
 51     public static void diedai(ArrayList<Card>p) {    //方法: 遍历集合p中的集合,显示卡组信息
 52         
 53     Iterator<Card> it = p.iterator();    // 返回一个迭代器
 54     System.out.printf("*卡组信息*\n");
 55        while (it.hasNext()) {
 56            Card s = it.next();         // 返回迭代器的下一个元素
 57 //           System.out.println(s.getName() +"\t"+"\t"+ s.getAtk());
 58            // \t作用,看前面内容满不满8位,不满就补充,满了就再输出8位
 59            //暗冥天魔 尼奥斯菲亚 .一个汉字是两个字符，一个空格是一个字符
 60            //9个字一个空格,共19位,如果补全的话,恰好多了一位
 61            String nmtm = s.getName();    //获得一张卡片的名称
 62            int x = nmtm.length();
 63            if(x <=4 ) {
 64            System.out.println(s.getName() +"\t"+"\t"+"\t"+ s.getAtk());
 65            } else if (x <=8 ){
 66                System.out.println(s.getName() +"\t"+"\t"+ s.getAtk());
 67            }else {
 68                System.out.println(s.getName() +"\t"+s.getAtk());
 69            }
 70        }
 71     }    
 72     
 73     public static ArrayList<Card> aiSelectCare() {        //方法: 电脑卡组
 74         ArrayList<Card> ai= new ArrayList<Card>();
 75         ai.add(new Card("黑魔法神官",3200));
 76         ai.add(new Card("黑魔术师",2500));
 77         ai.add(new Card("混沌巫师",2300));
 78         ai.add(new Card("黑魔导少女",2000));
 79         ai.add(new Card("熟练的黑魔术师",1900));
 80         return ai;
 81     }
 82     
 83     public static ArrayList<Card> selectCard (int x ) {        //方法: 玩家选择卡组
 84         ArrayList<Card> sc= new ArrayList<Card>();    //声明一个空的集合,用来存储switch中的选择
 85         switch (x) {    //x的值就是用户输入的选择卡组的值,1,2,3有3个卡组,其余值默认为3号卡组    
 86             case 1:            //当key=1时使用自然卡组
 87                 ArrayList<Card> p1 = new ArrayList<Card>();
 88                 p1.add(new Card("自然木龙兽",2800));
 89                 p1.add(new Card("自然木鳞龙",2500));
 90                 p1.add(new Card("自然地龟",2350));
 91                 p1.add(new Card("自然兽",2200));
 92                 p1.add(new Card("自然竹笋",2000));
 93                 sc = p1;
 94                 break;
 95             case 2:
 96                 ArrayList<Card> p2 = new ArrayList<Card>();
 97                 p2.add(new Card("降雷皇 哈蒙",4000));
 98                 p2.add(new Card("幻魔皇 拉比艾尔",4000));
 99                 p2.add(new Card("暗冥天魔 尼奥斯菲亚",4000));
100                 p2.add(new Card("神炎皇 乌利亚",0));
101                 p2.add(new Card("王立魔法图书馆",0));
102                 sc = p2;
103                 break;    
104             case 3:
105                 ArrayList<Card> p3 = new ArrayList<Card>();
106                 p3.add(new Card("青眼卡通龙",3000));
107                 p3.add(new Card("卡通恶魔",2500));
108                 p3.add(new Card("卡通蛋龙",2200));
109                 p3.add(new Card("卡通哥布林突击部队",2200));
110                 p3.add(new Card("卡通黑魔导少女",2000));
111                 sc = p3;
112                 break;
113             default:    //当case匹配失败的时,执行
114                 System.out.println("由于输入错误,默认使用卡通卡组");
115                 ArrayList<Card> p4 = new ArrayList<Card>();
116                 p4.add(new Card("青眼卡通龙",3000));
117                 p4.add(new Card("卡通恶魔",2500));
118                 p4.add(new Card("卡通蛋龙",2200));
119                 p4.add(new Card("卡通哥布林突击部队",2200));
120                 p4.add(new Card("卡通黑魔导少女",2000));
121                 sc = p4;
122                 
123                 break;    
124             }    //switch的结束括号
125         return sc;    //sc是选择好的卡组,怎么给返回? 
126     } //选择卡组的方法结束括号.return直接返回,方法返回值声明成ArrayList<Card>
127     
128     
129     public static int APrandom5(int n) {    //获取传入随机数,数量为传入的参数值
130         Random  random = new Random();            
131         int apr = random.nextInt(n) ;    
132         return apr;            
133     }
134     
135     public static void Ashowprint(int aishow,String aiN1,int aia1) {
136         System.out.println("电脑抽到了第" + aishow +"张卡，这张卡是："
137                 + aiN1 + " 攻击力是：" + aia1);
138     }
139     
140     public static void Pshowprint(int aishow,String aiN1,int aia1) {
141         System.out.println("玩家抽到了第" + aishow +"张卡，这张卡是："
142                 + aiN1 + " 攻击力是：" + aia1);
143     }
144 }

AP和玩家双方的行为

 1 package first;
 2 
 3 public class BiPin {    //所有和比较有关的方法都在这个类中
 4     public static int BPAWIN = 0;      //电脑胜利一局后加的分数    
 5     public static int BPPWIN = 0;
 6     public static int BPX = 0;        //猜拳计数器,猜拳胜利时,这个变量=1时,玩家先抽卡
 7     public static int BPA = 0;          //当变量变量=1时,电脑先抽卡
 8     
 9     static int a1a = 0;                //电脑先抽卡时,电脑怪兽的攻击力
10     static int a1p = 0;                //玩家后抽卡时,玩家怪兽的攻击力,玩家数组列表命名ap
11     
12     public int aia1ashow() {        //电脑先抽卡时,电脑的怪兽攻击力
13         int a = this.a1a;
14         return a;
15     }
16     
17     public int pa1ashow() {            
18         int p = this.a1p;
19         return p;
20     }
21     
22     public void bipin (int pa, int pp) {          //方法1:判断攻击力高低的方法            
23         if(pa > pp) {                            
24             System.out.println("电脑胜利");
25             this.BPAWIN ++;    
26         } else 
27             if(pa < pp) {
28             System.out.println("玩家胜利");
29             this.BPPWIN ++;        
30         } else{
31             System.out.println("攻击力相同，平局");
32         }
33     }
34     
35     public static void shuying(int BPPWIN ,int BPAWIN) {         //方法2:判定比赛胜负的方法
36         if(BPAWIN >= 2){    //BPAWIN是电脑的比分,
37             System.out.println("电脑率先获得2局胜利，赢下这场比赛");
38             System.out.println("《游戏王怪兽卡大乱斗》的获得者是：电脑");
39         } else 
40             if(BPPWIN >= 2){
41             System.out.println("玩家率先获得2局胜利，赢下这场比赛");
42             
43             System.out.println("《游戏王怪兽卡大乱斗》的获得者是：玩家");
44         } else {
45             System.out.println("下面开始无限对局");
46         }
47     }
48     
49     public static void caiquan (int playerS ,int aic) {        //方法3:猜拳的胜负判断
50         int aia1 = 0;
51         int pa1 = 0;
52         
53         if(playerS == 1 & aic ==2 | playerS ==2 & aic ==3 | playerS ==3 & aic ==1){
54             System.out.println("玩家先抽卡");
55             BPX = BPX + 1;
56         } else if (aic == 1 & playerS==2 | aic ==2 & playerS ==3 | aic ==3 & playerS==1){ 
57             System.out.println("电脑先抽卡");
58             BPA = BPA + 1;
59         }
60     }
61     
62     public static void Ashowprint(int aishow,String aiN1,int aia1) {
63         System.out.println("电脑抽到了第" + aishow +"张卡，这张卡是："
64                 + aiN1 + " 攻击力是：" + aia1);
65     }
66     
67     public static void Pshowprint(int aishow,String aiN1,int aia1) {
68         System.out.println("玩家抽到了第" + aishow +"张卡，这张卡是："
69                 + aiN1 + " 攻击力是：" + aia1);
70     }
71 }