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();
}
}