[Java知识库]Java习题（二）

1．编写一个Java应用程序，该程序有2个类：Vehicle(机动车)和User(主类)。

Vehicle类的成员变量有：speed(速度)、power(功率)。成员方法有：speedUp(int s)—加速，speedDown(int d)—减速，setPower(int p)—设置功率，getPower()—获取功率

请按下面给出的程序模版，填写缺少的代码，完成程序。

Vehicle.java

public class Vehicle{

代码1 //声明double型变量speed

代码2 //声明int型变量power

void speedUp(int s)

{

    代码3 //将s的值累加到speed

}

void speedDown(int d)

{

    代码4 //从speed中减去d

}

void setPower(int p)

{

    代码5 //将p赋给power

}

int getPower()

{

    代码6 //返回power的值

}

double getSpeed()

{

    return speed;

}

}

User.java

public class User {

public static void main(String args[]){

    Vehicle car1,car2;

    代码7 //创建对象car1

    代码8 //创建对象car2

    car1.setPower(128);

    car2.setPower(76);

    System.out.printf("car1的功率是：%d\n", car1.getPower());

    System.out.printf("car2的功率是：%d\n", car2.getPower());

    代码9 //car1调用speedUp方法,速度增加80

    代码10 //car2调用speedUp方法,速度增加80

    System.out.printf("car1目前的速度：%f\n", car1.getSpeed());

    System.out.printf("car2目前的速度：%f\n", car2.getSpeed());

    car1.speedDown(10);

    car2.speedDown(20);

    System.out.printf("car1目前的速度：%f\n", car1.getSpeed());

    System.out.printf("car2目前的速度：%f\n", car2.getSpeed());

}

}

功能扩展：

在类中定义构造方法，构造具有不同初始值的对象。

改进speedUP()方法，限制speed的值不能超过200。

改进speedDown()方法，限制speed的值不能小于0。

增加一个刹车方法void brake()，调用它能将speed的值变为0。

public class Vehicle{
    double speed; //声明double型变量speed
    int power; //声明int型变量power
    Vehicle() //构造方法，定义初始值
    {
        speed=10;
        power=20;
    }
    void speedUp(int s)
    {
        speed+=s; //将s的值累加到speed
        if(speed>200){
            speed=200;
        }
    }
    void speedDown(int d)
    {
        speed-=d; //从speed中减去d
        if(speed<0){
            speed=0;
        }
    }
    void setPower(int p)
    {
        power=p; //将p赋给power
    }
    int getPower()
    {
        return power; //返回power的值
    }
    double getSpeed()
    {
        return speed;
    }
    void brake()
    {
        speed=0;
    }
}
public class User {
    public static void main(String args[]){
        Vehicle car1,car2;
        car1=new Vehicle(); //创建对象car1
        car2=new Vehicle();//创建对象car2
        car1.setPower(128);
        car2.setPower(76);
        System.out.printf("car1的功率是：%d\n", car1.getPower());
        System.out.printf("car2的功率是：%d\n", car2.getPower());
        car1.speedUp(80); //car1调用speedUp方法,速度增加80
        car2.speedUp(80); //car2调用speedUp方法,速度增加80
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());
        car1.speedDown(10);
        car2.speedDown(20);
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());
        car1.brake();  //car1刹车
        car2.brake();  //car2刹车
        System.out.printf("car1目前的速度：%f\n", car1.getSpeed());
        System.out.printf("car2目前的速度：%f\n", car2.getSpeed());
    }
}

2．根据下面要求，编写一个Java应用程序：

①定义类StuCard，用到类成员变量(人数)和实例成员变量：学号、姓名、性别、专业、年级、籍贯等；

②初始化的时候用到构造方法，提供两个以上构造方法；

③多个类（业务类StuCard和测试主类），用到包的概念，且分别放到不同的包中；

④用到类成员访问权限，要求类成员变量为Public，实例成员变量为Private；

⑤编写所有数据成员的访问器和修改器（共有的get和set方法）；

⑥在主类中实现对业务类StuCard的读、写、修改属性等功能。

在完成以上功能要求的情况下，可以进一步扩展。

package stu_info;
public class StuCard {
    public static int amount;
    private long id;
    private String name;
    private String gender;
    private String major;
    private String grade;
    private String address;
    public StuCard(){}
    public StuCard(long id,String name,String gender,String major,String grade,String address){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.major=major;
        this.grade=grade;
        this.address=address;
    }
    public void setId(long i){
        id=i;
    }
    public long getId(){
        return id;
    }
    public void setName(String n){
        name=n;
    }
    public String getName(){
        return name;
    }
    public void setGender(String ge){
        gender=ge;
    }
    public String getGender(){
        return gender;
    }
    public void setMajor(String m){
        major=m;
    }
    public String getMajor(){
        return major;
    }
    public void setGrade(String gr){
        grade=gr;
    }
    public String getGrade(){
        return grade;
    }
    public void setAddress(String a){
        address=a;
    }
    public String getAddress(){
        return address;
    }
    public void show(){
        System.out.print("学号="+id+','+"名字="+name+','+"性别="+gender+','+"专业="+major+','+"年级="+grade+','+"籍贯="+address+'\n');
    }
}
 
package main_stu;
import stu_info.StuCard;
public class main_stu {
    public static void main(String args[]){
        StuCard stu1=new StuCard();
        StuCard stu2=new StuCard(略);
        stu1.setId(略);
        stu1.setName(略); //写入名字
        stu1.setGender("男");
        stu1.setMajor(略);
        stu1.setGrade("大二");
        stu1.setAddress(略);
        System.out.printf("%s\n",stu1.getName()); //查看名字
        stu1.setName(略);  //修改名字
        stu1.show();
        stu2.show();
    }
}

3．用类描述计算机中CPU的速度和硬盘的容量。要求Java应用程序有4个类，名字分别是PC、CPU、HardDisk和Test，其中Test是主类。

PC类与CPU和HardDisk类关联的UML图如下：

其中，CPU类要求getSpeed()返回speed的值，要求setSpeed(int m)方法将参数m的值赋值给speed。HardDisk类要求getAmount()返回amount的值，要求setAmount(int m)方法将参数m的值赋值给amount。PC类要求setCPU(CPU c)将参数c的值赋值给cpu，要求setHardDisk(HardDisk h)方法将参数h的值赋值给HD，要求show()方法能显示cpu的速度和硬盘的容量。

主类Test的要求：

（1） main方法中创建一个CPU对象cpu，cpu将自己的speed设置为2200；

（2） main方法中创建一个HardDisk对象disk，disk将自己的amount设置为200；

（3） main方法中创建一个PC对象pc；

（4） pc调用setCPU(CPU c)方法，调用时实参是cpu；

（5） pc调用setHardDisk(HardDisk h)方法，调用时实参是disk;

（6） pc调用show()方法。

package work_3;
public class CPU {
    int speed;
    public void setSpeed(int m){
        speed=m;
    }
    public int getSpeed(){
        return speed;
    }
}
public class HardDisk {
    int amount;
    public void setAmount(int m){
        amount=m;
    }
    public int getAmount(){
        return amount;
    }
}
public class PC {
    CPU cpu;
    HardDisk HD;
    public void setCPU(CPU c){
        cpu=c;
    }
    public void setHardDisk(HardDisk h){
        HD=h;
    }
    public void show(){
        System.out.print("speed="+cpu.speed+","+"amount="+HD.amount);
    }
}
 
import work_3.CPU;
import work_3.HardDisk;
import work_3.PC;
public class Test {
    public static void main(String args[]){
        CPU cpu=new CPU();
        cpu.setSpeed(2200);
        HardDisk disk=new HardDisk();
        disk.setAmount(200);
        PC pc=new PC();
        pc.setCPU(cpu);
        pc.setHardDisk(disk);
        pc.show();
    }
}

4．共饮同井水：编写程序模拟两个村庄公用同一口井水。编写一个Village类，该类有一个静态的成员变量waterAmount，用于模拟井水的水量；实例变量peopleNumber表示村庄的人数，实例变量name表示村庄的名称。定义相应的成员方法操作成员变量。在主类Land的main()方法中创建两个村庄，设置村庄的名称、人数，通过一个村庄改变waterAmount的值，另一个村庄查看该值的结果。

提示：类变量是该类所有对象的共享数据；一般通过类方法操作类变量。

package work_4;
public class Village {
    static double waterAmout=100.0;
    int peopleNumber;
    String name;
    public void ConsumWater(double w){
        waterAmout-=w;
    }
    public double getWaterAmount(){
        return waterAmout;
    }
}
import work_4.Village;
public class Land {
    public static void main(String args[]){
        Village v1,v2;
        v1=new Village();
        v2=new Village();
        v1.name="石油1村";
        v2.name="石油2村";
        v1.peopleNumber=100;
        v2.peopleNumber=50;
        v1.ConsumWater(10.5);
        System.out.printf("%f",v2.getWaterAmount());
    }
}

5．正n边形：在一个正n边形中，所有边的长度都相同，且所有角的度数都相同（即这个多边形是等边等角的）。设计一个名为RegularPolygon的类，该类包括：

①一个名为n的int型私有数据成员表示多边形的边数；

②一个名为side的double型私有数据成员表示多边形的长度；

③一个名为x的double型私有数据成员表示多边形中点的x坐标；

④一个名为y的double型私有数据成员表示多边形中点的y坐标；

⑤一个创建带默认值（n的默认值为3，side的默认值为1，x的默认值为0，y的默认值为0）的正多边形的无参构造方法；

⑥一个能创建带指定边数和边长度，中心在（0，0）的正多边形的构造方法；

⑦一个能创建带指定边数和边长度，中心在（x，y）的正多边形的构造方法；

⑧所有数据成员的访问器和修改器（共有的get和set方法）；

⑨一个返回多边形周长的方法getPerimeter()；

⑩一个返回多边形面积的方法getArea()，计算正多边形面积的公式是：

S = (n * side *side)/(4 * tan(π/n))

编写一个测试程序，分别使用无参构造方法、RegularPolygon(6, 4)和RegularPolygon(10, 4, 5.6, 7.8)创建三个RegularPolygon对象，输出每个对象的周长和面积。

package work_5;
public class RegularPolygon {
    private int n;
    private double side;
    private double x;
    private double y;
     
    RegularPolygon(){
        n=3;
        side=1;
        x=0;
        y=0;
    }
    RegularPolygon(int n,double side){
        this.n=n;
        this.side=side;
        x=0;
        y=0;
    }
    RegularPolygon(int n,double side,double x,double y){
        this.n=n;
        this.side=side;
        this.x=x;
        this.y=y;
    }
     
    public void setN(int n){
        this.n=n;
    }
    public int getN(){
        return n;
    }
    public void setSide(double side){
        this.side=side;
    }
    public double getSide(){
        return side;
    }
    public void setX(double x){
        this.x=x;
    }
    public double getX(){
        return x;
    }  
    public void setY(double y){
        this.y=y;
    }
    public double getY(){
        return y;
    }
     
    public double getPerimeter(){
        return n*side;
    }
    public double getArea(){
        return (n*side*side)/(4*Math.tan(Math.PI/n));
    }
}
import work_5.RegularPolygon;
public class main_5 {
    public static void main(String args[]){
        RegularPolygon t1,t2,t3;
        t1=new RegularPolygon();
        t2=new RegularPolygon(6,4);
        t3=new RegularPolygon(10,4,5.6,7.8);
        System.out.printf("%f\n",t1.getPerimeter());
        System.out.printf("%f\n",t1.getArea());
        System.out.printf("%f\n",t2.getPerimeter());
        System.out.printf("%f\n",t2.getArea());
        System.out.printf("%f\n",t3.getPerimeter());
        System.out.printf("%f\n",t3.getArea());
    }
}

6．分析程序，给出运行结果

class B {

int x=100,y=200;

public void setX(int x){

    x=x;

}

public void setY(int y){

    this.y=y;

}

public int getXYSum(){

    return x+y;

}

}

public class A{

public static void main(String args[]){

    B b=new B();

    b.setX(-100);

    b.setY(-200);

    System.out.printf("sum=%d\n", b.getXYSum());

}

}

/* 首先是对B这个类的分析
 * 首先定义两个整数x,y分别初始化为100和200
 * 在B类中有三个方法，分别是设置x，设置y的值以及求x+y
 * 然后是对A这个类的分析
 * 首先创建一个属于B的对象b
 * 设置x和y为-100和-200
 * 然后输出x+y的值
 * 但是在B类的setX这个方法中没有用this.x=x，所以不能真正修改x的值
 * 所以原先是-100+（-200）=-300 结果变成了100+（-200）
 * 输出结果为-100*/

7．分析程序，给出输出结果

public class A{

public static void main(String args[]){

    B b=new B(20);

    add(b);

    System.out.printf("%d\n", b.intValue());

}

public static void add(B m){

    int t=777;

    m.setIntValue(t);

}

}

class B{

int n;

B(int n){

    this.n=n;

}

public void setIntValue(int n){

    this.n=n;

}

int intValue(){

    return n;

}

}

/* 首先是对B这个类的分析
 * 首先定义一个 整数n然后把成员变量初始化为n
 * B这个类有两个方法，一个是设置n的值，一个是返回n的值
 * 然后是对A这个类的分析
 * A中有一个类方法，是调用B的setIntValue方法把变量的值设为777
 * 然后首先创建一个属于B的对象b并初始化为20
 * 然后调用类方法
 * 最后输出b的值
 * 输出结果为777*/

8．分析程序，给出输出结果

class B{

int n;

static int sum=0;

void setN(int n){

    this.n=n;

}

int getSum(){

    for(int i=1;i<=n;i++)

        sum=sum+i;

    return sum;

}

}

public class A{

public static void main(String args[]){

    B b1=new B(),b2=new B();

    b1.setN(3);

    b2.setN(5);

    int s1=b1.getSum();

    int s2=b2.getSum();

    System.out.printf("%d\n", s1+s2);

}

}

/*首先是对B这个类的分析
 *首先定义一个 整数n和一个类变量sum=0
 *两个方法，一个设置n的值，一个返回1~n的累加结果
 *然后是对A这个类的分析
 *首先创建两个属于B的对象b1,b2并分别设置为3，5
 *然后分别计算s1=1~3的累加，s2=s1+1~5的累加
 *这里要注意，因为B中求和时使用的是static sum,所以求s2时sum的初始值=1+2+3=6
 *最后输出s1+s2的值
 *输出结果为27*/

9．程序改错：将下面给出的程序修改成正确的代码

class A{

int x=100;

static long y;

y=200;

public void f(){

    y=300;

}

public static void g(){

    x=-23;

}

}

class A{
    int x=100;
    static long y=200; //定义时直接赋值
    public void f(){
        y=300;
    }
    public void g(){   //删除static
        x=-23;
    }
}

10．程序改错：将下面给出的程序修改成正确的代码

class Tom{

private int x=120;

protected int y=20;

int z=11;

private void f(){

    x=200;

    System.out.printf("%d\n", x);

}

void g(){

    x=200;

    System.out.printf("%d\n", x);

}

}

public class A{

public static void main(String args[]){

    Tom tom=new Tom();

    tom.x=22;

    tom.y=33;

    tom.z=55;

    tom.f();

    tom.g();

}

}

class Tom{
    private int x=120;
    protected int y=20;
    int z=11;
    public void setX(int x){   //x是私有的，所以需要加一个设置x的方法
        this.x=x;
    }
    public void f(){  //方法需要public
        x=200;
        System.out.printf("%d\n", x);
    }
    void g(){
        x=200;
        System.out.printf("%d\n", x);
    }
}
public class A{
    public static void main(String args[]){
        Tom tom=new Tom();
        tom.setX(22);  //直接赋值改为调用方法赋值
        tom.y=33;
        tom.z=55;
        tom.f();
        tom.g();
    }
}