我有一个学校的java大作业,java大作业小游戏

发布时间：2022-11-23

本文目录一览：

  1. 急求一份Java课程设计，结课大作业，最近有考试，时间不够，来不及做了。谢谢啦！邮箱573762475@qq.com
  2. 一个java的作业！~
  3. [我有一个学校的java大作业，需要实现addplayer familyname，surname，username 来添加player](#我有一个学校的java大作业，需要实现addplayer familyname，surname，username 来添加player)

急求一份Java课程设计，结课大作业，最近有考试，时间不够，来不及做了。谢谢啦！邮箱573762475@qq.com

Java课程设计报告 题 目： 计算器 院（系）：xxx学院 年级专业： xxx班 学生姓名： xxx 指导老师： xx老师 开始时间： 200x-xx-xx 完成时间： 200x-xx-xx 目 录

  1. 摘 要
  2. 概要设计
  3. 详细设计
  4. 测试分析
  5. 参考文献 一、摘 要 本计算器可以进行简单的四则运算（加、减、乘、除）但仅限于十进制下，还可以进行（八进制，十进制，十六进制）之间的相互转换，八进制最多可以输入19位数，十进制最多可以输入18位数，十六进制最多可以输入14位数,backspace表示退格, clear表示初始化，在window下直接运行（Jsp2003.bat）即可，界面为灰白对称。 二、概要设计 （1） 自定义类说明
  • 类名: This_number_too_big
  • 作用: 自定义的异常类，用来处理计算结果溢出
  • 继承的父类: Exception类
  • 实现的接口: 没有
class This_number_too_big extends Exception
{
}

自定义的一个结果溢出异常类

  • 类名: Jsp2003
  • 作用: 主类。
  • 继承的父类: Frame类
  • 实现的接口: ItemListener类,ActionListener类
class Jsp2003 extends Frame implements ItemListener,ActionListener
{
    public int number=0,length=18;
    //number是用来记录输入的数字个数，
    //length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制 
    public char mark='n';
    //设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’
    public double data=0;
    //设置运算数据为零
    public char ch;
    //用来临时存放所按按钮的第一个字符
    public boolean Refresh=false;
    //设置lab是否要在输入数据的时候刷新，初始为否

主要方法说明：

public void js() throws This_number_too_big //指定由method抛出异常
{
    if (mark=='n') //没有运算符
    {
        mark=ch; //，则设置运算符为刚刚输入的字符，
        data=Double.parseDouble(lab.getText());//则设置运算数据为lab的值
        Refresh=true;//则设置下一次输入的时候要刷新lab
    }
    else //如果采用的是连续运算（即没有使用‘=’号）则运行下面的语句
    {
        switch (mark) //根据运算符计算结果，并把结果保存到data
        {
            case '+': data+=Double.parseDouble(lab.getText()); break;
            case '-': data-=Double.parseDouble(lab.getText()); break;
            case '*': data*=Double.parseDouble(lab.getText()); break;
            case '/': data/=Double.parseDouble(lab.getText()); break;
        }
        lab.setText(Double.toString(data)); //显示运算结果
        mark=ch;//设置运算符为刚刚按下的运算符
        Refresh=true;//则设置下一次输入的时候要刷新lab
        number=lab.getText().length();//设置输入的字符个数
        // System.out.println(lab.getText());//用来调试用的
        if (data > Double.MAX_VALUE)
        //如果data超过double类型的最大值则抛出自定义的一个异常类
    }
}

public void enter()//处理输入字符
{
    if(Refresh==true)
    //如果已经设置了 运算符则在下一次输入数据的时候要把以前lab的内容清除掉
    if(lab.getText().charAt(0)=='0' && lab.getText().length()==1)
    //如果lab的内容为0则，lab的内容将被所输入的字符代替，
    //否则直接在lab的内容后面加上所输入的字符
    else
    if(number > length)
}

//八进制或十六进制转换成十进制I
public String goto_10(String s,long l)
//参数s： 是要转换的字符串，由于输入的控制，保证了字符串的合法性；
//参数l： 使用来设置是将8进制还是16进制转换成10进制，它的有效值为8或16；
{
    String str=s; //用来转换的字符串
    long j=l; //表示进制
    long lg=0,jing=1;//lg用来记录权乘和，jing用来记录位权
    char cha;//临时记录要转换的字符
    for(int i=1;i<=str.length();i++)
    {
        cha=str.charAt(str.length()-i);
        switch(cha)
        {
            case '1': lg=lg+1*jing;break;
            case '2': lg=lg+2*jing;break;
            case '3': lg=lg+3*jing;break;
            case '4': lg=lg+4*jing;break;
            case '5': lg=lg+5*jing;break;
            case '6': lg=lg+6*jing;break;
            case '7': lg=lg+7*jing;break;
            case '8': lg=lg+8*jing;break;
            case '9': lg=lg+9*jing;break;
            case 'A': lg=lg+10*jing;break;
            case 'B': lg=lg+11*jing;break;
            case 'C': lg=lg+12*jing;break;
            case 'D': lg=lg+13*jing;break;
            case 'E': lg=lg+14*jing;break;
            case 'F': lg=lg+15*jing;break;
        }
        jing*=j; //位权升一级，为下次使用做好准备
    }
    return Long.toString(lg);
}

} （2）程序流程图 三、详细设计

import java.awt.*;
import java.awt.event.*;
class This_number_too_big extends Exception
{}//自定义的一个结果溢出异常类
class Jsp2003 extends Frame implements ItemListener,ActionListener 
{
    public Jsp2003() 
    {
        addWindowListener(new WindowAdapter() 
        {
            public void windowClosing(WindowEvent e) 
            {
                dispose();
                System.exit(0);
            }
        });
    }
    static Jsp2003 mainFrame = new Jsp2003();
    static Label lab=new Label("0");
    static Panel pnl1=new Panel(new GridLayout(4,3,3,3));
    static Panel pnl2=new Panel(new GridLayout(4,1,3,3));
    static Panel pnl3=new Panel(new GridLayout(1,2,3,3));
    static Panel pnl4=new Panel(new GridLayout(6,1,3,3));
    static Button bt9=new Button("9");
    static Button bt8=new Button("8");
    static Button bt7=new Button("7");
    static Button bt6=new Button("6");
    static Button bt5=new Button("5");
    static Button bt4=new Button("4");
    static Button bt3=new Button("3");
    static Button bt2=new Button("2");
    static Button bt1=new Button("1");
    static Button bt0=new Button("0");
    static Button btdot=new Button(".");
    static Button btequ=new Button("=");
    static Button btadd=new Button("+");
    static Button btsub=new Button("-");
    static Button btmul=new Button("*");
    static Button btdev=new Button("/");
    static Button btA=new Button("A");
    static Button btB=new Button("B");
    static Button btC=new Button("C");
    static Button btD=new Button("D");
    static Button btE=new Button("E");
    static Button btF=new Button("F");
    static Checkbox ckb8=new Checkbox("八进制");
    static Checkbox ckb10=new Checkbox("十进制");
    static Checkbox ckb16=new Checkbox("十六进制");
    static Button btc=new Button("clear");
    static Button btt=new Button("backspace");
    public int number=0,length=18;
    //number是用来记录输入的数字个数，length是用来设置在不同进制下允许输入的最多数字位数，默认为十进制
    public char mark='n'; //设置运算符号为没有即为‘n’，它的值是‘+’‘-’‘*’‘/’
    public double data=0; //设置运算数据为零
    public char ch; //用来临时存放所按按钮的第一个字符
    public boolean Refresh=false;//设置lab是否要在输入数据的时候刷新，初始为否
    public static void main(String args[]) 
    {
        System.out.println("Starting Jsp2003...");
        lab.setAlignment(Label.RIGHT);
        lab.setBackground(Color.lightGray);
        lab.setForeground(Color.BLUE);
        lab.setFont(new Font("Serief",Font.BOLD,18));
        lab.setBounds(14,33,216,40);
        mainFrame.add(lab);
        CheckboxGroup grp=new CheckboxGroup();
        ckb8.setCheckboxGroup(grp);
        ckb10.setCheckboxGroup(grp);
        ckb16.setCheckboxGroup(grp);
        ckb8.setBounds(14,75,55,25);
        ckb10.setBounds(69,75,55,25);
        ckb16.setBounds(124,75,65,25);
        ckb8.setState(false);
        ckb10.setState(true);
        ckb16.setState(false);
        mainFrame.add(ckb8);
        mainFrame.add(ckb10);
        mainFrame.add(ckb16);
        pnl1.setBounds(14,140,120,150);
        pnl2.setBounds(144,140,40,150);
        pnl3.setBounds(14,100,170,36);
        pnl4.setBounds(190,100,40,190);
        pnl1.add(bt7);
        pnl1.add(bt8);
        pnl1.add(bt9);
        pnl1.add(bt4);
        pnl1.add(bt5);
        pnl1.add(bt6);
        pnl1.add(bt1);
        pnl1.add(bt2);
        pnl1.add(bt3);
        pnl1.add(bt0);
        pnl1.add(btdot);
        pnl1.add(btequ);
        pnl2.add(btadd);
        pnl2.add(btsub);
        pnl2.add(btmul);
        pnl2.add(btdev);
        pnl3.add(btt);
        pnl3.add(btc);
        pnl4.add(btA);
        pnl4.add(btB);
        pnl4.add(btC);
        pnl4.add(btD);
        pnl4.add(btE);
        pnl4.add(btF);
        btA.enable(false);
        btB.enable(false);
        btC.enable(false);
        btD.enable(false);
        btE.enable(false);
        btF.enable(false);
        mainFrame.add(pnl1);
        mainFrame.add(pnl2);
        mainFrame.add(pnl3);
        mainFrame.add(pnl4);
        mainFrame.setResizable(false);
        mainFrame.setLayout(null);
        mainFrame.setSize(240,300 );
        mainFrame.setTitle("计算器");
        mainFrame.setVisible(true);
        ckb8.addItemListener(mainFrame);
        ckb10.addItemListener(mainFrame);
        ckb16.addItemListener(mainFrame);
        //把事件聆听者向各个组键注册
        bt1.addActionListener(mainFrame);
        bt2.addActionListener(mainFrame);
        bt3.addActionListener(mainFrame);
        bt4.addActionListener(mainFrame);
        bt5.addActionListener(mainFrame);
        bt6.addActionListener(mainFrame);
        bt7.addActionListener(mainFrame);
        bt8.addActionListener(mainFrame);
        bt9.addActionListener(mainFrame);
        bt0.addActionListener(mainFrame);
        btadd.addActionListener(mainFrame);
        btsub.addActionListener(mainFrame);
        btmul.addActionListener(mainFrame);
        btdev.addActionListener(mainFrame);
        btt.addActionListener(mainFrame);
        btc.addActionListener(mainFrame);
        btdot.addActionListener(mainFrame);
        btequ.addActionListener(mainFrame);
        btA.addActionListener(mainFrame);
        btB.addActionListener(mainFrame);
        btC.addActionListener(mainFrame);
        btD.addActionListener(mainFrame);
        btE.addActionListener(mainFrame);
        btF.addActionListener(mainFrame);
    }
    //---------------------------------------------
    //checkbox 事件的处理
    public void itemStateChanged(ItemEvent e)
    {
        mark='n';
        Refresh=false;
        //规定当进制转换时以前输入的运算符失效
        if (ckb8.getState()==true)
        {
            btA.enable(false);
            btB.enable(false);
            btC.enable(false);
            btD.enable(false);
            btE.enable(false);
            btF.enable(false);
            bt9.enable(false);
            bt8.enable(false);
            btdot.enable(false);
            btadd.enable(false);
            btmul.enable(false);
            btsub.enable(false);
            btdev.enable(false);
            btequ.enable(false);
            //在八进制的情况下对有些按件的管理
            if(length==18) 
            { 
                lab.setText(goto10_8(lab.getText()));
                number=lab.getText().length();
            }
            if(length==14) 
            { 
                lab.setText(goto_10(lab.getText(),16L));
                lab.setText(goto10_8(lab.getText()));
                number=lab.getText().length();
            }
            //将其他进制转换成八进制
            length=19;
            //在八进制下允许输入数字个数最多为19位
        }
        if(ckb10.getState()==true)
        {
            btA.enable(false);
            btB.enable(false);
            btC.enable(false);
            btD.enable(false);
            btE.enable(false);
            btF.enable(false);
            bt9.enable(true);
            bt8.enable(true);
            btdot.enable(true);
            btadd.enable(true);
            btmul.enable(true);
            btsub.enable(true);
            btdev.enable(true);
            btequ.enable(true);
            //在十进制的情况下对有些按件的管理
            if(length==19) 
            { 
                lab.setText(goto_10(lab.getText(),8L));
                number=lab.getText().length();
            }
            if(length==14) 
            { 
                lab.setText(goto_10(lab.getText(),16L));
                number=lab.getText().length();
            }
            //进制转换成十进制
            length=18;
            //在十进制下允许输入数字个数最多为18位
        }
        if(ckb16.getState()==true)
        {
            btA.enable(true);
            btB.enable(true);
            btC.enable(true);
            btD.enable(true);
            btE.enable(true);
            btF.enable(true);
            bt9.enable(true);
            bt8.enable(true);
            btdot.enable(false);
            btadd.enable(false);
            btmul.enable(false);
            btsub.enable(false);
            btdev.enable(false);
            btequ.enable(false);
            //在十六进制的情况下对有些按件的管理
            if(length==18) 
            { 
                lab.setText(goto10_16(lab.getText()));
                number=lab.getText().length();
            }
            if(length==19) 
            { 
                lab.setText(goto_10(lab.getText(),8L));
                lab.setText(goto10_16(lab.getText()));
                number=lab.getText().length();
            }
            //将其他进制转换成十六进制
            length=14;
            //在十六进制下允许输入数字个数最多为14位
        }
    }
    //------------------------------------------------------------
    //按钮事件的处理
    public void actionPerformed(ActionEvent m)
    {
        Button btn=(Button) m.getSource();
        ch=btn.getLabel().charAt(0);
        switch (ch)
        {
            break;//初始化
            case '1': enter(); break;
            case '2': enter(); break;
            case '3': enter(); break;
            case '4': enter(); break;
            case '5': enter(); break;
            case '6': enter(); break;
            case '7': enter(); break;
            case '8': enter(); break;
            case '9': enter(); break;
            case '0':
                if(lab.getText().charAt(0)=='0' && lab.getText().length()==1)
                    break;
                if(number < length)
                else 
                    break;
                break;
            case 'A': enter(); break;
            case 'B': enter(); break;
            case 'C': enter(); break;
            case 'D': enter(); break;
            case 'E': enter(); break;
            case 'F': enter(); break;
            case '.': 
                if(Refresh==true)
                {
                    if(lab.getText().indexOf('.') == -1)
                        break;
                    else
                        break;
                }
                break;
            case 'b': 
                if(number == 0) 
                    break;
                else
                {
                    if (number != 1) 
                        lab.setText(lab.getText().substring(0,number));
                    else
                        lab.setText(Character.toString(lab.getText().charAt(0)));
                }
                break;
            case '+': 
                try
                {
                    // ...
                }
                catch(This_number_too_big e)
                {
                    lab.setText("0"); 
                    number=0; 
                    mark='n';
                    Refresh=false; 
                    System.out.println("The number is too big");
                } 
                break;
            case '-': 
                try
                {
                    // ...
                }
                catch(This_number_too_big e)
                {
                    lab.setText("0"); 
                    number=0; 
                    mark='n';
                    Refresh=false; 
                    System.out.println("The number is too big");
                } 
                break;
            case '*': 
                try
                {
                    // ...
                }
                catch(This_number_too_big e)
                {
                    lab.setText("0"); 
                    number=0; 
                    mark='n';
                    Refresh=false; 
                    System.out.println("The number is too big");
                } 
                break;
            case '/': 
                try
                {
                    // ...
                }
                catch(This_number_too_big e)
                {
                    lab.setText("0"); 
                    number=0; 
                    mark='n';
                    Refresh=false; 
                    System.out.println("The number is too big");
                } 
                break;
            case '=': 
                try
                {
                    // ...
                }
                catch(This_number_too_big e)
                {
                    lab.setText("0"); 
                    number=0; 
                    mark='n';
                    Refresh=false; 
                    System.out.println("The number is too big");
                } 
                break;
        }
    }
}

一个java的作业！~

import java.lang.Math;
//a+bx+cx^2=y
public class func(double a1,double b1,double c1,double x1){
    double a=a1;
    double b=b1;
    double c=c1;
    double x=x1;
    double y=0;
    public void function(double a,double b,double x)
    {
        if((b^2-4*a*c) > 0.0)
            System.out.println("没有实根");
        double x1=-(b/2*a)+Math.sqrt(b^2-4*a*c)/2*a;
        double x2=-(b/2*a)-Math.sqrt(b^2-4*a*c)/2*a;
        System.out.println("根为x1=" + x1 + ",x2=" + x2);
    }
}

我有一个学校的java大作业，需要实现addplayer familyname，surname，username 来添加player

scanner是默认空格分割字符的 你可以把3个数隔一个空格输入，然后依次存进数组里

String[] s;
while (s.hasNext()) {
    System.out.println(s.next());
    s[]=s.next();
}

自己改改看

推荐文章