1.编写一个计算图形面积的程序，程序应当能够计算并输出矩形、圆的面积。考虑到程序的未来扩展，设计一个接口ShapeInterface，在此基础上设计实现类Rectangle（矩形类）和Circle（圆形 类），具体要求如下：
（1）Rectangle 类基本信息：宽度、高度。
（2）Cirlce 类基本信息：半径。
（3）每个图形类有多个构造方法：空构造方法、带参数的构造方法；成员变量使用private 修饰，成员方法是用public 修饰。
（4）每个图形类有计算图形面积getArea()方法，显示图形的基本信息 toString()方法，以及属性的set和get方法。
提示：PI=3.14
【试题输入输出】
编写测试类，要求分别创建一个Rectangle类和Circle类对象，从键盘读入宽、高和半径，计算各自的面积，并按照如下样例输出两个图形的信息：
import java.util.Scanner;
abstract class ShapeInterface {
public abstract double getArea();
}
class Rectangle extends ShapeInterface{
private double width;
private double height;
public Rectangle() {}
public Rectangle(double width,double height) {
this.width=width;
this.height=height;
}
@Override
public double getArea() {
return width*height;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public String toString() {
return "\n矩形的宽为"+width+"\n"+"矩形的高为"+height+"\n"+"矩形的面积为"+getArea();
}
}
class Circle extends ShapeInterface{
private double radius;
public Circle() {}
public Circle(double radius) {
this.radius=radius;
}
@Override
public double getArea() {
return radius*radius*3.14;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius=radius;
}
public String toString() {
return "\n圆形的半径为"+radius+"\n"+"圆形的面积为"+getArea();
}
}
public class Test{
public static void main(String[]args) {
Scanner input=new Scanner(System.in);
Rectangle r=new Rectangle(input.nextDouble(),input.nextDouble());
Circle c=new Circle(input.nextDouble());
input.close();
System.out.println(r.toString());
System.out.println(c.toString());
}
}
2.
根据UML图，定义抽象缴费单类Bill，实现GasBill类，定义居民燃气缴费单类。实现WaterBill类，定义居民用水缴费单类。
说明：燃气费（率）按本地普通居民燃气费2.28元/立方米计算。
燃气缴费总额 = 燃气费率(rate) * 燃气总量(volume)。
水费（率）按本地阶梯水价计算,如表1所示。
水缴费总额 = 各阶梯水价之和
每阶梯水价额 = 每阶梯水价(rate[i]) * 本阶梯水量(volume)
下表 本地居民用水阶梯水价表
编写测试程序，从键盘输入某居民的用水量和用气量，计算该居民应该缴纳的水费和燃气费的总额，按照如下样例输出结果。
import java.util.Scanner;
public class Test{
public static void main(String[]args) {
Scanner input=new Scanner(System.in);
WaterBill wb=new WaterBill();
wb.setVolume(input.nextDouble());
GasBill gb=new GasBill();
gb.setVolume(input.nextDouble());
input.close();
double a;
a=wb.getBill()+gb.getBill();
System.out.println("该居民缴费总额为"+a);
}
}
abstract class Bill{
protected double volume;
public abstract double getBill();
public Bill() {};
public Bill(double volume) {
this.volume=volume;
}
public double getVolume() {
return volume;
}
public void setVolume(double volume) {
this.volume=volume;
}
}
class WaterBill extends Bill{
private double rate[]= {5,7,9};
public WaterBill() {}
public WaterBill(double volume) {
this.volume=volume;
}
@Override
public double getBill() {
if(this.volume<=180)
return this.volume*rate[0];
else if(this.volume<=260)
return 180*rate[0]+(this.volume-180)*rate[1];
else
return 180*rate[0]+80*rate[1]+(this.volume-260)*rate[2];
}
}
class GasBill extends Bill{
private double rate=2.28;
public GasBill() {}
public GasBill(double volume) {
this.volume=volume;
}
@Override
public double getBill() {
return rate*this.volume;
}
}
3.
一个小型公司，职员有2类，第一类是按月领取薪水，第二类按照周领取薪水，请计算公司每年需要支付的员工薪水的总额。
根据上述需求，程序设计公司类Company、职员类Employee、按月领取工资的员工类MonthWorker以及按周领取工资的员工类WeekWorker类，具体说明如下：
（1）Employee类：是从所有的员工抽象得到的abstract类。
a）一个用protected修饰的String类型的name属性，描述员工的姓名；
b）一个无参的构造方法；
c）一个用于设定name属性的带参数的构造方法 Employee(String name)；
d) name属性的修改器和访问器；
e）一个公共的计算员工年薪的方法earnings()，返回值类型为double；
f）一个公共的toString()方法，用于输出员工的信息，返回值类型为String。
（2）MonthWorker类：按月领取薪水的员工，父类是Employee。
a）一个私有的double类型的monthSal属性，描述员工每月的薪水；
b）一个无参的构造方法；
c) 一个用于设定姓名和每月薪水的带参数的构造方法 MonthWorker(String name,double monthSal)；
d) monthSal属性的修改器和访问器；
e）重写父类的earnings()方法，计算员工的年薪；
f）重写父类的toString()：输出员工的信息。
(3) WeekWorker类：按周领取薪水的员工，父类是Employee。
a）一个私有的double类型的weekSal属性，描述员工每周的薪水；
b）一个无参的构造方法；
c) 一个用于设定姓名和每周薪水的带参数的构造方法 WeekWorker(String name,double weekSal)；
d) weekSal属性的修改器和访问器；
e）重写父类的earnings()方法，计算员工的年薪，假设一年52个周；
f）重写父类的toString()：输出员工的信息。
(4) Company类：公司类.
a）一个私有的Employee对象数组，用于存放公司员工，数组中的元素可以是MonthWorker对象，也可以是WeekWorker对象；
b）一个私有的用于记录员工人数的数据域numberOfWorkers,初始值为0；
c)一个无参的构造方法；
d)一个公共的用于计算公司每年需要支付的员工薪水总额的方法 computeTotalSal()，返回值为double；
e）一个公共的用于添加单个员工的方法 addEmployee(Employee e)，无返回值；
f）一个公共的toString()方法，返回公司员工信息和每年需要支付的员工薪水总额。
(1) 编写测试类TestCompany，要求如下：
a) 创建公司对象；
b）创建一个MonthWorker对象和一个WeekWorker对象，从键盘读入两个员工的姓名和薪水；
c）将两个员工添加至公司。
(2) 按照如下样例输出结果：
import java.util.Scanner;
public class TestCompany{
public static void main(String[]args) {
Scanner input=new Scanner(System.in);
Employee e1=new MonthWorker(input.next(),input.nextDouble());
Employee e2=new WeekWorker(input.next(),input.nextDouble());
Company company=new Company();
company.addEmployee(e1);
company.addEmployee(e2);
input.close();
System.out.println(company.toString());
}
}
abstract class Employee{
protected String name;
Employee(){}
Employee(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name=name;
}
public double earnings() {
return 0;
}
public String toString() {
return "姓名 "+name;
}
}
class MonthWorker extends Employee{
private double monthSal;
MonthWorker(){}
MonthWorker(String name,Double monthSal){
this.name=name;
this.monthSal=monthSal;
}
public double getMonthSal() {
return monthSal;
}
public void setMonthSal(double monthSal) {
this.monthSal = monthSal;
}
@Override
public double earnings() {
return 12*monthSal;
}
public String toString() {
return super.toString()+"\n月薪为 "+this.monthSal+"\n年薪为 "+this.earnings();
}
}
class WeekWorker extends Employee{
private double weekSal;
WeekWorker(){}
WeekWorker(String name,double weekSal){
this.name=name;
this.weekSal=weekSal;
}
public double getWeekSal() {
return weekSal;
}
public void setWeekSal(double weekSal) {
this.weekSal = weekSal;
}
@Override
public double earnings() {
return 52*weekSal;
}
public String toString() {
return super.toString()+"\n周薪为 "+this.weekSal+"\n年薪为 "+this.earnings();
}
}
class Company{
private Employee[]employees=new Employee[100];
private int numberOfWorkers=0;
Company(){}
public double computeTotalSal() {
double sum=0;
for(int i=0;i<numberOfWorkers;i++)
sum+=employees[i].earnings();
return sum;
}
public void addEmployee(Employee e) {
employees[numberOfWorkers++]=e;
}
public String toString() {
String str="";
for(int i=0;i<numberOfWorkers;i++) {
str+="\n"+employees[i].toString();
}
str+="\n\n公司年工资总额"+this.computeTotalSal();
return str;
}
}
4.
根据给定的GeometricObject类层次图，分别实现GeometricObject、Circle和Triangle类。要求：
（1）按照类图，定义各类的数据域属性和方法。
（2）默认的GeometricObject的颜色为white。默认的Circle对象的半径为10。默认的Triangle对象的三边为（3，4，5）。
（3）GeometricObject类的toString()方法，返回对象的颜色信息。Circle和Triangle的toString()方法，覆盖父类的toString()，分别返回颜色、半径或边长的信息。
（4）GeometricObject类实现java.lang.Comparable接口，覆盖public int compareTo()方法，实现两个几何对象在周长上的比较。
（5）Circle和Triangle类分别覆盖实现getPerimeter()方法。
编写一个测试程序，在main()方法中实现下述功能：
（1）创建一个几何对象数组Object[] object；
（2）分别存放两个圆和两个三角形，从键盘输入圆的半径和三角形的三条边长；
（3）计算这一组几何对象的总周长并输出；
（4）使用toString(),输出每个几何对象的相关信息；
（5）使用java.util.Arrays.sort()方法，对几何对象数组中的几何图形，按周长进行排序，并输出排序结果。
提示：此题圆周长=2 * radius * Math.PI
输出样例如下：
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
GeometricObject[] object = { new Circle(input.nextDouble()),new Circle(input.nextDouble()),new Triangle(input.nextDouble(),input.nextDouble(),input.nextDouble()),new Triangle(input.nextDouble(),input.nextDouble(),input.nextDouble())};
input.close();
double totalPerimeter = 0;
for(GeometricObject go:object)
totalPerimeter += go.getPerimeter();
System.out.println("所有图形的总周长是" + totalPerimeter + "\n");
for(GeometricObject go:object)
System.out.println(go.toString());
java.util.Arrays.sort(object);
for(int i = 0; i < object.length; i++)
System.out.println("第"+i+"个图形的周长是"+object[i].getPerimeter());}
}
abstract class GeometricObject implements Comparable<GeometricObject>{
private String color = "white";
protected GeometricObject() {}
protected GeometricObject(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public int compareTo(GeometricObject o){
if (this.getPerimeter() > o.getPerimeter())
return 1;
else if (this.getPerimeter() < o.getPerimeter())
return -1;
else
return 0;
}
public String toString(){
return "颜色是" + color + "\n";
}
public abstract double getPerimeter();
}
class Circle extends GeometricObject {
private double radius;
public Circle() {
this.radius = 10.0;
}
public Circle(double radius) {
this.radius = radius;
}
public Circle(String color, double radius){
super(color);
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
@Override
public double getPerimeter() {
return 2 * radius * Math.PI;
}
public String toString() {
return super.toString() + "圆的半径是" + radius + "\n";
}
}
class Triangle extends GeometricObject{
private double side1;
private double side2;
private double side3;
public Triangle() {
this.side1 = 3.0;
this.side2 = 4.0;
this.side3 = 5.0;
}
public Triangle(double side1 ,double side2, double side3){
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public Triangle(String color,double side1 ,double side2, double side3){
super();
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
@Override
public double getPerimeter(){
return side1 + side2 + side3;
}
@Override
public String toString(){
return super.toString() + "三角形的三条边是" + side1 + " "+ side2 + " "+ side3 +"\n";
}
}