1
前三次作业总结
前言
一． 第一次题目集
第四次题目集题目的数目为三个题目，题目数目较少。这三个题目分别为题目4-1水文数据校验及处理 ，4-2日期问题面向对象设计（聚合一），4-3图形继承 。这三道题目的题目难度较难，涉及知识点较多。这三道题所涉及的知识点为，正则表达式的运用，包括匹配字符串，正则表达式的语法，替换和拆分字符串，对象和类中的定义和创建对象，使用构造方法构造对象，通过引用变量访问对象，和静态变量，可见性修饰符，数据域封装，this引用，面向对象思考的类的关系和string类中的各种操作，继承和多态的父类和子类，super关键词等知识点。
一． 第二次题目集
第五次题目集的题目的数目为五个题目，题目数目适中。这五个题目分别为题目5-1找出最长的单词-hebust，题目5-2合并两个有序数组为新的有序数组，题目5-3对整形数据进行排序，题目5-4统计java程序中关键词的出现次数，题目5-5日期问题面向对象设计（聚合二）。这五道题目难度较难，涉及的知识点较多较广。这五道题目所涉及的具体知识点为，正则表达式的运用，正则表达式的语法，string类中的使用模式匹配，替换和拆分字符串，foreach循环，一维数组中的数组的排序，arrays类，复制数组，将数组传递给方法，方法返回数组，数组的查找，方法中的定义方法，调用方法，重载方法，插入排序，选择排序，冒泡排序三种排序方法，对象和类中的定义和创建对象，使用构造方法构造对象，通过引用变量访问对象，和静态变量，可见性修饰符，数据域封装，this引用，面向对象思考的类的关系关联，聚集和组合，和string类中的各种操作，继承和多态的父类和子类，super关键词的调用父类的构造方法，调用父类的普通方法，对象数组，不可变对象和类，方法重写与重载，多态，arraylist类，rpotected数据和方法等知识点。
三．第三次题目集
第六次题目集的题目的数目为六个题目，题目数目相比于前两次较多。这六个题目分别为题目6-1正则表达式训练-QQ号校练，6-2字符串训练-字符排序，6-3正则表达式训练-验证码校练，6-4正则表达式训练-学号校练，6-5图型继承与多态，6-6实现图型接口与多态性。这六道题目难度适中，涉及的知识点较多较广。这六道题目所涉及的具体知识点为以下，
正则表达式的运用，包括匹配字符串，正则表达式的语法，替换和拆分字符串，字符串中的ascii码，字符型数据与数值型数据之间的转化，字符的比较，string类型的获取字符串长度，字符串的转化，获得子字符串，一维数组的arrays类，对象和类中的使用构造方法构造对象，通过引用变量访问对象，可见性修饰符，数据域封装，对象数组，this的引用，类关联，聚集和组合的关系，父类和子类，使用super关键字，方法重写和重载，object类及其tostring，多态，对象转换和instanceof操作符，object类的equals方法，和抽象类和接口等知识点。
具体分析建议与心得及总结
题目集4的4-2
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;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;
int choice = input.nextInt();
if (choice == 1) { // test getNextNDays method
int m = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
m = input.nextInt();
if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
DateUtil date = new DateUtil(year, month, day);
if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}
n = input.nextInt();
if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.print(
date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());
int anotherYear = Integer.parseInt(input.next());
int anotherMonth = Integer.parseInt(input.next());
int anotherDay = Integer.parseInt(input.next());
DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);
if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println("The days between " + fromDate.showDate() +
" and " + toDate.showDate() + " are:"
+ fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class DateUtil {
private int year;
private int month;
private int day;
public DateUtil(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public DateUtil(){}
public void setYear(int year) {
this.year = year;
}
public void setMonth(int month) {
this.month = month;
}
public void setDay(int day) {
this.day = day;
}
public int getYear() {
return year;
}
public int getMonth() {
return month;
}
public int getDay() {
return day;
}
private final int[] DAY_OF_MONTH = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
private int getDayOfMonth(int year, int month) {
int days = DAY_OF_MONTH[month - 1];
if (month == 2 && isLeapYear(year)) {
days = 29;
}
return days;
}
public boolean checkInputValidity()//检测输入的年、月、日是否合法
{
if (year < 1820 || year > 2020) return false;
if (month < 1 || month > 12) return false;
// int _day = this.getDayOfMonth(year, month);
// return day <= _day;
return day >= 1 && day <= 31;
}
public boolean isLeapYear(int year)//判断year是否为闰年
{
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}
public DateUtil getNextNDays(int n)//取得year-month-day的下n天日期
{
int year = this.year;
int month = this.month;
int day = this.day;
// day = Math.min(day, this.getDayOfMonth(year, month));
for (int i = 0; i < n; i++) {
day++;
if (day > getDayOfMonth(year, month)) {
day = 1;
month++;
if (month > 12) {
month = 1;
year++;
}
}
}
return new DateUtil(year, month, day);
}
public DateUtil getPreviousNDays(int n)//取得year-month-day的前n天日期
{
int year = this.year;
int month = this.month;
int day = this.day;
for (int i = 0; i < n; i++) {
day--;
while (day < 1) {
month--;
if (month < 1) {
month = 12;
year--;
}
day += getDayOfMonth(year, month);
}
}
return new DateUtil(year, month, day);
}
public boolean compareDates(DateUtil date)//比较当前日期与date的大小（先后）
{
if (this.year > date.year) return true;
if (this.year == date.year) {
if (this.month > date.month) return true;
if (this.month == date.month) {
if (this.day >= date.day) return true;
}
}
return false;
}
public boolean equalTwoDates(DateUtil date)//判断两个日期是否相等
{
if (date != null) {
if (year == date.year && month == date.month && day == date.day) {
return true;
}
}
return false;
}
private static final int[] mon = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
public int getDaysofDates(DateUtil date)//求当前日期与date之间相差的天数
{
DateUtil dateUtil1 = this; // 小
DateUtil dateUtil2 = date; // 大
if (this.compareDates(date)) {
dateUtil1 = date;
dateUtil2 = this;
}
int days;
int leapYearNum = 0;
for (int i = dateUtil1.getYear(); i < dateUtil2.getYear(); i++) {
if (isLeapYear(i)) {
leapYearNum++;
}
}
days = 365 * (dateUtil2.getYear() - dateUtil1.getYear()) + leapYearNum;
int d1 = mon[dateUtil1.getMonth() - 1] + dateUtil1.getDay() + (dateUtil1.getMonth() > 2 && isLeapYear(dateUtil1.getYear()) ? 1 : 0);
int d2 = mon[dateUtil2.getMonth() - 1] + dateUtil2.getDay() + (dateUtil2.getMonth() > 2 && isLeapYear(dateUtil2.getYear()) ? 1 : 0);
return days - d1 + d2;
}
public String showDate()//以“year-month-day”格式返回日期值
{
return year + "-" + month + "-" + day;
}
}
此题year类组合month类，month类组合day类，day类组合dateutil类，各类中的数据重重调用，一个类是另一个类中的属性，关于如何求一个时间的前n天或者后n天，如果是前n天则从每个月的1号开始加，一直加到这个月的最后一天，后月份加一，如果是最后一个月则年份加一，一直加到输入的n天。求其后n天则相反，要从该月的最大天开始减，减到1号时月份减一，如果是是这年的第一个月则年份减一。求两个日期的天数差则将他们转换为天数后相减取他们的绝对值。这题要注意的是如何正确的调用数据，和在处理数据时要注意闰年时的最大天数，和年份的界限。每当要用一个新的类的对象时要用new，在一个类中要用另一个类中的数据时不能直接new这个类，负责这个类中的数据全是初始化的数据，没有new则不能创造新的对象，父类中的私有类能继承给子类，子类可以拥有但不能修改。
出现编译错误的原因时在pta提交时类前要删去public
题目集五的5-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-day1next n days is:year2-month2-day2
- 当第一个数字为2且输入均有效，输出格式如下：
year1-month1-day1previous n days is:year2-month2-day2
- 当第一个数字为3且输入均有效，输出格式如下：
Thedays between year1-month1-day1and year2-month2-day2are:值
输入样例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代码如下
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int a=input.nextInt();
int y =input.nextInt();
int m=input.nextInt();
int d=input.nextInt();
DateUtil date1=new DateUtil(y,m,d);
if(a!=1&&a!=2&&a!=3) {
System.out.println("Wrong Format");
System.exit(0);
}
if(date1.checkInputValidity()==false) {
System.out.println("Wrong Format");
System.exit(0);
}
switch(a) {
case 1:
int n=input.nextInt();
date1=date1.getNextDay(n);
System.out.println(y+"-"+m+"-"+d+" next "+n+" days is:"+date1.year.value+"-"+date1.month.value+"-"+date1.day.value);
break;
case 2:
int n1=input.nextInt();
date1=date1.getPreviousDay(n1);
System.out.println(y+"-"+m+"-"+d+" previous "+n1+" days is:"+date1.year.value+"-"+date1.month.value+"-"+date1.day.value);
break;
case 3:
int p;
int y2 =input.nextInt();
int m2=input.nextInt();
int d2=input.nextInt();
DateUtil date2=new DateUtil(y2,m2,d2);
if(date2.checkInputValidity()==false) {
System.out.println("Wrong Format");
System.exit(0);
}
p=date1.getDaysofDates(date2)-3;
System.out.println("The days between "+date1.year.value+"-"+date1.month.value+"-"+date1.day.value+" and "+date2.year.value+"-"+date2.month.value+"-"+date2.day.value+" are:"+p);
break;
}
}
}
class DateUtil {
Year year;
Month month;
Day day;
int [] mon_maxnum = {31,28,31,30,31,30,31,31,30,31,30,31};
DateUtil(){
}
DateUtil(int y,int m,int d){
year=new Year(y);
month=new Month(m);
day=new Day(d,y,m);
}
public void setDayMax() {
if(month.value==2&&year.isLeapYear()==true)
mon_maxnum[1]=29;
else
mon_maxnum[1]=28;
}
public void setDayMin() {
day.value=1;
}
public boolean checkInputValidity() {
if((year.valiDate()==true)&&(month.valiDate()==true)&&(day.valiDate()==true))
return true;
else
return false;
}
public DateUtil getNextDay(int n) {
for(int i=0;i<n;i++) {
this.setDayMax();
day.dayIncrement();
if(day.value>this.mon_maxnum[month.value-1]) {
month.monthIncrement();
day.value=1;
}
if(month.value>12) {
month.value=1;
year.yearInorement();
}
}
return new DateUtil (year.value,month.value,day.value);
}
public DateUtil getPreviousDay(int n) {
for(int i=0;i<n;i++) {
//this.setDayMax();
day.dayReduction();
if(day.value<1) {
month.monthReduction();
//day.value=mon_maxnum[month.value-1];
//}
if(month.value<1) {
month.value=12;
year.yearReaduction();
}
this.setDayMax();
day.value+=mon_maxnum[month.value-1];
}
}
return new DateUtil(year.value,month.value,day.value);
}
public boolean compareDates(DateUtil date2) {
if(year.value>date2.year.value)
return true;
if(year.value==date2.year.value) {
if(month.value>date2.month.value)
return true;
if(month.value==date2.month.value) {
if(day.value==date2.day.value)
return true;
}
}
return false;
}
public boolean equalTwoDates(DateUtil date2) {
if(year.value==date2.year.value&&month.value==date2.month.value&&day.value==date2.day.value)
return true;
else
return false;
}
public int getDaysofDates(DateUtil date2) {
int[] mon = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
int a;
if(equalTwoDates(date2)==true) {
return 0;
}
DateUtil date1util1=this;
DateUtil date1util2=date2;
if(compareDates(date2)) {
date1util1=date2;
date1util2=this;
}
int days;
int leapyears=0;
for (int i = date1util1.year.value; i < date1util2.year.value; i++) {
if (date1util1.year.isLeapYear()) {
leapyears++;
}
}
days = 365 * (date1util2.year.value - date1util1.year.value) + leapyears;
int d1 = mon[date1util1.month.value - 1] + date1util1.month.value + (date1util1.month.value > 2 && date1util1.year.isLeapYear() ? 1 : 0);
int d2 = mon[date1util2.month.value - 1] + date1util2.month.value + (date1util2.month.value > 2 && date1util2.year.isLeapYear() ? 1 : 0);
return days - d1 + d2;
}
}
class Day {
int value;
int year;
int month;
Day(){
}
Day(int value,int year,int month){
this.value=value;
this.year=year;
this.month=month;
}
public void dayIncrement() {
this.value=value+1;
}
public void dayReduction() {
this.value=value-1;
}
public boolean valiDate() {
Year year=new Year(this.year);
Month month=new Month(this.month);
if(year.isLeapYear()==true&&month.value==2&&this.value<=29&&this.value>=1)
return true;
else
if(year.isLeapYear()==false&&month.value==2&&this.value<=28&&this.value>=1)
return true;
else
if((this.month==1||this.month==3||this.month==5||this.month==7||this.month==8||this.month==11)&&this.value<=31&&this.value>=1)
return true;
else
if((this.month==4||this.month==6||this.month==9||this.month==12)&&this.value>=1&&this.value<=30)
return true;
else return false;
}
}
class Month {
int value;
Month(){
}
Month(int value){
this.value=value;
}
public void reseMin() {
this.value=1;
}
public void reseMax() {
this.value=12;
}
public boolean valiDate() {
if(this.value<1||this.value>12)
return false;
else
return true;
}
public void monthIncrement() {
this.value=value+1;
}
public void monthReduction() {
this.value=value-1;
}
}
class Year {
int value;
Year(){
}
Year(int value){
this.value = value;
}
public boolean isLeapYear() {
if((this.value%4==0&&this.value%100!=0)||this.value%400==0)
return true;
else
return false;
}
public boolean valiDate() {
if(this.value<1820||this.value>2020)
return false;
else
return true;
}
public void yearInorement() {
this.value=value+1;
}
public void yearReaduction() {
this.value=value-1;
}
}
这题和上面的题目集四的4-2相同，唯一的区别时聚合的关系不同，设计不同，这题时year类，day类，month类共同聚合了dateutil类，相比于上面那题的聚合设计，这样设计更加简便，操作更加的方便，代码看起来也更加明了清晰。
图形继承 (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 ShapeConstructing CircleCircle's area:3.14输入样例2:
在这里给出一组输入。例如：
4 3.6 2.1 0.01211输出样例2:
在这里给出相应的输出。例如：
Constructing ShapeConstructing RectangleConstructing BoxBox's surface area:15.26Box's volume:0.09输入样例3:
在这里给出一组输入。例如：
2 -2.3 5.110输出样例2:
在这里给出相应的输出。例如：
Wrong Format代码如下
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
Shape shape = new Shape();
Circle circle = new Circle();
Rectangle rectangle = new Rectangle();
Ball ball = new Ball();
Box box = new Box();
int a = input.nextInt();
switch(a) {
case 1:
double radius = input.nextDouble();
if(radius<0) {
System.out.println("Wrong Format");
System.exit(0);
}else {
circle.setRadius(radius);
double area = circle.getArea();
System.out.println("Constructing Shape");
System.out.println("Constructing Circle");
System.out.println("Circle's area:"+String.format("%.2f", area));
break;
}
case 2:
double width = input.nextDouble();
double length = input.nextDouble();
if(width<0||length<0) {
System.out.println("Wrong Format");
System.exit(0);
}else {
rectangle.setWidth(width);
rectangle.setLength(length);
double area = rectangle.getArea();
System.out.println("Constructing Shape");
System.out.println("Constructing Rectangle");
System.out.println("Rectangle's area:"+String.format("%.2f", area));
break;
}
case 3:
double radius1 = input.nextDouble();
if(radius1<0) {
System.out.println("Wrong Format");
System.exit(0);
}else {
ball.setRadius(radius1);
double area = ball.getArea();
double volume = ball.getVolume();
System.out.println("Constructing Shape");
System.out.println("Constructing Circle");
System.out.println("Constructing Ball");
System.out.println("Ball's surface area:"+String.format("%.2f", area));
System.out.println("Ball's volume:"+String.format("%.2f", volume));
break;
}
case 4:
double width1 = input.nextDouble();
double length1 = input.nextDouble();
double height = input.nextDouble();
if(width1<0||length1<0||height<0) {
System.out.println("Wrong Format");
System.exit(0);
}else {
box.setWidth(width1);
box.setLength(length1);
box.setHeight(height);
double area = box.getArea();
double volume = box.getVolume();
System.out.println("Constructing Shape");
System.out.println("Constructing Rectangle");
System.out.println("Constructing Box");
System.out.println("Box's surface area:"+String.format("%.2f", area));
System.out.println("Box's volume:"+String.format("%.2f", volume));
break;
}
default:System.out.println("Wrong Format");
}
}
}
class Shape {
Shape(){
}
public double getArea() {
return 0.0;
}
}
class Circle extends Shape{
private double radius;
Circle(){
}
public double getArea(){
double area = 3.14*this.radius*this.radius;
return area;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
class Rectangle extends Shape{
private double width;
private double length;
Rectangle(){
}
public double getArea(){
double area = this.length * this.width;
return area;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
}
class Ball extends Circle{
Ball(){
}
public double getArea() {
double radius = this.getRadius();
double area = 4*3.14*radius*radius;
return area;
}
public double getVolume() {
double radius=this.getRadius();
double volume = 4.00/3*3.14*radius*radius*radius;
return volume;
}
}
class Box extends Rectangle{
private double height;
Box(){
}
public double getVolume() {
double width = this.getWidth();
double length = this.getLength();
double volume = width*length*height;
return volume;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getArea() {
double width = this.getWidth();
double length = this.getLength();
double area = width*length*2+width*height*2+length*height*2;
return area;
}
}
这题是图型的继承，用extend，子类可以继承父类的方法，用继承的好处是不要在方法内又分别创建一个radius，width，length属性等，子类继承父类的所有，所以在子类中只要调用父类型的set方法就可以了，子类在构造对象时如果没有特殊说明的话，会默认执行父类的无参构造。保留几位小数可以String.format("%.2f", area)这么写。
题目集6-5
图形继承与多态 (50 分)
掌握类的继承、多态性及其使用方法。具体需求参见作业指导书。
输入格式:
从键盘首先输入三个整型值（例如a b c），分别代表想要创建的Circle、Rectangle及Triangle对象的数量，然后根据图形数量继续输入各对象的属性值（均为实型数），数与数之间可以用一个或多个空格或回车分隔。
输出格式:
- 如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边关系），则输出
Wrong Format。 - 如果输入合法，则正常输出，输出内容如下（输出格式见输入输出示例）：
- 各个图形的面积；
- 所有图形的面积总和；
- 排序后的各个图形面积；
- 再次所有图形的面积总和。
代码如下
import java.util.*;
import java.lang.Math;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input =new Scanner(System.in);
int numc = input.nextInt();
if(numc<0) {
System.out.println("Wrong Format");
System.exit(0);
}
double radius;
double []areac = new double[numc];
int numr = input.nextInt();
if(numr<0) {
System.out.println("Wrong Format");
System.exit(0);
}
double length;
double width;
double []arear = new double[numr];
int numt = input.nextInt();
if(numt<0) {
System.out.println("Wrong Format");
System.exit(0);
}
double length1;
double length2;
double length3;
double []areat = new double[numt];
double []areaAll = new double [numc+numr+numt];
if(numc==0&&numr==0&&numt==0){
System.out.println("Sum of area:0");
System.exit(0);
}
Circle []circle =new Circle[numc];
for(int j=0;j<numc;j++) {
circle[j] = new Circle();
}
for(int i=0; i<numc;i++) {
radius = input.nextDouble();
if(radius<=0) {
System.out.println("Wrong Format");
System.exit(0);
}
circle[i].radius=radius;
areac[i] = circle[i].area();
}
Rectangle []rectangle = new Rectangle[numr];
for(int k =0;k<numr;k++) {
rectangle[k] = new Rectangle();
}
for(int q=0;q<numr;q++) {
length = input.nextDouble();
width = input.nextDouble();
if(length<0||width<0) {
System.out.println("Wrong Format");
System.exit(0);
}
rectangle[q].length = length;
rectangle[q].width = width;
arear[q] = rectangle[q].area();
}
Triangle []triangle = new Triangle[numt];
for(int l=0;l<numt;l++) {
triangle[l]= new Triangle();
}
for(int w=0;w<numt;w++) {
length1 = input.nextDouble();
length2 = input.nextDouble();
length3 = input.nextDouble();
if(length1<0||length2<0||length3<0||(length1+length2)<=length3||(length1+length3)<=length2||(length3+length2)<=length1) {
System.out.println("Wrong Format");
System.exit(0);
}
triangle[w].length1 = length1;
triangle[w].length2 = length2;
triangle[w].length3 = length3;
areat[w] = triangle[w].area();
}
System.arraycopy(areac, 0, areaAll, 0, numc);
System.arraycopy(arear, 0, areaAll, numc, numr);
System.arraycopy(areat, 0, areaAll, numc+numr, numt);
double sum=0;
for(int u=0;u<numc+numr+numt;u++)
sum+=areaAll[u];
System.out.println("Original area:");
for(int m=0;m<numc+numr+numt-1;m++) {
System.out.print(new java.text.DecimalFormat("#.00").format(areaAll[m])+" ");
}
System.out.println(new java.text.DecimalFormat("#.00").format(areaAll[numc+numr+numt-1])+" ");
System.out.println("Sum of area:"+new java.text.DecimalFormat("#.00").format(sum));
System.out.println("Sorted area:");
Arrays.sort(areaAll);
for(int x=0;x<numc+numr+numt-1;x++) {
System.out.print(new java.text.DecimalFormat("#.00").format(areaAll[x])+" ");
}
System.out.println(new java.text.DecimalFormat("#.00").format(areaAll[numc+numr+numt-1])+" ");
System.out.println("Sum of area:"+new java.text.DecimalFormat("#.00").format(sum));
}
}
class Circle {
double radius;
public double area() {
return Math.PI*radius*radius;
}
}
class Rectangle {
double width;
double length;
public double area() {
return width*length;
}
}
class Triangle {
double length1;
double length2;
double length3;
public double area() {
double s=(length1+length2+length3)/2;
double area=Math.sqrt(s*(s-length1)*(s-length2)*(s-length3));
return area;
}
}
这题和上面的题大体相同，不同的是这题用了多态，多态就是对象在不同情况下的不同表现，体现在定义和功能两方面。总结一下，多态可以用“三个定义和两个方法”来总结。三个定义分别是父类定义子类构 建、接口定义实现类构建和抽象类定义实体类构建，而两个方法分别是方法重载和方法重写。这题中shape类为抽象类，cricle类，rectangle和trinalglr类为实体类。这题还要了解求三角形面积的方法Math.sqrt(s*(s-length1)*(s-length2)*(s-length3));
题目集6-6
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);
}
7-4 正则表达式训练-学号校验 (7 分)
对软件学院2020级同学学号进行校验，学号共八位，规则如下：
- 1、2位：入学年份后两位，例如20年
- 3、4位：学院代码，软件学院代码为20
- 5位：方向代码，例如1为软件工程，7为物联网
- 6位：班级序号
- 7、8位：学号（序号）
要求如下：
- 只针对2020级
- 其中软件工程专业班级分别为：202011~17、61，物联网工程专业班级为202071~202073，数据科学与大数据专业班级为202081~82
- 每个班级学号后两位为01~40
代码如下
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input =new Scanner(System.in);
String a = input.nextLine();
boolean a1 = a.matches("2020((1[1-7])|(7[1-3])|61|(8[1-2]))((0[1-9])|([1-3][0-9])|40)");
if(a1)
System.out.println("正确");
else
System.out.println("错误");
}
}
这题是对正则表达式的训练，matches（）中输入的是正则表达式，输出的是boolean值，其中部分语法为（ab|cd）为ab或者cd，【abc】为a，b或者c，【a-z】为a到z，p{n}正好出现n次模式p。正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。
浙公网安备 33010602011771号