Java基础编程作业3

最新推荐文章于 2024-07-10 21:37:49 发布

Lucilla1027

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量1.5k

点赞数 2

分类专栏： Java学习笔记文章标签： java

本文链接：https://blog.csdn.net/SLXii/article/details/116202063

版权

Java学习笔记专栏收录该内容

3 篇文章 2 订阅

订阅专栏

1-IntReceiver类可以接受指定范围内的整数值

IntReceiver类可以接受指定范围内的整数值，具有下面四个属性:
最大的可接受值
最小的可接受值
输入提示字符串
错误消息字符串
并具有一个方法:
getValue()，功能是显示输入提示字符串，然后读取键盘输入的-一个整数。如果读取的
值不在允许范围内，则显示错误消息字符串，并重新要求用户输入一个新值，重复以上步骤
直到输入了一个可接受的值。最后返回读取到的整数。
要求编程实现IntReceiver类，使给定的Test类能正常运行，并实现指定的输出内容。

import java.util.Scanner;
public class IntReceiver {
    private int max = 100;
    private int min = 0;
    private String warningStr = "invalid input!";
    private String inputStr = "input an integer:";

    public int getValue() {
        int temp;
        Scanner in = new Scanner(System.in);
        System.out.print(inputStr);
        temp = in.nextInt();
        while (temp < min || temp > max) {
            System.out.println(warningStr);
            System.out.print(inputStr);
            temp = in.nextInt();
        }
        return temp;
    }
}

 class Test{
    public static void main(String[] args)

    {

        IntReceiver ir = new IntReceiver();

        int value;

        value = ir.getValue();

        System.out.println("The value is "+value);

    }
}

2-汽车类

一辆Car有(has)四个轮子(Wheels)和一个发动机(Engine)。现在要求用组合方法设计类Car、类Wheel和类Engine.

(1) 类Engine 有字符串属性type记录发动机的型号，有构造方法，可设置发动机的型号有方法start()启动引擎(输出下面样例中包含发动机型号和“starts”的字符串)

(2)类Wheel有字符串属性type记录轮胎的型号，有整数类型属性index记录当前轮胎编号(1:front-left，2:front-right，3:back-left，4:back-right)，有构造方法，可设置轮胎的型号和编号，有方法roll()表示轮胎正在转动(输出下面样例中包含轮胎型号、轮胎位置和“rolling”的字符串)

(3)类Car有字符串属性model记录轿车的型号，有属性wheels[]和engine，分别是Wheel类对象数组和Engine类对象，有构造方法，参数是三个字符串，分别表示轿车的型号、轮胎型号和发动机的型号，有方法changeWheel()可以改变指定轮胎的型号，有方法start()，先输出下面样例中包含轿车型号和“firing”的字符串，然后调用engine的start()，再调用所有轮胎的roll()，最后显示轿车型号和“running”。

要求编程实现类Car、类Wheel和类Engine，使给定的Test类能正常运行，并实现指定的输出内容。

class Engine{
    String type;
    Engine(){

    }
    Engine(String type){
        this.type = type;
    }
    void start() {
        System.out.println("Engine" + "<" + type + ">" + "  starts!");
    }
}

class Wheel{
    String type;
    int index;
    public Wheel(){

    }
    public Wheel(int a,String b){
        index = a;
        type = b;
    }
    public void roll() {
        switch (index) {
            case 1:
                System.out.println("Wheel front-left " + "<" +type +">"+ " is rolling");
                break;
            case 2:
                System.out.println("Wheel front-right " + "<" +type +">"+ " is rolling");
                break;
            case 3:
                System.out.println("Wheel back-left " + "<" +type +">"+ " is rolling");
                break;
            case 4:
                System.out.println("Wheel back-right " + "<" +type +">"+ " is rolling");
                break;
            default:
                System.out.println("error\n");
                break;
        }

    }
}
class Car{
    String model;
    Wheel[] Wheels = new Wheel[4];//实例化数组
    Engine engine=new Engine();//实例化Engine

    public Car(String model, String Wheelstype, String engine) {
        this.model = model;
        for(int i=0;i<4;i++)
        {
            Wheels[i]=new Wheel(i+1,Wheelstype);
        }//实例化数组成员
        this.engine.type = engine;
    }

    void changeWheel(int a, String type) {
        Wheels[a - 1].type = type;
    }

    void start() {
        System.out.println("Car" + "<" + model +">"+ " is firing!");
        engine.start();
        for (int i = 0; i < 4; i++) {
            Wheels[i].roll();
        }
        System.out.println("Car" + "<" + model +">"+ " is running");
    }

}
public class Test01 {
    public static void main(String[] args){
        String wheel="BridgeStone";
        String model="BMW";
        String engine="Mode L";
        Car car1=new Car(model,wheel,engine);
        car1.start();

        System.out.println("=================");

        model="Benz";
        engine="Model S";
        Car car2=new Car(model,wheel,engine);
        car2.changeWheel(2,"Michelin");
        car2.start();
    }
}

3-Money类

编写Money类，要求具有yuan, jiao, fen三个int类型的属性及相应的置取方法，所表示的金额分别按元角分保存在各个属性中。

另外，还具有以下方法：

1 具有重载的四个set()方法，具体要求如下：

（1）参数为int类型，将参数值存入yuan, jiao和fen都置为0；

（2）参数为double类型，将参数值按分做四舍五入，然后分别存入对应的属性；

（3）参数为字符串String，对字符串中的数字做解析后，按分做四舍五入，将金额分别存入对应的属性；

（4）参数为Money类的对象，将参数中的金额分别存入对应的属性。

2 有两个可实现金额计算的方法

（1） times(int n)方法，参数为int，返回值为Money类对象，其中的总金额为当前对象的总金额乘以参数n

（2） add(Money money)方法，参数为Money类对象，返回值为Money类对象，其中的总金额为当前对象的总金额加上参数money中的总金额。

3 有一个静态方法，按照指定格式输出总金额

writeOut(String owner, Money money)方法，输出格式如“owner have/has XX Yuan XX Jiao XX Fen.”的字符串，所输出的的金额是参数money中的总金额。

字符串转浮点数可以使用静态方法：Double.parseDouble(String)。

要求编程实现类Money，使给定的Test类能正常运行，并实现指定的输出内容。

class Money{

    private int jiao;
    private int fen;
    private int yuan;

    public Money(){
    }
    public void set(int yuan){
        this.yuan=yuan;
        this.jiao=0;
        this.fen=0;
    }
    public void  set(double yuan){
        double f = Double.parseDouble(String.format("%.2f", yuan));
        int b=(int)(f*100);
        this.yuan=(int)(b/100);
        this.jiao=((int)(b/10))%10;
        this.fen=b%10;
    }
    public  void set(String yuan){
        double f = Double.parseDouble(yuan);
        int b=(int)(f*100);
        this.yuan=(int)(b/100);
        this.jiao=((int)(b/10))%10;
        this.fen=b%10;
    }
    public  void set(Money yuan){
        this.yuan=yuan.yuan;
        this.jiao=yuan.jiao;
        this.fen=yuan.fen;
    }
    public  Money times(int n){
        double a;
        Money c=new Money();
        a=n*(this.yuan+this.jiao*0.1+this.fen*0.01);
        int b=(int)(a*100);
        c.yuan=(int)(b/100);
        c.jiao=((int)(b/10))%10;
        c.fen=b%10;
        return c;
    }
    public Money add(Money money){
        Money d=new Money();
        d.yuan=money.yuan+this.yuan;
        d.jiao=money.jiao+this.jiao;
        d.fen=money.fen+this.fen;
        while (d.fen>10)
        {
            d.jiao++;
            d.fen=d.fen-10;
        }
        while (d.jiao>10)
        {
            d.yuan++;
            d.jiao=d.jiao-10;
        }

        return d;
    }
    public static void writeOut(String owner, Money money){
        System.out.println(owner+" have/has "+money.yuan+" Yuan "+money.jiao+" Jiao "+money.fen+" Fen.");
    }

}
public class Test02 {
    public static void main(String[] args){

        Money myMoney = new Money();

        Money yourMoney = new Money();

        Money hisMoney = new Money();

        Money herMoney = new Money();



        int amountInt=365;

        double amountDouble=254.686;

        String amountString="368.244";



        myMoney.set(amountInt);

        Money.writeOut("I",myMoney);



        yourMoney.set(amountDouble);

        Money.writeOut("You",yourMoney);



        hisMoney.set(amountString);

        Money.writeOut("He",hisMoney);



        herMoney.set(myMoney);

        Money.writeOut("She",herMoney);



        herMoney = yourMoney.times(3);

        Money.writeOut("She",herMoney);



        herMoney = yourMoney.add(hisMoney);

        Money.writeOut("She",herMoney);



        System.out.println("Remember: A penny saved is a penny earned.");

    }
}

4-MyMath类

已知公式如下图，编程求f(x,y,z)的值，在Test类中实现x，ｙ，ｚ值的输入及结果的输出。
在这里插入图片描述

编写MyMath类，实现静态的4个重载方法f(),分别计算不同的函数值，使给定的Test类能正常运行，并实现指定的输出内容。

import java.util.Scanner;
class MyMath{
    public static int f(){
        return 0;
    }
    public static int f(int x){
        return x*x;
    }
    public static int f(int x,int y){
        return x*x + y*y;
    }
    public static int f(int x,int y,int z){
        return x*x + y*y +z*z;
    }

}
public class Test03 {
    public static void main(String[] args){

        int x, y, z;

        Scanner in = new Scanner(System.in);

        x = in.nextInt();

        y = in.nextInt();

        z = in.nextInt();

        in.close();



        int result;

        if (x < 0) {

            result = MyMath.f();

        } else if (x >= 0 && y < 0) {

            result = MyMath.f(x);

        } else if (x >= 0 && y >= 0 && z < 0) {

            result = MyMath.f(x, y);

        } else {

            result = MyMath.f(x, y, z);

        }

        System.out.println(result);

    }
}

Lucilla1027

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Java基础编程作业3

1-IntReceiver类可以接受指定范围内的整数值IntReceiver类可以接受指定范围内的整数值，具有下面四个属性:最大的可接受值最小的可接受值输入提示字符串错误消息字符串并具有一个方法:getValue()，功能是显示输入提示字符串，然后读取键盘输入的-一个整数。如果读取的值不在允许范围内，则显示错误消息字符串，并重新要求用户输入一个新值，重复以上步骤直到输入了一个可接受的值。最后返回读取到的整数。要求编程实现IntReceiver类，使给定的Test类能正常运行，并实现指定的
复制链接

扫一扫