文章提供了几个Java类的设计示例，包括汽车类、形状类（三角形、矩形、圆形）以及模拟小球碰撞的场景。在汽车类中，定义了司机、发动机、乘客和车轮等属性，并实现了乘客上下车和汽车运行的逻辑。形状类中，三角形、矩形和圆形分别计算周长和面积，三角形还需判断是否能构成有效形状。在小球碰撞问题中，基于数轴的线段，描述了小球的运动规则和碰撞处理算法。
1. 补全java代码
class Body{
//此处代码省略
} //车身类
class Passenger{
//此处代码省略
} //乘客类
class Wheel
{
//此处代码省略
} //车轮类
class Driver{ //司机类
public String name; //表示第几路公交车司机
public Driver(String driverName){
name = driverName;
}
}
class Engine{ //发动机类
public String engineNo; //发动机编号
public Engine(String engineNo){
this.engineNo = engineNo;
}
}
public class car{ //汽车类
static final int (1) =7; //定义最多载客数
static final int MAX_WHEELS=5; //定义最多轮胎数
private int number = 0; //车上乘客数量
protected Engine engine;
protected Driver driver;
protected Body body = new Body();
protected wheel[] wheels;
protected Passenger[]passengers;
public Car(Driver driver){ //构造函数
(2) .driver = driver;
engine = new Engine("TX6536型号引擎");
wheels = new Wheel[MAX_WHEELS];
passengers = new Passenger[MAX_PASSENGERS];
for(int index =0; index <MAX_WHEELS; index++){
wheels[index] = new wheel();
}
for(int index =0; index <MAX_PASSENGERS; index++){
passengers[index] = null;
}
}
public int getPassengerNumber(){ //获取车上乘客数量
（3）
}
public void getOnPassenger(Passenger aPassenger）{ //乘客上车
（4）
}
public void run{ //开车
if( (5) ){
systern.out.printIln("司机尚未上车!");
return;
}
System.out.println("车子在开动!")
}
}
public class Program{
public static void main( String args[]){
Driver driver = new Driver("第五路公交车司机");
car car =new Car( (6) );
for (int index = 0 ; index < MAX_PASSENGERS; index ++)
car. getOnPassenger( (7) Passenger());
car.run();
}
}
（1） MAX_PASSENGERS - 这是定义了最多载客数的静态常量，表示车辆最多能够同时搭载的乘客人数。
（2）this - 关键字“this”表示当前对象，“this.driver”是指Car类中的driver属性。
（3）return number; - 这段代码返回车上乘客数量（number属性）。
（4）passengers[number] = aPassenger; number++; - 这段代码将传入的aPassenger添加到passengers数组中，并增加车上乘客数量（number属性）。
（5）driver == null - 如果driver属性为null，则表示司机尚未上车，不能开车。
（6）driver - 这里将Driver实例作为参数传递给Car构造函数，以便初始化车辆时设置司机属性。
（7）new - 这里使用关键字“new”创建一个新的Passenger实例，并将其传递给getOnPassenger()方法，以便将其添加到passengers数组中。
在Java中，使用 “static final int” 来定义一个只读的常量（constant）。其中：
static 表示该常量属于类，而不是对象实例。
final 表示该常量的值不能被修改。
int 表示该常量的数据类型为整型。
下面是一个例子：
public class MyClass {
public static final int MY_CONSTANT = 123;
}
在其他类中可以通过 MyClass.MY_CONSTANT 访问该常量。
2.设计一组形状类
【问题描述】
编写一个java应用程序，该程序中有3个类：Triangle,Rectangle和Circle,分别用来刻画“三角形”、“矩形”和“圆形”。具体要求如下：
l Triangle类具有类型为double的三条边属性，具有返回周长、面积以及修改三个边的方法。另外，Triangle类还具有一个boolean型的属性，该属性用来判断三个数能否构成一个三角形。
l Rectangle类具有类型为double的宽、高属性，具有返回周长和面积的方法。
l Circle类具有类型为double的半径属性，具有返回周长、面积的方法。
class Triangle{
private double sideA,sideB,sideC;
private boolean boo;
public Triangle(double a,double b,double c){
sideA=a;
sideB=b;
sideC=c;
boo = judge(a,b,c);
}
public double getPerimeter(){
if(boo)
{
return(sideA+sideB+sideC);
}
else
{
System.out.println("error,can not calculate perimeter");
return 0;
}
}
public double getArea(){
if(boo){
double p=(sideA+sideB+sideC)/2.0;
double area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC));
return area;
}else{
System.out.println("error,can not calculate area");
return 0;
}
}
public void setABC(double a,double b,double c){
sideA = a; sideB = b; sideC = c;
boo = judge(a,b,c);
}
public boolean judge(double a,double b,double c){
if((a+b>c)&&(a+c>b)&&(b+c>a)&&(a-b<c)&&(a-c<b)&&(b-c<a)){
return true;
}else{
return false;
}
}
}
class Rectangle{
private double width,height;
Rectangle(double width,double height){
this.width=width;
this.height=height;
}
public double getPerimeter(){
return 2*(width+height);
}
public double getArea(){
return width*height;
}
}
class Circle{
private double radius;
public Circle(double radius){
this.radius=radius;
}
public double getArea(){
return Math.PI * radius * radius;
}
public double getPerimeter(){
return Math.PI * 2 * radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
public class ShapeTest {
public static void main(String[] args){
double perimeter,area;
Circle c=null;
Triangle t;
Rectangle r;
c=new Circle(5) ;
t=new Triangle(6,8,10) ;
r=new Rectangle(7,3) ;
perimeter=c.getPerimeter() ;
System.out.printf("circle's perimeter:%.2f",perimeter);
area=c.getArea();
System.out.printf("circle's area:%.2f",area);
perimeter=t.getPerimeter() ;
System.out.println("triangle's perimeter:"+perimeter);
area=t.getArea() ;
System.out.println("triangle's area:"+area);
perimeter=r.getPerimeter() ;
System.out.println("rectangle's perimeter:"+perimeter);
area= r.getArea() ;
System.out.println("rectangle's area:"+area);
t.setABC(12,34,1);
area=t.getArea();
System.out.println("triangle's area:"+area);
perimeter=t.getPerimeter();
System.out.println("triangle's perimeter:"+perimeter);
}
}
3.设计三角形类
【问题描述】
在平面坐标系中，不在一条直线上的三个点确定一个三角形，设计点Point类，由点类组合创建三角形类Triangle，设计要求：
点类Point
属性：
x,y坐标
方法：
（1）两个参数的构造方法
（2）计算与另一点的距离方法
三角形类Triangle
属性：
三个点
三个边
方法：
（1）三个参数的构造方法
（2）判断三个点能否构成一个合法三角形
（3）计算周长方法
（4）计算面积方法
【输入形式】
一行6个由空格隔开的点数，依次表示三个点的坐标
【输出形式】
两行，第一行周长，第二行面积。（当三点不能构成一个三角形时，输出一行相关信息，在下一行输出0）
【样例输入1】
0 0 3 0 3 4
【样例输出1】
12.00
6.00
【样例输入2】
1 1 2 2 3 3
【样例输出2】
error,can not calculate perimeter
0.00
error,can not calculate area
0.00
【样例说明】
import java.util.Scanner;
class Point
{
private double x,y;
public Point(double x,double y)
{
this.x=x;
this.y=y;
}
public double getDistance(Point o)
{
return Math.sqrt((this.x - o.x) *(this.x - o.x) +(this.y - o.y) * (this.y - o.y) );
}
}
class Triangle{
Point p1;
Point p2;
Point p3;
double a;
double b;
double c;
Triangle(Point p1, Point p2, Point p3) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
}
boolean isTriangle(Point p1, Point p2, Point p3) {
this.a = p1.getDistance(p2);
this.b = p1.getDistance(p3);
this.c = p2.getDistance(p3);
if((a+b>c)&&(a+c>b)&&(b+c>a)&&(a-b<c)&&(a-c<b)&&(b-c<a)){
return true;
}else{
return false;
}
}
double getPerimeter() {
if (isTriangle(this.p1, this.p2, this.p3)) {
return this.a + this.b + this.c;
} else {
System.out.println("error,can not calculate perimeter");
return 0;
}
}
double getArea() {
if (isTriangle(this.p1, this.p2, this.p3)) {
double s = getPerimeter() / 2;
return Math.sqrt(s * (s - this.a) * (s - this.b) * (s - this.c));
} else {
System.out.println("error,can not calculate area");
return 0;
}
}
}
public class ShapeTest {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
double x1,y1,x2,y2,x3,y3;
x1 = in.nextDouble();
y1 = in.nextDouble();
x2 = in.nextDouble();
y2 = in.nextDouble();
x3 = in.nextDouble();
y3 = in.nextDouble();
Triangle t = new Triangle(new Point(x1,y1),new Point(x2,y2),new Point(x3,y3));
System.out.printf("%.2f\n",t.getPerimeter());
System.out.printf("%.2f\n",t.getArea());
}
}
4. 碰撞的小球
【问题描述】
数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。
当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。
当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。
现在，告诉你线段的长度L，小球数量n，以及n个小球的初始位置，请你计算t秒之后，各个小球的位置。
提示：
因为所有小球的初始位置都为偶数，而且线段的长度为偶数，可以证明，不会有三个小球同时相撞，小球到达线段端点以及小球之间的碰撞时刻均为整数。
同时也可以证明两个小球发生碰撞的位置一定是整数（但不一定是偶数）。
【输入形式】
输入的第一行包含三个整数n, L, t，用空格分隔，分别表示小球的个数、线段长度和你需要计算t秒之后小球的位置。
第二行包含n个整数a1, a2, …, an，用空格分隔，表示初始时刻n个小球的位置。
【输出形式】
输出一行包含n个整数，用空格分隔，第i个整数代表初始时刻位于ai的小球，在t秒之后的位置。
【样例输入】
3 10 5
4 6 8
【样例输出】
7 9 9
【样例说明】
初始时，三个小球的位置分别为4, 6, 8。
一秒后，三个小球的位置分别为5, 7, 9。
两秒后，第三个小球碰到墙壁，速度反向，三个小球位置分别为6, 8, 10。
三秒后，第二个小球与第三个小球在位置9发生碰撞，速度反向（注意碰撞位置不一定为偶数），三个小球位置分别为7, 9, 9。
四秒后，第一个小球与第二个小球在位置8发生碰撞，速度反向，第三个小球碰到墙壁，速度反向，三个小球位置分别为8, 8, 10。
五秒后，三个小球的位置分别为7, 9, 9。
【样例输入】
10 22 30
14 12 16 6 10 2 8 20 18 4
【样例输出】
6 6 8 2 4 0 4 12 10 2
【数据的规模与约定】
对于所有评测用例，1 ≤ n ≤ 100，1 ≤ t ≤ 100，2 ≤ L ≤ 1000，0 < ai < L。L为偶数。
保证所有小球的初始位置互不相同且均为偶数。
【评分标准】
将球设计成类Ball,每个小球是一个对象，用一个对象数组来存放一组小球（如非此设计程序不得分）：
属性：
int pos; //坐标位置
int dx; //运动方向及步长,+1向右，-1向左
方法：
Ball（int pos); //构造方法
void next()； //一秒运动一次
boolean isTouch(Ball other)；//判断是否与另一球相碰
boolean reachBorder(int L) ；//判断是否到达边界
changeDir()； //改变运动方向，向左变向右，向右变向左
int getPos(); //返回当前位置
主程序思路：
（1）根据输入创建并初始化一组小球
（2）while(每秒循环一次）{
判断每个球当前有没有运动到边界，到边界的球，要改变其运动方向
判断任意两个球当前有没有碰撞，如碰撞则彼此都要改变运动方向
让每个球运动一次
}
（3）打印每个小球的位置
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int L = scanner.nextInt();
int t = scanner.nextInt();
Ball[] balls = new Ball[n];
for (int i = 0; i < n; i++) {
int pos = scanner.nextInt();
balls[i] = new Ball(pos);
}
// 每秒循环一次
int i = 0;
while ( i < t) {
// 计算球之间的碰撞
for (int j = 0; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if (balls[j].isTouch(balls[k])) {
balls[j].changeDir();
balls[k].changeDir();
}
}
}
// 判断每个球当前有没有运动到边界，到边界的球，要改变其运动方向
for (Ball ball : balls) {
if (ball.reachBorder(L)) {
ball.changeDir();
}
}
// 让每个球运动一次
for (Ball ball : balls) {
ball.next();
}
i++;
}
// 打印每个小球的位置
for (Ball ball : balls) {
System.out.print(ball.getPos() + " ");
}
}
}
class Ball {
private int pos;
private int dx;
public Ball(int pos) {
this.pos = pos;
this.dx = 1;
}
public void next() {
pos += dx;
}
public boolean isTouch(Ball other) {
return Math.abs(pos - other.pos) == 0 && dx == -other.dx;
}
public boolean reachBorder(int L) {
return pos == 0 || pos == L;
}
public void changeDir() {
dx = -dx;
}
public int getPos() {
return pos;
}
}
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
