sdut-Java面向对象-06 继承和多态、抽象类和接口（编程：1-10题）
定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：1.接口名字为USB，里面包括两个抽象方法：描述可以工作描述停止工作2.完成类Mouse，实现接口USB，实现两个方法：work方法输出“我点点点”；stop方法输出 “我不能点了”；3.完成类UPan，实现接口USB，实现两个方法：work方法输出“我存存存”；stop方法输出 “我走了”；4测试类Main中，main方法中。
·
7-1 sdut-oop-5 计算长方体和四棱锥的表面积和体积（类的继承）
分数 10
作者 周雪芹
单位 山东理工大学
计算如下立体图形的表面积和体积。
从图中观察，可抽取长方体和四棱锥两种立体图形的共同属性到父类Rect中：长度：l 宽度：h 高度：z。
编程要求：
（1）在父类Rect中，定义求底面周长的方法length( )和底面积的方法area( )。
（2）定义父类Rect的子类立方体类Cubic，计算立方体的表面积和体积。其中表面积area( )重写父类的方法。
（3）定义父类Rect的子类四棱锥类Pyramid，计算四棱锥的表面积和体积。其中表面积area( )重写父类的方法。
（4）在主程序中，输入立体图形的长(l)、宽(h)、高(z)数据，分别输出长方体的表面积、体积、四棱锥的表面积和体积。
提示：
（1）四棱锥体积公式：V=31Sh，S——底面积 h——高
（2）在Java中，利用Math.sqrt(a)方法可以求得a的平方根（方法的参数及返回结果均为double数据类型）
（3）在Python中，利用math模块的sqrt(a)方法，求得a的平方根。
输入格式:
输入多行数值型数据（double）；
每行三个数值，分别表示l、h、z，数值之间用空格分隔。
若输入数据中有0或负数，则不表示任何图形，表面积和体积均为0。
输出格式:
行数与输入相对应，数值为长方体表面积 长方体体积 四棱锥表面积 四棱锥体积（中间有一个空格作为间隔，数值保留两位小数）。
输入样例:
1 2 3
0 2 3
-1 2 3
3 4 5
输出样例:
22.00 6.00 11.25 2.00
0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00
94.00 60.00 49.04 20.00实现代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
//每行读入3个数
double l = sc.nextDouble();
double h = sc.nextDouble();
double z = sc.nextDouble();
//构造长方体对象
Cubic cubic=new Cubic(l,h,z);
//构造四棱锥对象
Pyramid pyramid=new Pyramid(l, h, z);
//格式化数据
String area1=String.format("%.2f", cubic.area());
String volumn1=String.format("%.2f", cubic.volumn());
String area2=String.format("%.2f", pyramid.area());
String volumn2=String.format("%.2f", pyramid.volumn());
//输出数据
System.out.println(area1+" "+volumn1+" "+area2+" "+volumn2);
}
}
}
/**
* 长方体类
* @author Administrator
*
*/
class Cubic extends Rect {
public Cubic(double l, double h, double z) {
super(l, h, z);
}
/**
* 长方体表面积,重写父类方法
*/
public double area() {
return 2 * super.area() + length() * z;
}
/**
* 长方体体积，子类新增方法
*/
public double volumn() {
return super.area() * z;
}
}
/*** 四棱锥类
* @author Administrator
*
*/
class Pyramid extends Rect {
public Pyramid(double l, double h, double z) {
super(l, h, z);
}
/**
* 四棱锥表面积,重写父类方法
*/
public double area() {
return super.area()
+ l * Math.sqrt(z * z + h * h / 4)
+ h * Math.sqrt(z * z + l * l / 4);
}
/**
* 四棱锥体积，子类新增方法
*/
public double volumn() {
return super.area() * z / 3;
}
}
/**
* 父类
* @author Administrator
*
*/
class Rect {
double l;
double h;
double z;
public Rect(double l, double h, double z) {
if (l > 0 && h > 0 && z > 0) {
this.l = l;
this.h = h;
this.z = z;
}
}
public Rect(int l) {
this(l, l, l);
}
public Rect() {
}
/**
* 计算长方形底面周长
*/
public double length() {
return 2 * (l + h);
}/**
* 长方形底面面积
*
* @return
*/
public double area() {
return l * h;
}
}7-2 sdut-oop-6 计算各种图形的周长（多态）
定义接口或类 Shape，定义求周长的方法length()。
定义如下类，实现接口Shape或父类Shape的方法。
（1）三角形类Triangle （2）长方形类Rectangle （3）圆形类Circle等。
定义测试类ShapeTest，用Shape接口（或类）定义变量shape，用其指向不同类形的对象，输出各种图形的周长。并为其他的Shape接口实现类提供良好的扩展性。
提示： 计算圆周长时PI取3.14。
输入格式:
输入多组数值型数据（Python类型float，Java类型double）；
一行中若有1个数，表示圆的半径；
一行中若有2个数（中间用空格间隔），表示长方形的长度、宽度。
一行中若有3个数（中间用空格间隔），表示三角形的三边的长度。（需要判断三个边长是否能构成三角形）
若输入数据中有0或负数，则不表示任何图形，周长为0。
输出格式:
行数与输入相对应，数值为根据每行输入数据求得的图形的周长。
输入样例:
在这里给出一组输入。例如：
1
2 3
4 5 6
2
-2
-2 -3
输出样例:
在这里给出相应的输出。例如：
6.28
10.00
15.00
12.56
0.00
0.00实现代码：
import java.util.Scanner;
interface Shape{//定义Shape接口，接口中包含求周长的length()方法
public double length();
}
class Triangle implements Shape{
double a,b,c;
public Triangle() {
}
public Triangle(double a, double b, double c) {
this.a = a;
this.b = b;
this.c = c;
}
public double length(){
if(a<=0||b<=0||c<=0) return 0;
else if(a+b>c&&a+c>b&&b+c>a)
{
return a+b+c;
}
return 0;
}
}
class Rectangle implements Shape{
double a,b;
public Rectangle() {
}
public Rectangle(double a, double b) {
this.a = a;
this.b = b;
}
public double length(){
if(a<=0||b<=0) return 0;
else return (a+b)*2;
// return 0;
}
}
class Circle implements Shape{
double r;
public Circle() {
}
public Circle(double r) {
this.r = r;
}
public double length()
{
if(r<=0) return 0;
else return 2*3.14*r;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
while(Scan.hasNext())
{
Shape shape=null;//???
String s=Scan.nextLine();
String []as=s.split(" ");//
int num=as.length;
if(num==1)
{
double r=Double.parseDouble(as[0]);//
shape=new Circle(r);
}
else if(num==2)
{
double a=Double.parseDouble(as[0]);
double b=Double.parseDouble(as[1]);
shape=new Rectangle(a,b);
}
else if(num==3)
{
double a=Double.parseDouble(as[0]);
double b=Double.parseDouble(as[1]);
double c=Double.parseDouble(as[2]);
shape=new Triangle(a,b,c);
}
if(shape!=null)
{
double l=shape.length();//me
String ss=String.format("%.2f",l);
System.out.println(ss);
}
// else
// {
// System.out.println("0.00");
// }
}
}
}7-3 jmu-Java-04面向对象进阶--02-接口-Comparator
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。
1.编写PersonSortable2类
属性：private name(String)、private age(int)
有参构造函数：参数为name,age
toString方法：返回格式name-age
2 编写Comparator类
- 编写
NameComparator类，实现对name进行升序排序 - 编写
AgeComparator类，对age进行升序排序
3.main方法中
- 输入n
- 输入n行name age，并创建n个对象放入数组
- 对数组按照name进行升序排序后输出。
- 在3的基础上对数组按照age进行升序排序后输出。
- 最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17
输出样例:
NameComparator:sort
Wang-17
li-17
wang-14
zhang-15
zhang-12
AgeComparator:sort
zhang-12
wang-14
zhang-15
Wang-17
li-17
//最后两行是标识信息
实现代码：
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
class PersonSortable2{
public String name;
public int age;
public PersonSortable2(String name, int age) {
this.name = name;
this.age = age;
}
// public String getName() {
// return name;
// }
//
// public void setName(String name) {
// this.name = name;
// }
//
// public int getAge() {
// return age;
// }
//
// public void setAge(int age) {
// this.age = age;
// }
public String toString(){
return name+"-"+age;
}
}
class NameComparator implements Comparator<PersonSortable2>{
public int compare(PersonSortable2 o1,PersonSortable2 o2){
int result=o1.name.compareTo(o2.name);
if(result>0) return 1;
else if(result<0) return -1;
else return result;
}
}
class AgeComparator implements Comparator<PersonSortable2> {
public int compare(PersonSortable2 o1,PersonSortable2 o2){
if(o1.age<o2.age) return -1;//此处是关键，关乎输出时年龄相同时的输出顺序
else return 1;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int n=Scan.nextInt();
PersonSortable2 []a=new PersonSortable2[n];
for(int i=0;i<n;i++)
{
String name=Scan.next();
int age=Scan.nextInt();
a[i]=new PersonSortable2(name,age);
}
Arrays.sort(a,new NameComparator());
System.out.println("NameComparator:sort");
for(PersonSortable2 i:a)
{
System.out.println(i.toString());
}
Arrays.sort(a,new AgeComparator());
System.out.println("AgeComparator:sort");
for(PersonSortable2 i:a)
{
System.out.println(i.toString());
}
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
}
}7-4 USB接口的定义
定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：
1.接口名字为USB，里面包括两个抽象方法：
void work（）；描述可以工作
void stop(); 描述停止工作
2.完成类Mouse，实现接口USB，实现两个方法：
work方法输出“我点点点”；
stop方法输出 “我不能点了”；
3.完成类UPan，实现接口USB，实现两个方法：
work方法输出“我存存存”；
stop方法输出 “我走了”；
4测试类Main中，main方法中
定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法
定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。
输入格式:
输出格式:
输出方法调用的结果
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
我点点点
我不能点了
我存存存
我走了
我点点点
我不能点了实现代码：
import java.util.Scanner;
interface USB{
public void work();
public void stop();
}
class Mouse implements USB{
@Override
public void work() {
System.out.println("我点点点");
}
@Override
public void stop() {
System.out.println("我不能点了");
}
}
class UPan implements USB{
@Override
public void work() {
System.out.println("我存存存");
}
@Override
public void stop() {
System.out.println("我走了");
}
}
public class Main
{
public static void main(String[] args) {
USB usb1=new Mouse();
usb1.work();
usb1.stop();
USB []usb2=new USB[2];
usb2[0]=new UPan();
usb2[1]=new Mouse();
for(int i=0;i<2;i++)
{
usb2[i].work();
usb2[i].stop();
}
}
}7-5 sdut-oop-7 答答租车系统（类的继承与多态 面向对象综合练习）
各位面向对象的小伙伴们，在学习了面向对象的核心概念——类的封装、继承、多态之后，答答租车系统开始营运了。
请你充分利用面向对象思想，为公司解决智能租车问题，根据客户选定的车型和租车天数，来计算租车费用，最大载客人数，最大载载重量。
公司现有三种车型（客车、皮卡车、货车），每种车都有名称和租金的属性；其中：客车只能载人，货车只能载货，皮卡车是客货两用车，即可以载人，也可以载货。
下面是答答租车公司的可用车型、容量及价目表：
要求：根据客户输入的所租车型的序号及天数，计算所能乘载的总人数、货物总数量及租车费用总金额。
输入格式:
首行是一个整数：代表要不要租车 1——要租车（程序继续），0——不租车（程序结束）；
第二行是一个整数，代表要租车的数量N；
接下来是N行数据，每行2个整数m和n，其中：m表示要租车的编号，n表示租用该车型的天数。
输出格式:
若成功租车，则输出一行数据，数据间有一个空格，含义为：
载客总人数 载货总重量（保留2位小数） 租车金额（整数）
若不租车，则输出：
0 0.00 0（含义同上）
输入样例:
1
2
1 1
2 2
输出样例:
在这里给出相应的输出。例如：
15 0.00 1600实现代码：
import java.util.Scanner;
class Car{
protected int id;
protected int rent;
public Car(int id, int rent) {
this.id = id;
this.rent = rent;
}
public Car() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getRent() {
return rent;
}
public void setRent(int rent) {
this.rent = rent;
}
}
class PeopleCar extends Car{
private int num1;//载客量
public PeopleCar(int id, int num1, int rent) {
super(id, rent);
this.num1 = num1;
}
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
}
class PickCar extends Car{
private int num1;//载客量
private double num2;//载货量
public PickCar(int id, int num1 ,double num2, int rent) {
super(id, rent);
this.num1 = num1;
this.num2 = num2;
}
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public double getNum2() {
return num2;
}
public void setNum2(double num2) {
this.num2 = num2;
}
}
class Truck extends Car{
private double num2;
public Truck(int id, double num2,int rent ) {
super(id, rent);
this.num2 = num2;
}
public double getNum2() {
return num2;
}
public void setNum2(double num2) {
this.num2 = num2;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
Car []c={
new PeopleCar(1,5,800),
new PeopleCar(2,5,400),
new PeopleCar(3,5,800),
new PeopleCar(4,51,1300),
new PeopleCar(5,55,1500),
new PickCar(6,5,0.45,500),
new PickCar(7,5,2.0,450),
new Truck(8,3,200),
new Truck(9,25,1500),
new Truck(10,35,2000)
};
int t=Scan.nextInt();
int sum1=0;//总人数
double sum2=0;//载货总量
int sum3=0;//总租金
// if(t==0){
// System.out.println("0 0.00 0");
// }
if(t==1){
int n=Scan.nextInt();
// int sum1=0;//总人数
// double sum2=0;//载货总量
// int sum3=0;//总租金
for(int i=0;i<n;i++)
{
int id=Scan.nextInt();
int day=Scan.nextInt();
if(c[id-1] instanceof PeopleCar)//如果这个id是客车
{
sum1=sum1+((PeopleCar) c[id-1]).getNum1()*day;
sum3=sum3+c[id-1].getRent()*day;
}
else if(c[id-1] instanceof PickCar)
{
sum1=sum1+((PickCar) c[id-1]).getNum1()*day;
sum2=sum2+((PickCar) c[id-1]).getNum2()*day;
sum3=sum3+c[id-1].getRent()*day;
}
else if(c[id-1] instanceof Truck){
sum2=sum2+((Truck) c[id-1]).getNum2()*day;
sum3=sum3+c[id-1].getRent()*day;
}
}
// System.out.printf("%d %.2f %d",sum1,sum2,sum3);
}
System.out.printf("%d %.2f %d",sum1,sum2,sum3);
Scan.close();
}
}7-6 jmu-Java-03面向对象基础-04-形状-继承
前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似
shape.getClass()// 获得对象类型shape.getClass().getSuperclass()// 获得对象父类型
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
- 你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
- 是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape
实现代码：
import java.util.Objects;
import java.util.Scanner;
abstract class Shape{
final double PI=3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
class Rectangle extends Shape{
int width,length;
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public Rectangle() {
}
@Override
public double getPerimeter() {
return 2*(width+length);
}
@Override
public double getArea() {
return width*length;
}
}
class Circle extends Shape{
int radius;
public Circle() {
}
public Circle(int radius) {
this.radius = radius;
}
@Override
public double getPerimeter() {
return 2*PI*radius;
}
@Override
public double getArea() {
return PI*radius*radius;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int n=Scan.nextInt();
Shape []A=new Shape[n];
double sumAllArea=0;
double sumAllPerimeter=0;
for(int i=0;i<n;i++)
{
String s=Scan.next();
if(Objects.equals(s, "rect"))
{
int width=Scan.nextInt();
int length=Scan.nextInt();
Shape shape1= new Rectangle(width,length);
A[i]=shape1;
sumAllPerimeter=sumAllPerimeter+shape1.getPerimeter();
sumAllArea=sumAllArea+shape1.getArea();
}
else if(Objects.equals(s, "cir"))
{
int radius=Scan.nextInt();
Shape shape2=new Circle(radius);
A[i]=shape2;
sumAllPerimeter=sumAllPerimeter+shape2.getPerimeter();
sumAllArea=sumAllArea+shape2.getArea();
}
}
System.out.println(sumAllPerimeter);
System.out.println(sumAllArea);
System.out.print("[");
for(int i=0;i<n;i++)
{
if(i!=0) System.out.print(",");
if(A[i]instanceof Rectangle)
{
if(i==0) System.out.print("Rectangle ");
else System.out.print(" Rectangle ");
System.out.print("[width="+((Rectangle) A[i]).width+", length="+((Rectangle) A[i]).length+"]");
}
else if(A[i]instanceof Circle)
{
if(i==0) System.out.print("Circle ");
else System.out.print(" Circle ");
System.out.print("[radius="+((Circle) A[i]).radius+"]");
}
}
System.out.print("]");
System.out.println();
for(int i=0;i<n;i++)
{
System.out.println(A[i].getClass()+","+A[i].getClass().getSuperclass());
}
}
}7-7 jmu-Java-03面向对象基础-05-覆盖
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。
1. 新建PersonOverride类
a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。
b. 有参构造方法，参数为name, age, gender
c. 无参构造方法，使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true
d.toString()方法返回格式为：name-age-gender
e. equals方法需比较name、age、gender，这三者内容都相同，才返回true.
2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。
提示：使用ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:
1
3
zhang 10 true
zhang 10 true
zhang 10 false
输出样例:
default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]
实现代码：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
class PersonOverride{
private String name;
private int age;
private boolean gender;
public PersonOverride() {
this.name = "default";
this.age = 1;
this.gender = true;
}
public PersonOverride(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String toString(){
return name+"-"+age+"-"+gender;
}
public boolean equals(Object o)
{
if(this==o) return true;
if(o==null||this.getClass()!=o.getClass()) return false;
PersonOverride oo=(PersonOverride) o;
if(!this.name.equals(((PersonOverride) o).name)||this.age!=((PersonOverride) o).age||this.gender!=((PersonOverride) o).gender) return false;
return true;
}
}
public class Main{
public static void main(String[] args) {
Scanner Scan=new Scanner(System.in);
int n1=Scan.nextInt();
PersonOverride []person1=new PersonOverride[n1];
for(int i=0;i<n1;i++)
{
person1[i]=new PersonOverride();
}
int n2=Scan.nextInt();
ArrayList<PersonOverride> ss=new ArrayList<PersonOverride>();
for(int i=0;i<n2;i++)
{
String name=Scan.next();
int age=Scan.nextInt();
boolean gender=Scan.nextBoolean();
PersonOverride pp=new PersonOverride(name,age,gender);
if(ss.size()==0) ss.add(pp);
else {
boolean flag=true;
for(int j=0;j<ss.size();j++)
{
if(ss.get(j).equals(pp)) {
flag = false;
break;
}
}
if(flag) ss.add(pp);
}
}
for(int i=0;i<n1;i++) System.out.println(person1[i].toString());
for(int i=0;i<ss.size();i++) System.out.println(ss.get(i).toString());
System.out.println(ss.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}7-8 设计圆和圆柱体
编写一个完整的Java Application 程序。包含类Circle、Cylinder、Main，具体要求如下。
（1）编写类Circle，表示圆形对象，包含以下成员
①属性：
1) radius：私有，double型，圆形半径；
②方法：
1) Circle(double radius), 构造方法,用参数设置圆的半径
2) Circle(),构造方法，将圆形初始化为半径为0。
3) void setRadius(double r)：用参数r设置radius的值
4) double getRadius()：返回radius的值
5) double getArea()，返回圆形的面积
6) double getPerimeter()，返回圆形的周长
7) public String toString( )，将把当前圆对象的转换成字符串形式，例如圆半径为10.0，返回字符串"Circle(r:10.0)"。
（2）编写一个类Cylinder，表示圆柱形对象，包含以下成员
①属性：
1) height：私有，double型，圆柱体高度；
2) circle：私有，Circle类型，圆柱体底面的圆形；
②方法：
1) Cylinder(double height，Circle circle), 构造方法,用参数设置圆柱体的高度和底面的圆形
2) Cylinder(),构造方法，将圆柱体的高度初始化为0，底面圆形初始化为一个半径为0的圆形。
3) void setHeight(double height)：用参数height设置圆柱体的高度
4) double getHeight()：返回圆柱体的高度
5) void setCircle(Circle circle)：用参数circle设置圆柱体底面的圆形
6) Circle getCircle()：返回圆柱体底面的圆形
7) double getArea()，重写Circle类中的area方法，返回圆柱体的表面积
8) double getVolume()，返回圆柱体的体积
9) public String toString( )，将把当前圆柱体对象的转换成字符串形式，例如半径为10.0，高为5.0，返回字符串"Cylinder(h:5.0,Circle(r:10.0))"。
（3）编写公共类Main,在main()方法中实现如下功能
输入一个整数n，表示有n个几何图形。
对于每一个几何图形，先输入一个字符串，“Circle”表示圆形，“Cylinder”表示圆柱体。
如果是圆形，输入一个浮点数表示其半径。要求计算其面积和周长并输出。
如果是圆柱体，输入两个浮点数分别表示其半径和高度。要求计算其面积和体积并输出。
将以下代码附在自己的代码后面：
public class Main{
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for(int i = 0; i < n; i++) {
String str = input.next();
if(str.equals("Circle")) {
Circle c = new Circle(input.nextDouble());
System.out.println("The area of " + c.toString() + " is " + String.format("%.2f",c.getArea()));
System.out.println("The perimeterof " + c.toString() + " is "+ String.format("%.2f",c.getPerimeter()));
} else if(str.equals("Cylinder")) {
Cylinder r = new Cylinder(input.nextDouble(), new Circle(input.nextDouble()));
System.out.println("The area of " + r.toString() + " is " + String.format("%.2f",r.getArea()));
System.out.println("The volume of " + r.toString() + " is " + String.format("%.2f",r.getVolume()));
}
}
}
}
输入格式:
第一行输入一个整数n，表示有n个几何图形。
以下有n行，每行输入一个几何图形的数据。
每行先输入一个字符串表示几何图形的类型，“Circle”表示圆形，“Cylinder”表示圆柱体。
如果是圆形，输入一个浮点数表示其半径。
如果是圆柱体，输入两个浮点数分别表示其半径和高度。
输出格式:
如果是圆形，要求计算其面积和周长并输出。
如果是圆柱体，要求计算其面积和体积并输出。
注意，圆周率用Math.PI
输入样例:
在这里给出一组输入。例如：
4
Circle 10.0
Cylinder 10.0 10.0
Circle 1.1
Cylinder 1.1 3.4
输出样例:
在这里给出相应的输出。例如：
The area of Circle(r:10.0) is 314.16
The perimeterof Circle(r:10.0) is 62.83
The area of Cylinder(h:10.0,Circle(r:10.0)) is 1256.64
The volume of Cylinder(h:10.0,Circle(r:10.0)) is 3141.59
The area of Circle(r:1.1) is 3.80
The perimeterof Circle(r:1.1) is 6.91
The area of Cylinder(h:1.1,Circle(r:3.4)) is 96.13
The volume of Cylinder(h:1.1,Circle(r:3.4)) is 39.95
实现代码：
import java.util.Scanner;
class Circle{
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public Circle() {
this.radius=0;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public double getArea(){
return Math.PI*radius*radius;
}
public double getPerimeter(){
return 2*Math.PI*radius;
}
public String toString(){
return "Circle(r:"+radius+")";
}
}
class Cylinder{
private double height;
private Circle circle;
public Cylinder(double height, Circle circle) {
this.height = height;
this.circle = circle;
}
public Cylinder() {
this.height=0;
this.circle=new Circle(0);
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public Circle getCircle() {
return circle;
}
public void setCircle(Circle circle) {
this.circle = circle;
}
public double getArea(){
return circle.getArea()*2+ circle.getPerimeter()*height;
}
public double getVolume(){
return circle.getArea()*height;
}
public String toString(){
return "Cylinder(h:"+height+",Circle(r:"+circle.getRadius()+"))";
}
}
public class Main{
public static void main(String args[]) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
for(int i = 0; i < n; i++) {
String str = input.next();
if(str.equals("Circle")) {
Circle c = new Circle(input.nextDouble());
System.out.println("The area of " + c.toString() + " is " + String.format("%.2f",c.getArea()));
System.out.println("The perimeterof " + c.toString() + " is "+ String.format("%.2f",c.getPerimeter()));
} else if(str.equals("Cylinder")) {
Cylinder r = new Cylinder(input.nextDouble(), new Circle(input.nextDouble()));
System.out.println("The area of " + r.toString() + " is " + String.format("%.2f",r.getArea()));
System.out.println("The volume of " + r.toString() + " is " + String.format("%.2f",r.getVolume()));
}
}
}
}7-9 职工排序题
1． 为某保险公司设计一个职工管理系统，其中职工类的属性有：职工编号，姓名，性别，团体险业绩，个体险业绩；方法有：
每个属性对应的set，get方法；
不带参数的构造方法；
带参数的构造方法，完成对职工属性的初始化；
该类实现接口Comparable，完成对职工总业绩的比较。
2． 设计一个类，实现Comparator接口，完成对团体险业绩的比较；
3． 在Main类中，创建一个职工的线性表，分别完成对职工线性表按照总业绩升序排序，按照团体险业绩升序排序。
注意：不要设计键盘输入职工信息，可根据样例中提供的数据直接创建职工对象；
输入格式:
输出格式:
各项之间用逗号“,”分隔
输入样例:
在这里给出一组输入。例如：
输出样例:
在这里给出相应的输出。例如：
编号,团险,个险,姓名,性别
1,500,400,职工1,female
3,600,300,职工3,male
2,400,600,职工2,female
4,800,200,职工4,female
5,500,700,职工5,male
编号,团险,个险,姓名,性别
2,400,600,职工2,female
1,500,400,职工1,female
5,500,700,职工5,male
3,600,300,职工3,male
4,800,200,职工4,female实现代码：
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Worker[] a = new Worker[5];
a[0] = new Worker(1,500,400,"职工1","female");
a[1] = new Worker(2,400,600,"职工2","female");
a[2] = new Worker(3,600,300,"职工3","male");
a[3] = new Worker(4,800,200,"职工4","female");
a[4] = new Worker(5,500,700,"职工5","male");
System.out.println("编号,团险,个险,姓名,性别");
Arrays.sort(a,new zongyejiComparator());
for(Worker w :a){
System.out.println(w);
}
System.out.println("编号,团险,个险,姓名,性别");
Arrays.sort(a,new tyejiComparetor());
for(Worker w :a){
System.out.println(w);
}
}
}
class Worker{
int id;
String name;
String gender;
int tyeji;
int gyeji;
public Worker(int id,int tyeji,int gyeji,String name,String gender){
this.id = id;
this.name = name;
this.gender = gender;
this.tyeji = tyeji;
this.gyeji = gyeji;
}
public String toString(){
return id+","+tyeji+","+gyeji+","+name+","+gender;
}
}
class zongyejiComparator implements Comparator<Worker>{
public int compare(Worker a , Worker b){
if(a.tyeji+a.gyeji>b.tyeji+b.gyeji) return 1;
else if(a.tyeji+a.gyeji< b.tyeji+b.gyeji) return -1;
else return 0;
}
}
class tyejiComparetor implements Comparator<Worker>{
public int compare(Worker a,Worker b){
if(a.tyeji>b.tyeji) return 1;
else if(a.tyeji<b.tyeji) return -1;
else return 0;
}
}7-10 横平竖直
程序填空题。根据题目要求完善下面的代码。请提交完整代码。
一个木块如果高度比宽度大，我们说它是竖着放的，否则我们说它是平放的。
读入一个木块的高度和宽度。如果它是平放的，则输出A，否则输出B。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int height, width;
char status;
height = in.nextInt();
width = in.nextInt();
Board board = new Board(height, width);
status = board.getStatus();
System.out.print(status);
}
}
class Board{
int height, width;
public Board(int height, int width){
this.height = height;
this.width = width;
}
public char getStatus(){
if(height<=width){
return status(1);
}else{
return status(1.0);
}
}
public char status(double rate){
}
public char status(int rate){
}
}
输入格式:
输入在一行中给出2个绝对值不超过1000的正整数A和B。
输出格式:
在一行中输出一个字符A或者B。
输入样例:
50 50
输出样例:
A实现代码：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int height, width;
char status;
height = in.nextInt();
width = in.nextInt();
Board board = new Board(height, width);
board.getStatus();
}
}
class Board{
int height, width;
public Board(int height, int width){
this.height = height;
this.width = width;
}
public void getStatus(){
if(height<=width){
System.out.println("A");
}else{
System.out.println("B");
}
}
}
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
16
0- 0
已为社区贡献4条内容
所有评论(0)