Java团队项目总结

Java团队项目总结

1.项目实现情况

  • 项目概述：

    我们团队项目准备实现一个有关于大富翁有的游戏程序。

    大富翁游戏，以经营权为主要的游戏方式，通过购买经营权与架构经营的星级服务来获得最大的利益，当其他玩家破产后，最后一个玩家取得胜利来结束游戏。在百度词条上示意为，默认多幅地图，以掷骰点数前进，并有多种道具、卡片使用，另外触发一些“特别事件”。主要通过购买房产，收取对方的路费、租金来导致对手的破产。

  • 项目预期：

    鉴于对java学习的程度和掌握内容，基本实现大富翁的游戏内容我们的项目打算实现以下目标。

    • 按照计划，首先需要列出我们要实现的特殊卡牌功能card，其中有BarricadeCard、BlackCard、DemolitionCard、EqualizedWealthCard、FortuneGodCard、LandCard、LotteryCard 、MonsterCard、PlunderCard、PurchaseCard、RedCard、 RemoteDiceCard、RetentionCard、TaxInspectionCard、TortoiseCardTurnCard、WealthGodCard同时需要一个CardSystem用来管理所有设计的Card类。
    • 其次设计大富翁游戏里的杂项功能，比如角色的数量，时间等，就需要一下class文件Date、Entrance、MenuPrint、Player、Stock等，比如Date就用来实现大富翁游戏中日期的计数，Entrance实现整个大富翁游戏的入口，MenuPrint就用来实现游戏中每一步之后显示的菜单选项，Player就用来实现游戏的参与游戏的数量，Stock用来返回各项菜单。
    • 最后需要设计大富翁游戏的重要的场景，例如医院、彩票站等。Bank、Blank、CardGet、CardShop、Hospita、Hous、Land、Landindex、LottteryStation、News、Park、Piont、PoliceStation
  • 项目结果（总项目列表）：
    • Card类：
    • PJ类：
    • Place类：

2.项目测试

  • 项目分析：

    因为所要完成总任务的大项都是由小项合并起来完成的。一下举出几个例子。本次博客也是郝昊主要写作其余队员合作完成的。

  • LotteryStation（彩票站）：
    • 程序代码：

      package place;

import java.util.Scanner;

import PJ.Entrance;
import PJ.Player;

public class LotteryStation extends  Land {
LotteryStation(int x, int y,String name) {
    this.i = x;
    this.j = y;
    this.name=name;
}
            @Override
        public char getchart() {
            return ‘彩‘;
            // TODO Auto-generated method stub
        }
        public  void printInformation(int step) {
    System.out.println("这里是彩票站~~");
// TODO Auto-generated method stub

    }
@Override
public void printaction(int step,int namei){
    Player player=new Player();
for(int i=0;i<Entrance.players.size();i++){
if(Entrance.players.get(i).getNamei()==namei){
    player=Entrance.players.get(i);
}
}
System.out.println("这里是彩票站，选购彩票将花费您1000元，"+"\n"+"是请输入y，不是请输入n");
Scanner input=new Scanner(System.in);
String answer=input.next();
while(true){
if(answer.equals("y")){
if(player.getCash()>=1000){
int i=(int)(Math.random()*5+1);
if(i==3){
    System.out.println("恭喜您中奖了！获得奖励5000元");
    player.setCash(player.getCash()+4000);
}else{
    System.out.println("很遗憾，您差点中奖，继续购买请输入y，离开请输入n");
    player.setCash(player.getCash()-1000);
    answer=input.next();
}
}else{
System.out.println("您的现金不足，彩票不支持刷卡");
break;
}
}else if(answer.equals("n")){
    System.out.println("真是遗憾，下次再来碰碰运气吧");
break;
}else{
System.out.println("不好意思，是不是输入错误了啊！");
answer=input.next();
}
}
}
public char getinitialchart() {
return ‘彩‘;
// TODO Auto-generated method stub
}

}
    • 代码分析：

      首先关于彩票站是属于Place里的一项，为了实现游戏中玩家使相互对方破产的功能。

      其次代码在编写的时不仅需要import java.util.Scanner;用来输入数据，还需要和杂项文件PJ中的Entrance和Player的数据联系起来。使用import PJ.Entrance;和import PJ.Player;。

      再次在这个彩票站的主函数中需要继承Land函数，Land函数是整个游戏地图的总揽，当前进到彩票站的环节，就需要继承Land。

      注意，因为继承了父类，所以在子类编写的时候加上@Overrid编译器会验证下面的方法是否是父类中所有的，如果没有则报错。这样会方便代码的书写和编译。

      彩票站的主要功能是购买彩票，验证是否中奖，或者选择离开等功能。我们在这里的金额计算采用差额计算法，即第一次购买彩票和之后的结果进行计算，比如购买彩票需要1000，中奖5000，在中奖下面用代码player.getCash()+4000来表示，将奖金中的一部分金额用来计算为购买彩票的金额。

      在编译的时候就要注意到在彩票站会有很多中情况，例如购买彩票的中奖与不中奖、选择继续还是不继续购买彩票、在购买的时候金额会不会足够、在输入时候格式会不会有问题，需要注意很多的细节问题。

    • 代码测试结果：
    • 显示出输入错误信息，未中奖信息，中奖信息等。
  • Player：
    • 程序代码：

      package PJ;

import java.util.ArrayList;
import java.util.Scanner;

import place.Landindex;
import card.CardSystem;

public class Player {
private double deposit ;
private double cash;
private int Point;
private int housequantity;
private int step;
private double houseValue;
private int direction =1;
private int location=(int)(Math.random()*67+1);
private String name ;
private int namei;
private String direct ;
private int special=0;//=0时正常，=1-6时使用了遥控骰子，=7时处于滞留卡状态，=8时处于乌龟卡状态，=9-16时处于福神保佑状态，=17-24时处于财神保佑状态
private int[] cards=new int[17];
private int[] stocks=new int[10];
Player(double deposit,double cash,int point,int housequantity,int housevalue,int direction,String name,int namei,int special){
this.deposit=deposit;
this.cash=cash;
this.Point=point;
this.housequantity=housequantity;
this.houseValue=housevalue;
this.direction=direction;
this.name=name;
this.special=special;
this.namei=namei;
for(int i=0;i<=16;i++){
cards[i]=1;
    }
    }
public Player() {
// TODO Auto-generated constructor stub
}
public void move(){
    if (deposit + cash > 0){
    if(direction==1){
    direct="顺时针";
    }else{
        direct="逆时针";
    }
    System.out.println("现在是玩家"+name+"的回合，您的前进方向是"+direct+"。");
    if(Date.day==1){
    System.out.println("又到了月初，您的存款已在月末获得了10%的利息");
        this.deposit=deposit*1.1;
    }
    System.out.println("您现在可以进行如下操作：");
MenuPrint.print1();
Scanner input = new Scanner(System.in);
    int digitalInput = input.nextInt();
    while (true) {
    if (digitalInput >= 0 && digitalInput <= 8)
    break;
else {
    System.out.print("invalid input, please enter again :");
    digitalInput = input.nextInt();
    }
    }
    while (digitalInput != 6 && digitalInput != 7) {
    switch (digitalInput) {
case 0:
    MenuPrint.printmap();
    System.out.println("还有什么要看的");
    MenuPrint.print1();
    digitalInput = input.nextInt();
    break;
case 1:
    MenuPrint.printinitialmap();
    System.out.println("还有什么要看的");
    MenuPrint.print1();
    digitalInput = input.nextInt();
    break;
case 2:
    System.out.println("名称"+"\t\t\t\t"+"功能"+"\t\t"+"类型"+"\t\t"+"价格"+"\t\t"+"适用范围"+"\t\t"+"剩余数量");
    for(int i=0;i<=16;i++){
        System.out.println(i+":"+CardSystem.cardsystem[i].getName()+"\t\t"+CardSystem.cardsystem[i].getFunction()+"\t\t"+CardSystem.cardsystem[i].getType()+"\t\t"+CardSystem.cardsystem[i].getPoint()+"\t\t"+CardSystem.cardsystem[i].getRange()+"\t\t"+cards[i]);
    }
    System.out.println("请选择");
    Scanner in=new Scanner(System.in);
    int inner=in.nextInt();
    if(cards[inner]==0){
        System.out.println("此卡数量不足");
    }else{
        CardSystem.cardsystem[inner].print(location, namei);
        cards[inner]--;
    }
    System.out.println("还有什么要看的");
    MenuPrint.print1();
    digitalInput = input.nextInt();
    break;
case 3:
    boolean luzhang=false;
    for (int i = 1; i <= 10; i++) {
        if (Landindex.mark[location+i].state == false) {
            System.out.println("前方第" + i + "步处有路障，小心哦,还有什么要看的");
            luzhang=true;
        }
    }
    if(!luzhang){
        System.out.println("没有情况；还有什么要看的");
    }
    MenuPrint.print1();
    digitalInput = input.nextInt();
    break;
case 4:
    System.out.print("请输入您想查询的地方与您相差的步数<后方用负数，按q退出>:");
    String Input = input.next();
    if (Input.equals("q")) {
        System.out.println("还有其它想看的么，请输入 ：");
        MenuPrint.print1();
        digitalInput = input.nextInt();
        break;
    } else {
        int i = Integer.parseInt(Input);
        Landindex.mark[(location+i)%68].printInformation((location+i)%68);
        System.out.println("还有其它想的么，请输入 ：");
        MenuPrint.print1();
        digitalInput = input.nextInt();
        break;
    }
case 5:
    System.out.println("玩家"+"\t"+"现金    "+"\t"+"存款     "+"\t"+"房产数"+"\t"+"房产价值"+"\t"+"点券数");
    for(int i=0;i<Entrance.players.size();i++){
        System.out.println(Entrance.players.get(i).getName()+"\t"+Entrance.players.get(i).getCash()+"\t"+Entrance.players.get(i).getDeposit()+"\t"+Entrance.players.get(i).getHousequantity()+"\t"+Entrance.players.get(i).getHouseValue()+"\t"+Entrance.players.get(i).getPoint());
    }
    System.out.println("还有其它想的么，请输入 ：");
    MenuPrint.print1();
    digitalInput = input.nextInt();
    break;
case 8:
        System.out.println("欢迎进入大富翁股市~~");
        MenuPrint.printstock(namei);
        String[] stockinput;
        String choose;
        int num;
        int amount;
        System.out.println("买股票请输入b*序号*数量，卖股票请输入s*序号*数量,退出请输入q");
        String stockin=input.next();
        if(stockin.equals("q")){
            System.out.println("还有其它想的么，请输入 ：");
            MenuPrint.print1();
            digitalInput = input.nextInt();
            break;
        }else{
        stockinput=stockin.split("[*]");
        choose=stockinput[0];
        num=Integer.parseInt(stockinput[1]);
        amount=Integer.parseInt(stockinput[2]);
        while(true){
        if(choose.equals("b")){
            double allprice=Stock.stocksystem[num-1].getPrice()*amount;
            double all=deposit+cash;
            if(all>=allprice){
                if(deposit>=allprice){
                deposit-=allprice;
                }else{
                    cash-=(allprice-deposit);
                    deposit=0;
                }
                stocks[num-1]+=amount;
                Stock.stocksystem[num-1].setHold(Stock.stocksystem[num-1].getHold()+amount);
                System.out.println("购买成功!");
                break;
            }else{
                System.out.println("购买失败，您的金钱不足");
                break;
            }
        }else if(choose.equals("s")){
            //System.out.println("您当前持有量为"+stocks[num-1]+"您要卖出"+amount);
            if(stocks[num-1]>=amount){
            double allprice=Stock.stocksystem[num-1].getPrice()*amount;
            stocks[num-1]-=amount;
            deposit+=allprice;
            Stock.stocksystem[num-1].setHold(Stock.stocksystem[num-1].getHold()-amount);
            System.out.println("抛售成功！");
            break;
            }else{
                System.out.println("抛售失败，您的持有量不足");
                break;
            }
        }else{
        System.out.print("invalid input, please enter again :");
        stockin=input.next();
        }
        }
        System.out.println("还有其它想的么，请输入 ：");
        MenuPrint.print1();
        digitalInput = input.nextInt();
    break;
    }
}
    }
    if (digitalInput == 6) {
        int actualStep = (int)(Math.random()*6+1);
    //System.out.println("前面"+actualStep);
    //当使用滞留卡时
    if(special==7){
    actualStep=0;
    special=0;
    //使用遥控骰子时
        }else if(special>0&&special<=6){
        actualStep=special;
        special=0;
        }
        //遇到路障时
        for(int i= 1; i < actualStep; i++){
            if (Landindex.mark[(location+i* direction)%68].state == false) {
        System.out.println("前面第" + i + "步遇到了路障，过不去了");
        actualStep = i;
        Landindex.mark[(location+i* direction)%68].state=true;
        location=(location+i* direction)%68;
        break;
    }
}
//当经过银行时
for (int j = 1; j < actualStep; j++) {
    if (Landindex.mark[(location+j* direction)%68] instanceof place.Bank) {
        Landindex.mark[(location+j* direction)%68].printaction((location+j* direction)%68, namei);
        break;
    }
    }
        location=(location+actualStep*direction)%68;
    //  System.out.println("后面"+actualStep);
    Landindex.mark[location].printaction(location, namei);
    }
    if (digitalInput == 7) {
    System.out.println("祝您下次游戏愉快~~");
    for(int i=0;i<Entrance.players.size();i++){
    if(Entrance.players.get(i).getNamei()==namei){
        Entrance.players.remove(i);
    }
    }
        for(int m=0;m<=67;m++){
        if(Landindex.mark[m].owner==namei){
            Landindex.mark[m].owner=0;
        }
    }
        if(Entrance.players.size()==1){
    System.out.println("胜利的玩家是:"+Entrance.players.get(0).getName());
    System.exit(0);
        }
    }
    }else{
    System.out.println("真抱歉，您破产了！下次加油吧！");
    for(int i=0;i<Entrance.players.size();i++){
        if(Entrance.players.get(i).getNamei()==namei){
    Entrance.players.remove(i);
        }
    }
    }
    }
    public double getDeposit() {
    return deposit;
    }
        public void setDeposit(double deposit) {
        this.deposit = deposit;
        }
        public double getCash() {
            return cash;
    }
    public void setCash(double cash) {
        this.cash = cash;
    }
    public int getPoint() {
    return Point;
    }
    public void setPoint(int point) {
    Point = point;
    }
    public int getHousequantity() {
    return housequantity;
    }
    public void setHousequantity(int housequantity) {
        this.housequantity = housequantity;
    }
    public int getStep() {
        return step;
}
public void setStep(int step) {
    this.step = step;
}
public double getHouseValue() {
return houseValue;
    }
public void setHouseValue(double d) {
    this.houseValue = d;
}
public int getDirection() {
    return direction;
    }
public void setDirection(int direction) {
        this.direction = direction;
}
public int getLocation() {
    return location;
}
    public void setLocation(int location) {
        this.location = location;
        }
    public String getName() {
    return name;
}
    public void setName(String name) {
    this.name = name;
        }
public int getNamei() {
        return namei;
    }
    public void setNamei(int namei) {
        this.namei = namei;
}
    public int getSpecial() {
    return special;
}
public void setSpecial(int special) {
    this.special = special;
}
public int[] getCards() {
    return cards;
}
public void setCards(int[] cards) {
    cards = cards;
    }
public int[] getStocks() {
    return stocks;
}
public void setStocks(int[] stocks) {
    this.stocks = stocks;
        }
    }
    • 代码分析：

      之前提到的Player函数,并没有用来作为玩家的初始数据设置。根据游戏性质，玩家在每到一个地方的时候就会发生金钱或者其他数据的变化，不论发生在哪一个场景，发生变化的数据总是这么几个数据，所以就将其列入Player函数中。在每遇到不同的信息的时候就直接调用，比如在Player函数中定义的金钱变化的函数private double cash;this.cash=cash;等，当遇到金钱的变化时候直接调用函数就可以记录。

  • Hospital：
    • 程序代码：

      package place;
public class Hospital extends Land{
Hospital(int x, int y,String name) {
this.i = x;
this.j = y;
this.name=name;
}

@Override
public char getchart() {
// TODO Auto-generated method stub
return ‘医‘;
    }
    public char getinitialchart() {
        return ‘医‘;
        // TODO Auto-generated method stub
    }
    public void printInformation(int step){
    System.out.println("这里是医院~~");
    }
    @Override
    public void printaction(int step,int namei){
        System.out.println("这里是医院~~");
}
}
    • 代码分析：

      因为在大富翁游戏中存在一些没有没有任何功能的地方，只是简单的等待或者显示什么都不会发生等。比如Hospital、PoliceStation、Land等，这一类的只需要在继承父类时候加上@Overrid检查与父类中相同段代码是否相同，方便日后的代码的维护与编译。

  • Entrance：
    • 程序代码：

      package PJ;

import java.util.ArrayList;
import java.util.Scanner;

public class Entrance {
public static int playernumber=0;
public static ArrayList<Player> players=new ArrayList<Player>();
public static void main(String[] args) throws InterruptedException {
System.out.println("====================     游戏开        始       ======================");
while(true){
System.out.println("请输入参加的玩家数:");
Scanner input = new Scanner(System.in);
playernumber = input.nextInt();
if(playernumber<2){
System.out.println("参与玩家数在2-4人之间，请重新输入");
}
if(playernumber>4){
    System.out.println("参与玩家数在2-4人之间，请重新输入");
    }
    if(playernumber>=2&&playernumber<=4){
    System.out.println("设置成功，本次游戏共有"+playernumber+"名玩家，祝您游戏愉快");
    break;
    }
    }
    if(playernumber==2){
    Player player1=new Player(15000, 15000, 100, 0, 0, 1, "玩家1", 1, 0);
    Player player2=new Player(15000, 15000, 100, 0, 0, 1, "玩家2", 2, 0);
    players.add(player1);
    players.add(player2);
    }
    if(playernumber==3){
    Player player1=new Player(15000, 15000, 100, 0, 0, 1, "玩家1", 1, 0);
    Player player2=new Player(15000, 15000, 100, 0, 0, 1, "玩家2", 2, 0);
    Player player3=new Player(15000, 15000, 100, 0, 0, 1, "玩家3", 3, 0);
    players.add(player1);
    players.add(player2);
    players.add(player3);
    }
    if(playernumber==4){
        Player player1=new Player(15000, 15000, 100, 0, 0, 1, "玩家1", 1, 0);
        Player player2=new Player(15000, 15000, 100, 0, 0, 1, "玩家2", 2, 0);
        Player player3=new Player(15000, 15000, 100, 0, 0, 1, "玩家3", 3, 0);
        Player player4=new Player(15000, 15000, 100, 0, 0, 1, "玩家4", 4, 0);
    players.add(player1);
    players.add(player2);
    players.add(player3);
    players.add(player4);
    }
    while(true){
    Date.print();
    if(Date.totalday%7!=6&&Date.totalday%7!=0){
    for(int i=0;i<=9;i++){
    Stock.stocksystem[i].run();
    }
    System.out.println("今天是工作日，股市正常开市");
    }else{
    System.out.println("今天是双休日，股市休市");
    }
        for(int i=0;i<players.size();i++){
        players.get(i).move();
    }
    }
    }
}
    • 程序分析：

    是整个程序的主函数，整个PJ包包含着项目的主要函数，entrance是整个项目的入口，主要定义了玩家的数量，以及每位玩家的初始位置以及初始金币等个人信息。通过scanner函数让用户选择玩家的人数System.out.println("请输入参加的玩家数:"); Scanner input = new Scanner(System.in); playernumber = input.nextInt();，并引用之后所需要的数组比如Player player1=new Player(15000, 15000, 100, 0, 0, 1, "玩家1", 1, 0);

  • Date：
    • 程序代码：

      package PJ;

public class Date {
public static int year=2016,month=5,day=30,totalday=1;
public static void print(){
System.out.println("今天是"+year+"年"+month+"月"+day+"日"+"周"+(totalday%7));
totalday++;
day++;
if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
if(day==32){
    day=1;
    month++;
}
if(month==13){
    month=1;
    year++;
}
}
    if(month==2){
    if(day==29){
    day=1;
    month++;
}
    }
    if(month==4||month==6||month==9||month==11){
    if(day==32){
    day=1;
    month++;
    }
}
}
}
  • 程序分析：

    主要是定义了日期，用最简单的if语句if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){，来定义，用户选择后来每月的30 31 28 29天数。当然如果满天数溢出之后month进一if(day==32){ day=1; month++; }，依次循环。

  • MenuPrint：
    • 程序代码：

      package PJ;

import card.CardSystem;
import place.Landindex;

public class MenuPrint {
    public static void print1() {
    System.out.println("0 - 查看地图\n1 - 查看原始地图\n2 - 使用道具\n3 - 前方十步内示警\n4 - 查看前后指定步数的具体信息\n5 - 查看玩家的资产信息\n6 - 想看的都看了，心满意足扔骰子"
            + "\n7 - 不玩了，认输\n8 - 股票");
    System.out.print("请选择 :");
    }
    public static void printstock(int namei) {
    Player player=new Player();
    int[] stocks ;
    for(int i=0;i<Entrance.players.size();i++){
    if(Entrance.players.get(i).getNamei()==namei){
    player=Entrance.players.get(i);
    }
    }
    stocks=player.getStocks();
    System.out.println("序号"+"\t\t"+"股票名"+"\t\t\t"+"单价"+"\t\t"+"涨跌幅"+"\t\t"+"持有量");
    for(int i=0;i<=9;i++){
    System.out.println(Stock.stocksystem[i].getNumber()+"\t\t"+Stock.stocksystem[i].getName()+"\t\t"+Stock.stocksystem[i].getPrice()+"\t\t"+Stock.stocksystem[i].getIncrease()+"\t\t"+stocks[i]);
    }
    }
    public static void printinitialmap(){
    char[][] blank=new char[10][20];
    for(int i=0;i<=9;i++){
        for(int j=0;j<=19;j++){
    blank[i][j]=(char)12288;//初始化
        }
    }
    for(int i=0;i<Landindex.mark.length;i++){
        for(int x=0;x<=9;x++){
        for(int y=0;y<=19;y++){
        if(Landindex.mark[i].i==y&&Landindex.mark[i].j==x)
        blank[x][y]=Landindex.mark[i].getchart();
            }
        }
        }
    for(int j=0;j<=9;j++){
        for(int i=0;i<=19;i++ ){
        System.out.print(blank[j][i]);
    }
    System.out.println();
    }
        }
    public static void printmap(){
    char[][] blank=new char[10][20];
    for(int i=0;i<=9;i++){
        for(int j=0;j<=19;j++){
        blank[i][j]=(char)12288;
        }
        }
    for(int i=0;i<Landindex.mark.length;i++){
        for(int x=0;x<=9;x++){
        for(int y=0;y<=19;y++){
        if(Landindex.mark[i].i==y&&Landindex.mark[i].j==x)
    blank[x][y]=Landindex.mark[i].getchart();
    for(int k=0;k<Entrance.players.size();k++){
        if(Entrance.players.get(k).getLocation()==i){
            if(Entrance.players.get(k).getNamei()==1)
                blank[Landindex.mark[i].j][Landindex.mark[i].i]=‘□‘;//玩家1所在位置
            if(Entrance.players.get(k).getNamei()==2)
                blank[Landindex.mark[i].j][Landindex.mark[i].i]=‘■‘;//玩家2所在位置
            if(Entrance.players.get(k).getNamei()==3)
                blank[Landindex.mark[i].j][Landindex.mark[i].i]=‘◇‘;//玩家3所在位置
            if(Entrance.players.get(k).getNamei()==4)
                blank[Landindex.mark[i].j][Landindex.mark[i].i]=‘◆‘;//玩家4所在位置
            }
            }
            }
    }
    }
    for(int j=0;j<=9;j++){
        for(int i=0;i<=19;i++ ){
        System.out.print(blank[j][i]);
    }
    System.out.println();
    }
    }

      }

    • 程序分析：

    这是程序的菜单类，比如每个回合用户走到了哪里，地图上能够print出来public static void printmap(){ char[][] blank=new char[10][20]; for(int i=0;i<=9;i++){ for(int j=0;j<=19;j++){ blank[i][j]=(char)12288; } }。设计思想就是类C用一个case语句，来让用户选择每一步的行为。landindex项来确定用户每一步走到了哪里if(Landindex.mark[i].i==y&&Landindex.mark[i].j==x) blank[x][y]=Landindex.mark[i].getchart();。用if语句来保证，因为最开始并不能确定到底有多少名用户。用四个if套环就能确定

  • Stock：
    • 程序代码：

      package PJ;

public class Stock {
String name;
int number;//序号
double price;
int hold=0;//持有量
double increase;
public boolean state=false;
Stock(String name,int number,double price){
    this.name=name;
this.number=number;
    this.price=price;
}
public  String getName(){
    return name;
};
public  int getNumber() {
    return number;
}
public  int getHold() {
    return hold;
}
public  void setHold(int i) {
    this.hold=i;
    }
    public  double getPrice() {
    return price;
}
public  double getIncrease() {
    return increase;
    }
public void run() {
    increase=(Math.random()-0.5)*0.2;
    increase=Double.parseDouble(String.format("%.2f",increase));
    this.price=price*(1+increase);
    this.price=Double.parseDouble(String.format("%.2f",price));
        }
    public static Stock[] stocksystem = new Stock   [10];
        static{
    stocksystem[0]=new Stock("zhonghaifazhan",1,2.0);
    stocksystem[1]=new Stock("dongfengqiche",2,1.5);
    stocksystem[2]=new Stock("jinangangtie",3,1.8);
    stocksystem[3]=new Stock("zhongguoguomao",4,2.5);
    stocksystem[4]=new Stock("baoganggufen",5,2.7);
    stocksystem[5]=new Stock("huanengguoji",6,2.9);
    stocksystem[6]=new Stock("baoganggufen",7,3.3);
    stocksystem[7]=new Stock("shanghaidianli",8,3.5);
    stocksystem[8]=new Stock("zhongyuangaosu",9,3.2);
    stocksystem[9]=new Stock("shanghaidianli",10,1.7);
}
}
    • 程序分析：

    stock类是用来定义股票的一个类，有利息运算increase函数increase=(Math.random()-0.5)*0.2;，其中引用了random函数来确定股票的增长收入，以及每种股票最后写的那样stocksystem[0]=new Stock("zhonghaifazhan",1,2.0);，每种的价格最开始处于一个固定的值，以后可以在完善的过程中加入新函数，不仅仅是random自带的math函数，更多的是更多杂凑函数的组合，让股票类能更多的无序。

  • EqualizedWealthCard
    • 程序代码：

      package card;

import place.Landindex;
import PJ.Entrance;
import PJ.Player;

public class EqualizedWealthCard extends CardSystem {
//均富卡
String name="EqualizedWealthCard";
String function="将所有人的现金平均分配";
String type="MagicCard";
String range="其他玩家（无视距离）";
EqualizedWealthCard(){
    int point=40;
this.point=point;
}
@Override
public String getName() {

    return name;
}

@Override
public String getFunction() {
    // TODO Auto-generated method stub
    return function;
}

@Override
public String getType() {
    // TODO Auto-generated method stub
    return type;
}
@Override
public int getPoint() {
    return point;
}
@Override
public String getRange() {
    // TODO Auto-generated method stub
    return range;
}
@Override
public void print(int location, int namei) {
    // TODO Auto-generated method stub
    int tmp=0;
    for(int i=0;i<Entrance.players.size();i++){
        tmp+=Entrance.players.get(i).getCash();
    }
    tmp=tmp/(Entrance.players.size());
    for(int i=0;i<Entrance.players.size();i++){
        Entrance.players.get(i).setCash(tmp);
    }
    System.out.println("卡牌使用成功");
}
}
    • 代码分析：

    这个代码程序是实现一个均富卡的功能，让所有玩家的资产平均分配。String name 是定义改卡片的名字，String function 是说明该卡片的功能，String type 是定义卡片的分类情况，String range定义了卡片的适用范围。getName、getFuction、getType、getRange是依次对应这些定义的获取函数。`

    for(int i=0;i<Entrance.players.size();i++){ tmp+=Entrance.players.get(i).getCash();这段代码是实现对每个玩家现金求和。

    tmp=tmp/(Entrance.players.size()这段代码是讲总资产平局分配。

    for(int i=0;i<Entrance.players.size();i++){Entrance.players.get(i).setCash(tmp); }这段代码完成了将每个人的现金数更改为修改后的数目的功能。

  • BlackCard
    • 程序代码：

      package card;
public class BlackCard extends CardSystem{
    //黑卡
String name="BlackCard";
String function="使第二天这支股票下跌10%";
String type="ToolCard";
String range="特定的股票";
BlackCard(){
    int point=20;
    this.point=point;
    }
    @Override
public int getPoint() {
    return point;
    }
    @Override
public String getName() {

            return name;
        }

        @Override
public String getFunction() {
    // TODO Auto-generated method stub
    return function;
}

@Override
public String getType() {
    // TODO Auto-generated method stub
    return type;
}

@Override
public String getRange() {
    // TODO Auto-generated method stub
    return range;
}
@Override
public void print(int location, int who) {
    // TODO Auto-generated method stub
    System.out.print("该卡牌功能尚未开放，敬请期待");
}
}
    • 程序分析

      该程序对应Black card，其功能是使某支股票价在第二天下跌10%。其中，@Override起到了方便代码检查和维护的功能。public String getName() {return name;};这段函数是为了获取这张卡片的名称。

      public String getFunction() {// TODO Auto-generated method stubreturn function;}以及后面的getType、gerRange功能和它类似，依次对应功能、类别、使用范围。 目前这张功能卡只完成了其模板的创建，主函数部分还未完成，所以该卡片的功能还不能在Jvaa程序上实现，我们组会在后续项目完善时将其补充完整。

  • MonsterCard
    • 程序代码：

        package card;

import PJ.Entrance;
    import PJ.Player;
import place.Landindex;

public class MonsterCard extends CardSystem {
//怪兽卡
String name="MonsterCard";
String function="该街道所有土地重置为初始状态，即1级";
String type="MagicCard";
String range="停留地的整条街道";
MonsterCard(){
    int point=20;
    this.point=point;
}
@Override
public String getName() {

    return name;
}

@Override
public String getFunction() {
    // TODO Auto-generated method stub
    return function;
}
@Override
public int getPoint() {
    return point;
}
@Override
public String getType() {
    // TODO Auto-generated method stub
    return type;
}

@Override
public String getRange() {
    // TODO Auto-generated method stub
    return range;
}
@Override
public void print(int location, int who) {
    // TODO Auto-generated method stub
    Player playerow=new Player();
    for(int i=0;i<Entrance.players.size();i++){
        if(Entrance.players.get(i).getNamei()==Landindex.mark[location].owner){
            playerow=Entrance.players.get(i);
        }
    }
    Landindex.mark[location].level=1;
    playerow.setHouseValue(playerow.getHouseValue()-Landindex.mark[location].price+Landindex.mark[location].intialprice);
    Landindex.mark[location].price=Landindex.mark[location].intialprice;
}
}
    • 代码分析：

    这张卡为怪兽卡，其功能是当玩家抽到该卡片时，玩家所处街道上的所有土地降为1级。与其他功能卡的程序类似，String name="MonsterCard";String function="该街道所有土地重置为初始状态，即1级";String type="MagicCard"; String range="停留地的整条街道"; 这些是定义该卡片的基本信息，包括名称、类别、功能、使用范围。

    if(Entrance.players.get(i).getNamei() ==Landindex.mark[location].owner){ playerow=Entrance.players.get(i); Landindex.mark[location].level=1;先判断玩家的土地是否处在该街道段上。 如果是在该街道上，则将这块土地的等级降为1。for(int i=0;i<Entrance.players.size();i++) 加上该循环后，就完成了对每位玩家的检查和执行。

3.项目现实中的问题与解决

  • 首先是主要函数中的Entrance函数，因为游戏需要规定出参与游戏的人数，原计划是单独使用一个class文件用来定义玩家数量和初始金钱等，直接利用Entrance函数将其连接起来，但是发现发现如果将参与游戏的人数与Entrance函数连接起来会增大工作量，在维护起来也会存在一定的问题，于是就减少了游戏的参与人数，将玩家的初始数据归入Entrance函数中。
  • 在菜单的选项中，遇到的问题是如何让参与游戏的玩家能直接获得地图信息、使用道具或者看到玩家个人信息等问题。因为我们的程序没有实现界面化，如果在一个界面下就可以成功的显示出以上所提到的信息。我们的解决方案是，在PJ中加入一个MenuPrint函数，里面显示为菜单打印功能，在每一步掷骰子结束后都会自动跳出来这个菜单，共玩家选择。这样就解决了之前遇到的玩家没法直接查询信息的问题。
  • 在之前提到的彩票站（LotteryStation）对于金钱的计算，遇到的问题是在嵌套循环的时候有时候的金钱信息会发生错误，解决得问题是采用差额计算法，之前提到过解决办法，如果遇到金额小于购买彩票的金额是，在其之前加上一个循环语句，判断一下就可以解决。
  • 在Card方面，我们遇到如何在游戏的地图里获得卡牌，是选择随机出现还是有卡牌出售的地方，经过讨论，我们在地图里加一个Cardshop函数，当掷骰子到该处时候就可以选择购买卡牌，并在Player函数中记录该玩家的特殊卡牌功能。只需在CardShop中显示出卡牌的种类及功能，具体的在Card包中实现，每一个卡牌需要定义功能，使用对象等，在CardShop中用move（）方法实现调用，就解决了问题。

4.项目展望与改进（共下一届同学参考）

  • 展望：

    我们原计划是希望有一个界面化，但是后来发现这个GUI界面化和简单的五子棋和贪吃蛇的界面不一样的。这个相较于内些复杂很多，所以希望如果有可能的话学习一下GUI界面化，对于这个游戏进行界面化设计运行程序的时候不单单在Idea的界面中，就会有质的改变。

  • 改进：

    在卡牌功能方面还有待提高，只有简单的几个卡牌，实现的功能不是很广泛，有时间的话在这方面应该还可以在改进一下。同样的在游戏的地图的设计方面，地图地点中由于编译能力的问题就没有实现很多其他种类的地方，像类似于Hospital函数、Bank函数、Park函数、Land函数、PolcieStation函数代码几乎是一样的，只是不同地名而已，所以在这方面丰富度不是很高，在这方面也是需要提高。

5.团队成员贡献与成绩分配

我们队一共4个人，团队总分4*25=100

|团队成员|成员贡献|成绩分配| |20144303石宇森|负责博客的记录、部分函数的编译、辅助项目的编译。|22分| |20145301赵嘉鑫|负责博客的记录、项目主要代码的编译、资料查询等、对托管的代码进行检查与再编译等。|29分| |20145307陈俊达|负责博客的记录、项目主要的代码编译、托管过的代码检查再编译z。|26分| |20145335郝昊|负责主要博客记录、部分函数的编译、辅助项目的编译、其他程序的java语言翻译、代码的托管。 |23分|

时间： 2024-10-17 04:01:04

Java团队项目总结的相关文章

HeyWeGo小组《Java程序设计》 2015—2016年学期团队项目总结

HeyWeGo小组<Java程序设计> 2015—2016年学期团队项目总结 题目简介 一个简单的扫雷小游戏,在12*12的方格盘上,首先可以设定雷的个数,然后点击开始程序就会随机布雷,开始游戏后如果点到雷就会显示游戏结束,如果没有,会出现数字表示周围一圈雷的个数,以此推理当扫出所有雷将显示游戏胜利. 游戏项目规划: 确定游戏中方块格子的个数 确定游戏中地雷的个数(初始10个),完成布雷 计算每个方块周围的雷数,在方块周围本身没有地雷的情况下,统计周围地雷的个数 若周围没有地雷则翻开周围的空白

团队项目失败总结

很遗憾 ,这次团队项目失败了.预定的是做一个简易四则运算器,以计算为辅,出题为主.出题包含两部分,小学部分和初中部分.现在只完成了小学部分,计算器部分也完成了.我们团队的基本配置是:一位主编(我).两位副编,一位负责计算器模块另一位负责UI.一人专司文档.一人做需求分析.一人做系统测试.分析此次项目失败,原因很多,主要有二:(1)所选编程语言不熟——Java,此前从未接触过Java,因为做项目的时候要考虑UI,用C语言就不合适了,C++用的也不熟,就选了Java.只能一边学一边用.我选的参考书是

[团队项目]----Math Calculator

团队项目 ----Math Calculator 任务: 1.每个团队从Github上fork这个项目的源代码 https://github.com/RABITBABY/We-have-bing 2.了解.部署.运行这个项目,理解其功能及实现: 3.进行必要的测试,发现软件的bug并记录,并进行bug的排除: 发布博客内容: 简要说明如何下载部署运行这个项目: 补充这个软件的单元测试并提交到Github上: 解释说明找出的bug及修复情况: 列出每个团队成员的个人贡献分. -----------

0421团队项目 1.0

团队项目 ----Math Calculator 任务: 1.每个团队从Github上fork这个项目的源代码 https://github.com/RABITBABY/We-have-bing 2.了解.部署.运行这个项目,理解其功能及实现: 3.进行必要的测试,发现软件的bug并记录,并进行bug的排除: 发布博客内容: 简要说明如何下载部署运行这个项目: 补充这个软件的单元测试并提交到Github上: 解释说明找出的bug及修复情况: 列出每个团队成员的个人贡献分. -----------

团队项目（二）

团队项目是建立局域网聊天室,我们打算用socket通信实现消息传递.考虑网络方面java有很多封装好的类库,使用十分方便,我们团队初步打算使用java实现. 目前我和王以正同学完成代码.目前我起了一个头,完成了客户端内核的基本框架.代码如下: 1 public class Client { 2 3 Socket soc = null; 4 public String name; 5 public String roomName; 6 public InputStream is = null; 7

软工实践之团队项目

我们的队名: Clean Code 031302511 林培兴 031302623 张衍坤 031302223 翁翰帅 031302536 苏丽玲 031302505 黄晓辉(组长) 团队项目描述: 校园通 团队成员介绍:    林培兴:我和组长是结对项目中的队友,在结对项目中,我们很好地合作分工,结对作业也取得不错的成绩.我有一定的Java基础,软工实践以来,也开始在努力学习安卓,在安卓编程方面有一定的进步.在我们的队伍中,我的定位主要是编程方面,负责我们项目的一部分模块的编程任务. 张衍坤:

团队项目第一周任务之团队组建及项目启动与竞争性需求分析

一.团队项目: 即时聊天工具,编写语言:java.设计知识:java基础,UI,java多线程,java通信,oracle数据库. 二.团队组建 团队组建及项目启动已将完成,成员人数五人,分工明确.各自的准备工作基本完成. 三.竞争需求分析 团队竞争性需求分析应经完成

Java开源项目（备查）

转自:http://www.blogjava.net/Carter0618/archive/2008/08/11/221222.html Spring Framework  [Java开源 J2EE框架] Spring 是一个解决了许多在J2EE开发中常见的问题的强大框架. Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯.Spring的架构基础是基于使用JavaBean属性的 Inversion of Control容器.然而,这仅仅是完整图景中的一部分

关于团队项目的一些看法

这次的软件工程暑期实践,我们团队打算用JAVA进行项目的开发.但就我本人而言,我其实编程学的并不是很好,为了这次的团队项目,我决定从现在开始重新再自学一遍JAVA这门课程.因为,上学期的JAVA,由于实践太少,也没多花心思所以只学到了一些JAVA的皮毛,所以,我将通过网上的课程重新学习JAVA.让我对JAVA有一个更加深入的了解,也为了我以后能熟练应用JAVA做准备. 再者,我也要多练习编程,毕竟我选择了软件方向,我就应该学好编程.我会从书中的例子开始着手,然后,再从网上找一些有关编程的题目,我