pta 题目集 4 5 6 心得体会
一．前言
题目集4题目数量较少 难度偏难
题目集5题目数量适中 难度偏难
题目集6题目量较多 前面题目比较容易所占分值较少后面两题较难所占分值多
二．设计与分析
题目集4
题目4的知识点主要是对类和继承的考查
7-2 日期问题面向对象设计（聚合一） (35 分)
参考题目7-2的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
- 当输入有误时，输出格式如下： Wrong Format
- 当第一个数字为1且输入均有效，输出格式如下：
输出格式:
year-month-day
- 当第一个数字为2且输入均有效，输出格式如下：
year-month-day
- 当第一个数字为3且输入均有效，输出格式如下：
天数值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
2312
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2 1935 2 17 125340
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
1591-12-17
结尾无空行
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
2017-2-24
结尾无空行
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
结尾无空行
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
源代码：
import java.util.Scanner;
//Year类
class Year{
int value;
//默认构造方法
public Year(){
}
//带参构造方法
public Year(int value){
this.value=value;
}
//getter
public int getValue(){
return value;
}
//setter
public void setValue(int value){
this.value=value;
}
//判断year是否为闰年
public boolean isLeapYear(){
if((value%4==0&&value%100!=0)||value%400==0)
return true;
else
return false;
}
//效验数据合法性
public boolean validate(){
if(value<=2050&&value>=1900)
return true;
else
return false;
}
//年份加一
public void yearIncrement(){
value=value+1;
}
//年份减一
public void yearReduction(){
value=value-1;
}
}
//Month类
class Month{
int value;
Year year;
//默认构造方法
public Month(){
}
//带参构造方法
public Month(int yearValue,int monthValue){
this.year=new Year(yearValue);
this.value=monthValue;
}
//getter
public int getValue(){
return value;
}
public Year getYear(){
return year;
}
//setter
public void setValue(int value){
this.value=value;
}
public void setYear(Year year){
this.year=year;
}
//日期复位(1)
public void resetMin(){
value=1;
}
//月份设置为12
public void resetMax(){
value=12;
}
//效验数据合法性
public boolean validate(){
if(value>=1&&value<=12)
return true;
else
return false;
}
//月份加一
public void dayIncrement(){
value=value+1;
}
//月份减一
public void dayReduction(){
value=value-1;
}
}
//Day类
class Day{
int value;
Month month;
int a[]={31,28,31,30,31,30,31,31,30,31,30,31};
//默认构造方法
public Day(){
}
//带参构造方法
public Day(int yearValue,int monthValue,int dayValue){
this.month=new Month(yearValue,monthValue);
this.value=dayValue;
}
//getter
public int getValue(){
return value;
}
public Month getMonth(){
return month;
}
//setter
public void setValue(int value){
this.value=value;
}
public void setMonth(Month value){
this.month=value;
}
//日期复位(1)
public void resetMin(){
value=1;
}
//日期设为该月最大值
public void resetMax(){
value=a[month.getValue()-1];
}
//效验数据合法性
public boolean validate(){
if(this.getMonth().getYear().isLeapYear())
a[1]=29;
if(value>=1&&value<=a[month.getValue()-1])
return true;
else
return false;
}
//日期加一
public void dayIncrement() {
value=value+1;
}
//日期减一
public void dayReduction() {
value=value-1;
}
}
//DateUtil类
class DateUtil{
Day day;
//默认构造方法
public DateUtil(){
}
//带参构造方法
public DateUtil(int d,int m,int y){
this.day=new Day(d,m,y);
}
//getter
public Day getDay(){
return day;
}
//setter
public void setDay(Day d){
this.day=d;
}
//效验数据合法性
public boolean checkInputValidity(){
if(this.getDay().getMonth().getYear().validate()&&this.getDay().getMonth().validate()&&day.validate())
return true;
else
return false;
}
//比较两个日期大小
public boolean compareDates(DateUtil date) {
if(date.getDay().getMonth().getYear().getValue()<this.getDay().getMonth().getYear().getValue())
return false;
else if(date.getDay().getMonth().getYear().getValue()==this.getDay().getMonth().getYear().getValue()&&date.getDay().getMonth().getValue()<this.getDay().getMonth().getValue())
return false;
else if(date.getDay().getMonth().getYear().getValue()==this.getDay().getMonth().getYear().getValue()&&date.getDay().getMonth().getValue()==this.getDay().getMonth().getValue()&&date.getDay().getValue()<this.getDay().getValue())
return false;
else
return true;
}
//判定两个日期是否相等
public boolean equalTwoDates(DateUtil date){
if(this.getDay().getValue()==date.getDay().getValue()&&this.getDay().getMonth().getValue()==date.getDay().getMonth().getValue()&& this.getDay().getMonth().getYear().getValue()==date.getDay().getMonth().getYear().getValue())
return true;
else
return false;
}
//日期值格式化
public String showDate(){
return this.getDay().getMonth().getYear().getValue()+"-"+this.getDay().getMonth().getValue()+"-"+this.getDay().getValue();
}
//计算该年的剩余天数
public int syts(DateUtil d){
int a[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int b=0,i;
for(i=d.getDay().getMonth().getValue()+1;i<=12;i++){
b=b+a[i];
}
b=b+a[d.getDay().getMonth().getValue()]-d.getDay().getValue();
if(d.getDay().getMonth().getYear().isLeapYear()&&d.getDay().getMonth().getValue()<=2)//闰年
b++;
return b;
}
//求下n天
public DateUtil getNextNDays(int n){
int a[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int y=0,m=0,d=0;
int i,j;
int b=syts(this);//该年剩余天数
if(b>n){//该年剩余天数大于n
y=this.getDay().getMonth().getYear().getValue();
if(this.getDay().getMonth().getYear().isLeapYear()){//如果是闰年
a[2]=29;
}
int e=a[this.getDay().getMonth().getValue()];//该月的天数
e=e-this.getDay().getValue();//本月剩余的天数
if(e>=n){//如果n天后在本月
m=this.getDay().getMonth().getValue();
d=n+this.getDay().getValue();
}
else{//如果n天后不在本月
n=n-e;
m=this.getDay().getMonth().getValue()+1;
i=m;
while(n-a[i]>0&&i<=12){//找到月
n=n-a[i];
m++;
i++;
}
d=n;//找到天
}
}
else{//该年剩余天数小于n
n=n-b;
y=this.getDay().getMonth().getYear().getValue()+1;
int c=365;//平年天数
if(new Year(y).isLeapYear()){//闰年天数
c++;
}
while(n-c>0){//找到年
n=n-c;
y++;
c=365;
if(new Year(y).isLeapYear())
c++;
}
i=1;
while(n-a[i]>0&&i<=12){//找到月
n=n-a[i];
i++;
}
m=i;
d=n;//找到天
}
return new DateUtil(y, m, d);
}
//求前n天
public DateUtil getPreviousNDays(int n){
int a[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int y=0,m=0,d=0;
int i,b;
b=365-syts(this);//该日期所在年份已经过的天数
if(this.getDay().getMonth().getYear().isLeapYear()){//如果是闰年
b++;
}
if (b>n){//如果前n天在该年
y=this.getDay().getMonth().getYear().getValue();
int e=this.getDay().getValue();//本月已经过的天数
if(e>n){//如果前n天在本月
m=this.getDay().getMonth().getValue();
d=e-n;
}
else{//如果前n天不在本月
n=n-e;
m=this.getDay().getMonth().getValue()-1;
i=m;
while(n-a[i]>0&&i>=0){//找到月
n=n-a[i];
m--;
i--;
}
d=a[i]-n;//找到天
if(new Year(y).isLeapYear()&&m==2){
d++;
}
}
}
else{//如果前n天不在该年
n=n-b;
y=this.getDay().getMonth().getYear().getValue()-1;
int f=365;
if(new Year(y).isLeapYear()){
f++;
}
while(n-f>0){//找到年
n=n-f;
y--;
f=365;
if(new Year(y).isLeapYear())
f++;
}
i=12;
while(n-a[i]>0&&i>=0){//找到月
n=n-a[i];
i--;
}
m=i;
d=a[i]-n;//找到天
if(new Year(f).isLeapYear()&&m==2){
d++;
}
}
return new DateUtil(y, m, d);
}
//求两个日期之间的天数
public int getDaysofDates(DateUtil date){
DateUtil b1=this;
DateUtil b2=date;
if(this.equalTwoDates(date)){//如果两天的日期相等
return 0;
}
else if(!this.compareDates(date)){//如果日期大小不对
b1=date;
b2=this;
}
int a[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int i,j,ts=0;
for(i=b1.getDay().getMonth().getYear().getValue()+1;i<b2.getDay().getMonth().getYear().getValue();i++){//两个日期的年数之和
ts=ts+365;
if(new Year(i).isLeapYear())
ts++;
}
if(b1.getDay().getMonth().getYear().getValue()==b2.getDay().getMonth().getYear().getValue()&&b1.getDay().getMonth().getValue()==b2.getDay().getMonth().getValue()){//年份相同，月份相同，日不同
ts=b2.getDay().getValue()-b1.getDay().getValue();
}
else if(b1.getDay().getMonth().getYear().getValue()==b2.getDay().getMonth().getYear().getValue()&&b1.getDay().getMonth().getValue()!=b2.getDay().getMonth().getValue()){//年份相同，月份不同
if(b1.getDay().getMonth().getYear().isLeapYear())//是闰年
a[2]=29;
ts=ts+a[b1.getDay().getMonth().getValue()]-b1.getDay().getValue();//小日期该月剩余的天数
ts=ts+b2.getDay().getValue();//大日期的天数
for(j=b1.getDay().getMonth().getValue()+1;j<=b2.getDay().getMonth().getValue()-1;j++)//月份天数和
ts+=a[j];
}
else if(b1.getDay().getMonth().getYear().getValue()!=b2.getDay().getMonth().getYear().getValue()){//年份不同
ts=ts+a[b1.getDay().getMonth().getValue()]-b1.getDay().getValue();//小日期在该月剩余的天数
ts=ts+b2.getDay().getValue();//大日期在该月已经过的天数
for(j=b1.getDay().getMonth().getValue()+1;j<=12;j++)//小日期在该年剩余的天数
ts=ts+a[j];
for(j=b2.getDay().getMonth().getValue()-1;j>0;j--)//大日期在该年已经过的天数
ts=ts+a[j];
if(b1.getDay().getMonth().getYear().isLeapYear()&&b1.getDay().getMonth().getValue()<=2)//如果小日期该年为闰年且该天在1月或2月
ts++;
if(b2.getDay().getMonth().getYear().isLeapYear()&&b2.getDay().getMonth().getValue()>2)//如果大日期该年为闰年且该天在1月或2月后
ts++;
}
return ts;
}
}
//主类
public class Main {
public static void main(String[] args) {
Scanner x=new Scanner(System.in);
int year=0,month=0,day=0,a,b;
a=x.nextInt();//输入判断类型
year=x.nextInt();month= x.nextInt();day=x.nextInt();//输入年月日
DateUtil c=new DateUtil(year,month,day);
if(a==1){//求下n天
b=x.nextInt();//输入n
if(!c.checkInputValidity()||b<0){//如果数据不合法
System.out.println("Wrong Format");
System.exit(0);
}
else
System.out.println(c.getNextNDays(b).showDate());
}
else if(a==2){
b=x.nextInt();//输入n
if(!c.checkInputValidity()||b<0){//如果数据不合法
System.out.println("Wrong Format");
System.exit(0);
}
else
System.out.println(c.getPreviousNDays(b).showDate());
}
else if(a==3){
int y1,m1,d1;
y1=x.nextInt();m1= x.nextInt();d1=x.nextInt();//输入第二个年月日
DateUtil d=new DateUtil(y1,m1,d1);
if(!c.checkInputValidity()||!d.checkInputValidity()){//如果数据不合法
System.out.println("Wrong Format");
System.exit(0);
}
else
System.out.println(c.getDaysofDates(d));
}
else
System.out.println("Wrong Format");
}
}
题目集5
7-5 日期问题面向对象设计（聚合二） (40 分)
参考题目7-3的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：
应用程序共测试三个功能：
- 求下n天
- 求前n天
- 求两个日期相差的天数
注意：严禁使用Java中提供的任何与日期相关的类与方法，并提交完整源码，包括主类及方法（已提供，不需修改）
输入格式:
有三种输入方式（以输入的第一个数字划分[1,3]）：
- 1 year month day n //测试输入日期的下n天
- 2 year month day n //测试输入日期的前n天
- 3 year1 month1 day1 year2 month2 day2 //测试两个日期之间相差的天数
- 当输入有误时，输出格式如下： Wrong Format
- 当第一个数字为1且输入均有效，输出格式如下：
输出格式:
year1-month1-day1 next n days is:year2-month2-day2
- 当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1 previous n days is:year2-month2-day2
- 当第一个数字为3且输入均有效，输出格式如下：
The days between year1-month1-day1 and year2-month2-day2 are:值
输入样例1:
在这里给出一组输入。例如：
3 2014 2 14 2020 6 14
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
The days between 2014-2-14 and 2020-6-14 are:2312
结尾无空行
输入样例2:
在这里给出一组输入。例如：
2 1834 2 17 7821
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
1834-2-17 previous 7821 days is:1812-9-19
结尾无空行
输入样例3:
在这里给出一组输入。例如：
1 1999 3 28 6543
结尾无空行
输出样例3:
在这里给出相应的输出。例如：
1999-3-28 next 6543 days is:2017-2-24
结尾无空行
输入样例4:
在这里给出一组输入。例如：
0 2000 5 12 30
结尾无空行
输出样例4:
在这里给出相应的输出。例如：
Wrong Format
源代码：
通过这两个类图可以看出，聚合（一）中类DateUtil和其他三个类都有聚集关系，而聚合（二）中是单独两个类中有聚集关系。从代码实现的角度来说，聚合（一）的优点在于在实例化对象时，它不用去new每一个类，只需要new一个Day对象就能调用其他类的属性方法，而它的缺点就在于访问其他类的属性和方法时，需要写一长串来调用，如访问年属性就要date.day.getMonth().getYear().value ，较为麻烦。而聚合（二）的优点就在于它的调用就很简洁，访问年就直接year.getValue()就行，缺点在于实例化对象时要new多个对象，较为麻烦。
题目集4（7-3）、题目集6（7-5、7-6）三种渐进式图形继承设计的思路与技术运用（封装、继承、多态、接口等）
题目集4 7-3
-3 图形继承 (15 分)
编写程序，实现图形类的继承，并定义相应类对象并进行测试。
- 类Shape，无属性，有一个返回0.0的求图形面积的公有方法public double getArea();//求图形面积
- 类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积
- 类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积
- 类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法public double getVolume();//求球体积
- 类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法public double getVolume();//求立方体体积
- 注意：
- 每个类均有构造方法，且构造方法内必须输出如下内容：Constructing 类名
- 每个类属性均为私有，且必须有getter和setter方法（可用Eclipse自动生成）
- 输出的数值均保留两位小数
主方法内，主要实现四个功能（1-4）： 从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积； 从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积； 从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积； 从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；
假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format
输入格式:
共四种合法输入
- 1 圆半径
- 2 矩形宽、长
- 3 球半径
- 4 立方体宽、长、高
输出格式:
按照以上需求提示依次输出
输入样例1:
在这里给出一组输入。例如：
1 1.0
结尾无空行
输出样例1:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Circle
Circle's area:3.14
结尾无空行
输入样例2:
在这里给出一组输入。例如：
4 3.6 2.1 0.01211
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Constructing Shape
Constructing Rectangle
Constructing Box
Box's surface area:15.26
Box's volume:0.09
结尾无空行
输入样例3:
在这里给出一组输入。例如：
2 -2.3 5.110
结尾无空行
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
结尾无空行
类图
源代码：
import java.util.Scanner;
public class Main {
public static void main (String[] args)
{
Scanner input = new Scanner(System.in);
int a=input.nextInt();
if(a==1)
{
float r=input.nextFloat();
if(r<0.00)
{
System.out.print("Wrong Format");
}
else {
Circle circle=new Circle();
circle.setRadius(r);
System.out.println(String.format("Circle's area:%.2f",circle.getArea()));
}
}
else if(a==2)
{
float w=input.nextFloat();
float l=input.nextFloat();
if(w<0.0||l<0.0)
{
System.out.print("Wrong Format");
}
else {
Rectangle rectangle=new Rectangle();
rectangle.setLength(l);
rectangle.setWidth(w);
System.out.println(String.format("Rectangle's area:%.2f",rectangle.getArea()));}
}
else if(a==3) {
double r2=input.nextDouble();
if(r2<0.0) {
System.out.println("Wrong Format");
}
else {
Ball ball=new Ball();
ball.setRadius(r2);
System.out.println(String.format("Ball's surface area:%.2f",ball.getArea()));
System.out.println(String.format("Ball's volume:%.2f",ball.getVolume()));
}
}
else if(a==4)
{
double width2=input.nextDouble();
double length2=input.nextDouble();
double height=input.nextDouble();
if(width2<0.0||length2<0.0||height<0.0) {
System.out.println("Wrong Format");
}
else {
Box box=new Box();
box.setHeight(height);
box.setWidth(width2);
box.setLength(length2);
System.out.println(String.format("Box's surface area:%.2f",box.getArea()));
System.out.println(String.format("Box's volume:%.2f",box.getVolume()));
}
}
else
{
System.out.print("Wrong Format");
}
}
}
class Shape
{
public Shape()
{
System.out.print("Constructing Shape\n");
}
public double getVolume()
{
return 0.0;
}
}
class Circle extends Shape
{
public Circle()
{
System.out.print("Constructing Circle\n");
}
private double radius;
public void setRadius(double radius)
{
this.radius=radius;
}
public double getRadius()
{
return radius;
}
public double getArea()
{
return Math.PI*radius*radius;
}
}
class Rectangle extends Shape
{
public Rectangle()
{
System.out.print("Constructing Rectangle\n");
}
private double width;
private double length;
public void setWidth(double width)
{
this.width=width;
}
public void setLength(double length)
{
this.length=length;
}
public double getWidth()
{
return width;
}
public double getLength()
{
return length;
}
public double getArea()
{
return width*length;
}
}
class Ball extends Circle
{
public Ball()
{
System.out.print("Constructing Ball\n");
}
public double getArea()
{
return 4.0*super.getArea();
}
public double getVolume()
{
double r2=getRadius();
return (4.0/3.0)*r2*super.getArea();
}
}
class Box extends Rectangle
{
private double height;
public Box()
{
System.out.print("Constructing Box\n");
}
public void setHeight(double height)
{
this.height=height;
}
public double getHeight()
{
return height;
}
public double getArea()
{
double w2=getWidth();
double l2=getLength();
return 2*(height*w2+height*l2+w2*l2);
}
public double getVolume()
{
return height*super.getArea();
}
}
题目集6 7-5
7-5 图形继承与多态 (50 分)
掌握类的继承、多态性及其使用方法。具体需求参见作业指导书。
输入格式:
从键盘首先输入三个整型值（例如a b c），分别代表想要创建的Circle、Rectangle及Triangle对象的数量，然后根据图形数量继续输入各对象的属性值（均为实型数），数与数之间可以用一个或多个空格或回车分隔。
输出格式:
- 如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边关系），则输出Wrong Format。
- 如果输入合法，则正常输出，输出内容如下（输出格式见输入输出示例）：
- 各个图形的面积；
- 所有图形的面积总和；
- 排序后的各个图形面积；
- 再次所有图形的面积总和。
源代码：import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
class gongjv implements Comparator<Double>{
@Override
public int compare(Double o1, Double o2) {
if(o1>o2) {
return 1;
}else if(o1<o2) {
return -1;
}else
return 0;
}
}
class Circle{
double 半径;
public boolean 是否合法() {
if(this.半径>0) {
return true;
}else {
return false;
}
}
public Circle(double 半径) {
super();
this.半径 = 半径;
}
public double 求面积(){
return Math.PI*半径*半径;
}
}
class Rectangle{
double 长,宽;
public boolean 是否合法() {
if(this.宽>0&this.长>0) {
return true;
}else {
return false;
}
}
public Rectangle(double 长, double 宽) {
super();
this.长 = 长;
this.宽 = 宽;
}
public double 求面积(){
return 宽*长;
}
}
class Triangle{
double a,b,c;
public Triangle(double a, double b, double c) {
super();
this.a = a;
this.b = b;
this.c = c;
}
public double 求面积(){
return Math.sqrt((a+b+c)*(a+b-c)*(a+c-b)*(b+c-a))/4;
}
public boolean 是否符合三边关系() {
double a[] = new double[3];
a[0] = this.a;
a[1] = this.b;
a[2] = this.c;
Arrays.sort(a);
if (a[0] + a[1] > a[2]) {
return true;
} else {
return false;
}
}
}
public class Main {
public static void main(String[] args) {
Scanner se = new Scanner(System.in);
int 圆形个数 = se.nextInt();
int 矩形个数 = se.nextInt();
int 三角形个数 = se.nextInt();
if (圆形个数 >= 0 & 矩形个数 >= 0 & 三角形个数 >= 0) {
Circle c[] = new Circle[圆形个数];
Rectangle r[] = new Rectangle[矩形个数];
Triangle t[] = new Triangle[三角形个数];
ArrayList <Double> 面积表=new ArrayList<Double>();
for (int i = 0; i < 圆形个数; i++) {
c[i] = new Circle(se.nextDouble());
if (c[i].是否合法() == false) {
System.out.println("Wrong Format");
System.exit(0);
}
面积表.add(c[i].求面积());
}
for (int i = 0; i < 矩形个数; i++) {
r[i] = new Rectangle(se.nextDouble(), se.nextDouble());
if (r[i].是否合法() == false) {
System.out.println("Wrong Format");
System.exit(0);
}
面积表.add(r[i].求面积());
}
for (int i = 0; i < 三角形个数; i++) {
t[i] = new Triangle(se.nextDouble(), se.nextDouble(), se.nextDouble());
if (t[i].是否符合三边关系() == false) {
System.out.println("Wrong Format");
System.exit(0);
}
面积表.add(t[i].求面积());
}
System.out.println("Original area:");
输出所有面积(面积表);
System.out.printf("Sum of area:%.2f\n",求所有面积(面积表));
Collections.sort(面积表, new gongjv());
System.out.println("Sorted area:");
for(double i:面积表) {
System.out.printf("%.2f ",i);
}
System.out.println();
System.out.printf("Sum of area:%.2f\n",求所有面积(面积表));
}
else {
System.out.println("Wrong Format");
}
}
public static double 求所有面积(ArrayList <Double> 面积表){
double a = 0;
for (double i:面积表) {
a=a+i;
}
return a;
}
public static void 输出所有面积(ArrayList <Double> 面积表) {
for (double i:面积表) {
System.out.printf("%.2f ",i);
}
System.out.println();
}
}
7-6 实现图形接口及多态性 (30 分)
编写程序，使用接口及类实现多态性，类图结构如下所示：
其中：
- GetArea为一个接口，无属性，只有一个GetArea（求面积）的抽象方法；
- Circle及Rectangle分别为圆类及矩形类，分别实现GetArea接口
- 要求：在Main类的主方法中分别定义一个圆类对象及矩形类对象（其属性值由键盘输入），使用接口的引用分别调用圆类对象及矩形类对象的求面积的方法，直接输出两个图形的面积值。（要求只保留两位小数）
输入格式:
从键盘分别输入圆的半径值及矩形的宽、长的值，用空格分开。
输出格式:
- 如果输入的圆的半径值及矩形的宽、长的值非法（≤0），则输出Wrong Format
- 如果输入合法，则分别输出圆的面积和矩形的面积值（各占一行），保留两位小数。
7-6 实现图形接口及多态性 (30 分)
编写程序，使用接口及类实现多态性，类图结构如下所示：
其中：
- GetArea为一个接口，无属性，只有一个GetArea（求面积）的抽象方法；
- Circle及Rectangle分别为圆类及矩形类，分别实现GetArea接口
- 要求：在Main类的主方法中分别定义一个圆类对象及矩形类对象（其属性值由键盘输入），使用接口的引用分别调用圆类对象及矩形类对象的求面积的方法，直接输出两个图形的面积值。（要求只保留两位小数）
输入格式:
从键盘分别输入圆的半径值及矩形的宽、长的值，用空格分开。
输出格式:
- 如果输入的圆的半径值及矩形的宽、长的值非法（≤0），则输出Wrong Format
- 如果输入合法，则分别输出圆的面积和矩形的面积值（各占一行），保留两位小数。
源代码：
import java.util.Scanner;
import java.util.Arrays;
//GetArea类
interface GetArea{
public double Mj();
}
//Circle类
class Circle implements GetArea{
private double r;
//创建无参构造方法
public Circle(){
}
//创建带参构造方法
public Circle(double r){
this.r=r;
}
//getter
public double getR(){
return r;
}
//setter
public void setR(double r){
this.r = r;
}
//计算圆面积
public double Mj(){
return Math.PI*r*r;
}
}
//Rectangle类
class Rectangle implements GetArea{
private double a,b;
//创建无参构造方法
public Rectangle(){
}
//创建带参构造方法
public Rectangle(double a, double b){
this.a=a;
this.b=b;
}
//getter
public double A(){
return a;
}
public double B(){
return b;
}
//setter
public void setA(double a){
this.a=a;
}
public void setB(double b){
this.b=b;
}
//计算矩形面积
public double Mj(){
return a*b;
}
}
//主类
public class Main{
public static void main(String[] args){
Scanner x = new Scanner(System.in);
double ybj,jxc,jxk;
double yl,kp;
ybj=x.nextDouble();
jxc=x.nextDouble();
jxk=x.nextDouble();
if(ybj<=0||jxc<=0||jxk<=0){//如果不合法
System.out.println("Wrong Format");
System.exit(0);
}
GetArea yuanmianji=new Circle(ybj);
GetArea juxingmianji=new Rectangle(jxc,jxk);
yl=yuanmianji.Mj();
kp=juxingmianji.Mj();
System.out.printf("%.2f\n",yl);
System.out.printf("%.2f\n",kp);
}
}
、对三次题目集中用到的正则表达式技术的分析总结
三次题目集让我更加感受到正则表达式是一个强大的字符串处理工具。正则表达式可以对字符串进行查找、提取、分割、替换等操作，是一种可以用于模式匹配和替换的规范。
题目集5 7-4
7-4 统计Java程序中关键词的出现次数 (25 分)
编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：
- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法
输入格式:
输入Java源码字符串，可以一行或多行，以exit行作为结束标志
输出格式:
- 当未输入源码时，程序输出Wrong Format
- 当没有统计数据时，输出为空
- 当有统计数据时，关键字按照升序排列，每行输出一个关键字及数量，格式为数量\t关键字
源代码：
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
/*
abstract、assert、boolean、break、byte、case、catch、
char、class、const、continue、default、do、double、else、
enum、extends、false、final、finally、float、
for、goto、if、implements、import、instanceof、
int、interface、long、native、new、null、package、
private、protected、public、return、short、static、
strictfp、super、switch、synchronized、this、throw、
throws、transient、true、try、void、volatile、while
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input=new Scanner(System.in);
String a;
StringBuilder ss=new StringBuilder();
Map<String, Integer> map=new HashMap<String, Integer>();
String []key= { "abstract","assert","boolean","break","byte","case","catch",
"char","class","const","continue","default","do","double","else",
"enum","extends","false","final","finally","float",
"for","goto","if","implements","import","instanceof",
"int","interface","long","native","new","null","package",
"private","protected","public","return","short","static",
"strictfp","super","switch","synchronized","this","throw",
"throws","transient","true","try","void","volatile","while"
};
int j=0;
for(int i=0;;i++) {
a=input.nextLine();
if(a.equals("exit"))
break;
if(a.matches("(.*)//(.*)"))
{String b[]=a.split("//");
ss.append(b[0]+" ");
//ss.append('\n');
}
else
{ss.append(a+" ");
//ss.append('\n');
}
}
int count=0;
String s=ss.toString();
// System.out.println(s);
Pattern p=Pattern.compile("\"(.*?)\"");
Matcher m=p.matcher(s);
while(m.find()){
s=s.replace(m.group()," ");
p=Pattern.compile("\"(.*?)\"");
m=p.matcher(s);
}
p=Pattern.compile("/\\**(.*?)/");
m=p.matcher(s);
while(m.find()){
s=s.replace(m.group()," ");
// p=Pattern.compile("/\\*(.*?)\\*/");
m=p.matcher(s);
}
// System.out.println(s);
if(s.isEmpty())
{System.out.println("Wrong Format");
System.exit(0);
}
s=s.replace("["," ");
s=s.replace("]"," ");
s=s.replace("-","a");
s=s.replace("*","a");
s=s.replace("/","a");
s=s.replace("+","a");
s=s.replace(">","a");
s=s.replace("=","a");
s=s.replace("!","a");
s=s.replace(":","a");
s=s.replace("\\","a");
s= s.replaceAll("[^a-zA-Z]", " ");
String []s1=s.split("[ ' ']");
for(int i=0;i<s1.length;i++)
{//System.out.println(s1[i]);
for( j=0;j<key.length;j++)
if(s1[i].equals(key[j]))
{
map.put(key[j], 0);
}
}
for( int i = 0;i<s1.length;i++)
{
for( j=0;j<key.length;j++)
if(s1[i].equals(key[j]))
{ count=map.get(key[j]);
map.put(key[j], count+1);
}
}
Set set=map.keySet();
Object[] arr=set.toArray();
Arrays.sort(arr);
for(Object k:arr){
System.out.println(map.get(k)+"\t"+k);
}
}
}
三．踩坑心得：
在7-2 日期问题面向对象设计（聚合一）中，对于求n天前/n天后，在后续修改过程中，我发现可以使用一个while循环代替。如下代码所示，将天数全部加入day中，当天数数值大于当月最大天数a[m]，若m不为12，则将天数减去当月的天数最大值，month++，表示度过整个月，进入下个月的判断，当m==12时，天数减去当月最大之后，m=1，year+1，并判断新year是否为闰年，并以此修改2月最大天数。
y=day.month.year.value;
m=day.month.value;
d=day.value+n;
while(d-a[m]>0){//找到月
if(m == 12) {
d=d-a[m];
m = 1;
y++;
if(new Year(y).isLeapYear())
a[2]=29;
else
a[2]=28;
}
else {
d=d-a[m];
m++;
}
}
四．改进建议
在7-5图形的继承与多态题 可以用一个shapeList把数据全部存储会简单很多
五．总结
此次的java学习中，我深刻地理解到Java三大特征：封装、继承、多态的含义，封装通过对数据的访问限制可以增强代码的安全性，继承可以共享代码，那些类里面重复的属性 方法都可以共享，方便以后的维护以及修改 以及减少类创建的工作量，提高代码的可扩展性，更好的实现父类的方法，同时继承也是有缺点的，继承了父类就必须有父类的属性和方法，此次学习充分的了解了java的三大核心 封装 继承 多态 ，这六个字看似简单，实则不然，实际写代码时得考虑很多因素
浙公网安备 33010602011771号