总结性Blog1
作者：互联网
面向对象程序设计PTA01总结
前言
几次PTA的作业着重练习类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构、控制结构；练习数据的输入与输出；学习编写结构清晰、逻辑正确、功能完善的java代码。学习使用工具对代码进行跟踪调试。理解抽象类与子类的关系，实现继承操作，构造类族；正确使用抽象类和子类实现多态操作；理解接口的意义，并实现行为的多态；理解了解抽象类、类以及接口三者的异同以及使用场合。掌握UML基本用法和画法，并能根据题目描述画出类、接口、类。整体题量适中，大部分的题目的难度适中，极个别题目有着鲜明的特点、特征。
设计与分析
本模块重点对题目提交的源码进行分析
题目集1的7-8
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”； （2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”； （3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”； （3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”； （5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”； （6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”； （7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
源代码:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
double a=in.nextDouble();
double b=in.nextDouble();
double c=in.nextDouble();
if(a<0||b<0||c<0||a>200||b>200||c>200)
System.out.println("Wrong Format");
else if(a+b<=c||a+c<=b||b+c<=a)
System.out.println("Not a triangle");
else if(a==b&&a==c&&c==b)
System.out.println("Equilateral triangle");
else if(a*a+b*b-c*c<1e-6||a*a+c*c-b*b<1e-6||b*b+c*c-a*a<1e-6)
{
if(a==b||a==c||c==b)
System.out.println("Isosceles right-angled triangle");
else
System.out.println("Right-angled triangle");
}
else if(a==b||a==c||c==b)
System.out.println("Isosceles triangle");
else
System.out.println("General triangle");
}
}
设计思想
大方向：一般三角形 a+b>c 这是大前提条件等边三角形 ；a=b=c等腰直角三角形a=b， a×a+b×b=c×c；等腰三角形 a=b；直角三角形 a×a+b×b=c×c
根据题目要求，我们首先要判断输入的数据是否合法。然后按三角形类型的判断条件范围从大到小进行判断。
问题
题目中遇到的问题：
参考题目中提供的给出输入与输出，过不了的测试用例其实是等腰直角三角形，因为直角边和斜边满足根2倍数关系，根2是无限小数，所以题目中在给用例的时候无法给出一个准确值，因此不能用平方和的方法判断。应该用直角边的根2倍与斜边的差值绝对值是否足够小。
解决方案
解决直角边的根2倍与斜边的差值的差的绝对值是否足够小的问题，我用的是是否小于1e-6c（1x10^(-6)），所以是在做不出来的时候可以从出题者角度思考问题，或许会有收获。很多牵扯到无限小数的场景，都会用差值绝对值是否小于某个值来近似看做相等，这也是一种重要的编程思想。
题目集2的7-4
输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法。
要求：Main类中必须含有如下方法，签名如下：
public static void main(String[] args)；//主方法
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型
public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值
public static void nextDate(int year,int month,int day) ; //求输入日期的下一天
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
当输入数据非法及输入日期不存在时，输出“Wrong Format”；
当输入日期合法，输出下一天，格式如下：Next date is:年-月-日
输入样例1:
在这里给出一组输入。例如：
2020 3 10
输出样例1:
在这里给出相应的输出。例如：
Next date is:2020-3-11
输入样例2:
在这里给出一组输入。例如：
2025 2 10
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
源代码:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Main cal=new Main();
Scanner input=new Scanner(System.in);
int year=input.nextInt();
int month=input.nextInt();
int day=input.nextInt();
if(cal.checkInputValidity(year,month,day)==false)
System.out.println("Wrong Format");
else
cal.nextDate(year,month,day);
}
public static boolean isLeapYear(int year)
{
if (year%400==0||(year%4==0&&year%100!= 0))
return true;
else
return false;
}
public static boolean checkInputValidity(int year,int month,int day)
{
if(year<1820||year>2020||month<1||month>12||day<1||day>31||(isLeapYear(year)==false&&month==2&&day==29))
return false;
else
return true;
}
public static void nextDate(int year,int month,int day) {
if(isLeapYear(year))
{
if(((month==1||month==3||month==5||month==7||month==8||month==10)&&day==31)||((month==4||month==6||month==9||month==11)&&day==30)||(month==2&&day==29))
{month=month+1;
day=1;}
else if(month==12&&day==31)
{
year=year+1;
month=1;
day=1;
}
else
day=day+1;
}
else
{
if(((month==1||month==3||month==5||month==7||month==8||month==10)&&day==31)||((month==4||month==6||month==9||month==11)&&day==30)||(month==2&&day==28))
{month=month+1;
day=1;}
else if(month==12&&day==31)
{
year=year+1;
month=1;
day=1;
}
else
day=day+1;
}
System.out.println("Next date is:"+year+"-"+month+"-"+day);
}
}
设计思想
根据题目中给定的Main类中存在的方法，分别设计出每个方法所实现的功能。首先要判断出输入的数据是否合法，如果输入合法先行判断输入的年份是否为闰年，在求下一天的方法中求下一天分为两种情况，一种是闰年一种是非闰年，使用if-else语句对两种情况分别求下一天。
题目集2的7-5
输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。
输入格式:
在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。
输出格式:
当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
当输入数据合法时，输出“n days ago is:年-月-日”
输入样例1:
在这里给出一组输入。例如：
2018 6 19 8
输出样例1:
在这里给出相应的输出。例如：
8 days ago is:2018-6-11
输入样例2:
在这里给出一组输入。例如：
2018 6 19 -8
输出样例2:
在这里给出相应的输出。例如：
-8 days ago is:2018-6-27
源代码:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Main cal=new Main();
Scanner input=new Scanner(System.in);
int year=input.nextInt();
int month=input.nextInt();
int day=input.nextInt();
int n=input.nextInt();
if(cal.checkInputValidity(year,month,day,n)==false)
System.out.println("Wrong Format");
else if(day>n) {
day=day-n;
if(isLeapYear(year)==true&&month==2&&day>29)
{
month=3;
day=day-29;
}
else if(isLeapYear(year)==false&&month==2&&day>28) {
month=3;
day=day-28;
}
else if(month==12&&day>31) {
year=year+1;
month=1;
day=day-31;
}
else if((month==4||month==6||month==9||month==11)&&day>30) {
month=month+1;
day=day-30;
}
else if((month==3||month==5||month==7||month==8||month==10||month==12)&&day>31) {
month=month+1;
day=day-31;
}
System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
}
else if(day<=n) {
if(month==1)
{
year=year-1;
month=12;
day=31+day-n;
}
else if(month==3) {
if(isLeapYear(year)==true)
{
month=2;
day=29+day-n;
}
else {
month=2;
day=28+day-n;
}
}
else if(month==5||month==7||month==10||month==12)
{
month=month-1;
day=30+day-n;
}
else {
month=month-1;
day=31+day-n;
}
System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
}
}
public static boolean isLeapYear(int year)
{
if (year%400==0||(year%4==0&&year%100!= 0))
return true;
else
return false;
}
public static boolean checkInputValidity(int year,int month,int day,int n)
{
if(year<1820||year>2020||month<1||month>12||day<1||day>31||n<-10||n>10||(isLeapYear(year)==false&&month==2&&day==29))
return false;
else
return true;
}
}
设计思想
7-5与题目7-4大体上是一样的，差别不大。同样是对输入的数据进行判是否为闰年以及判断输入是否合法。我们对大月分以及小月份的月份数和月份内的天数进行赋值。首先判断是否为闰年，其次是n的正负问题，要求解的是前n天还是后n天。如果求后n天，用输入的day减n得新的day，判断月份是否为12月，是12月且day大于31，年份加一，月份加一，day-31；如果不是判断得到的day是否大于所在月的最大天数，如果大于月份的最大天数，只是年份不变，月份加一，day的值为得到的day减月份的最大天数。求前n天的日期是同样的道理。
问题
输出时先得到月份，减该月最大天数的时候得出的day错误。
解决方案
先求出day的值，通过day求得month的值。
题目集3的7-2
定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。
要求：Date类结构如下图所示：
输入格式:
在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式:
当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
当输入日期合法，输出下一天，格式如下：Next day is:年-月-日
输入样例1:
在这里给出一组输入。例如：
1912 12 25
输出样例1:
在这里给出相应的输出。例如：
Next day is:1912-12-26
输入样例2:
在这里给出一组输入。例如：
2001 2 30
输出样例2:
在这里给出相应的输出。例如：
Date Format is Wrong
源代码:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int year = input.nextInt();
int month = input.nextInt();
int day = input.nextInt();
int[] days = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31};
Date date = new Date(year,month,day);
date.nextDate(year,month,day);
}
}
class Date {
private int year;
private int month;
private int day;
public Date() {
}
public Date(int year, int month, int day) {
// TODO Auto-generated constructor stub
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getday() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public static boolean isLeapYear(int year)
{
if (year%400==0||(year%4==0&&year%100!= 0))
return true;
else
return false;
}
public static boolean checkInputValidity(int year,int month,int day)
{
if(year<1900||year>2000||month<1||month>12||day<1||day>31||(isLeapYear(year)==false&&month==2&&day==29))
return false;
else
return true;
}
public static void nextDate(int year,int month,int day) {
//求下一天注意夸年月以及特殊月份以及闰年和平年的二月不同天数
int[] days=new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year))
days[2] = 29;
int a = 0,b = 0,c = 0;
if(checkInputValidity(year,month,day)) {
if(month==12) {
if(day==days[month]) {
a = year+1;
b = 1;
c = 1;}
if(day>0&&day<days[month])
{a = year;
b = month;
c =day +1;
}
}
if(month<12) {
if(day==days[month]) {
a = year;
b = month + 1;
c = 1;}
if(day>0&&day<days[month])
{a = year;
b = month;
c = day+1;
}
}
System.out.println("Next day is:"+a+"-"+b+"-"+c);
}
else System.out.println("Date Format is Wrong");
}
}
设计思路
根据题目中给定的UML类图来设计此题，创建Date类，，初始化Date类的数据域，注意类方法的输入参数与返回值，求下一天的方法同题目集2中7-4的方法一样，在Main方法中通过date.nextDate(year,month,day)语句来获取下一天。
题目集3的7-3
编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。 OO作业3-3题目说明.pdf
输入格式:
在一行内输入一个待计算导函数的表达式，以回车符结束。
输出格式:
如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点： 结果不需要排序，也不需要化简；
当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
当输出结果第一项系数符号为“+”时，不输出“+”；
当指数符号为“+”时，不输出“+”；
当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。
输出格式见输入输出示例。
输入样例1:
在这里给出一组输入。例如：
-2* x^-2+ 5*x^12-4*x+ 12
输出样例1:
在这里给出相应的输出。例如：
4*x^-3+60*x^11-4
输入样例2:
在这里给出一组输入。例如：
2*x^6-0*x^7+5
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
源代码:
import java.math.BigInteger;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String data = in.nextLine();
data = data.replaceAll(" ", "");
Polynomial polynomial = new Polynomial(data);
if(data.matches("[-]?[0-9]+")) { //如果输入为常数
System.out.println("0");
}
else if(!polynomial.isPolynomial(data) || data.isEmpty()) { //判断正确，判断为空
System.out.println("Wrong Format");
}
else { //first
List<String> list = new LinkedList<String>();
List<String> list1 = new LinkedList<String>();
list = polynomial.getPolynomial(); //得到每一项
for(int i = 0 ; i < list.size() ; i++) {
if(polynomial.isInteger(list.get(i).toString())) { //如果是一个常数
}
else { //second 是式子了话
BigInteger coeff = polynomial.getCoeff(list.get(i).toString()); //若不是常数求系数和指数
BigInteger index = polynomial.getIndex(list.get(i).toString());
BigInteger value = new BigInteger("0");
PowerFunctionTerm powerFunctionTerm = new PowerFunctionTerm(coeff,index);
String s1 = powerFunctionTerm.getDerivative().getCoeff()+""; //新系数
String s2 = powerFunctionTerm.getDerivative().getIndex()+""; //新指数
//if(i != 0) { //不是第一位+-号情况
Special special = new Special(s1,s2,i);
list1.add(special.index1().replaceAll(" ", ""));
} // second
}
Expression expression = new Expression(list1);
for(int i = 0 ; i <expression.list.size() ; i++) {
System.out.print(expression.list.get(i));
}
} // first
}
}
//下面是其他类
class PowerFunctionTerm extends Term { //待指数求导并返回值——字符串
private BigInteger coeff; //系数
private BigInteger index; //指数
public PowerFunctionTerm(BigInteger coeff, BigInteger index) {
this.coeff = coeff;
this.index = index;
}
public BigInteger getCoeff() {
return coeff;
}
public void setCoeff(BigInteger coeff) {
this.coeff = coeff;
}
public BigInteger getIndex() {
return index;
}
public void setIndex(BigInteger index) {
this.index = index;
}
public PowerFunctionTerm getDerivative() { //这里求常数单项的导数
BigInteger a = new BigInteger("1");
return new PowerFunctionTerm(coeff.multiply(index),index.subtract(a));
}
public String toString() {
return getDerivative().toString();
}
}
class ConstantTerm extends Term { //常数求导并返回值——字符串
private BigInteger value; //常数值
public ConstantTerm(BigInteger value) {
this.value = value;
}
public BigInteger getValue() {
return value;
}
public void setValue(BigInteger value) {
this.value = value;
}
public Term getDerivative() { //这里求常数单项的导数
value = new BigInteger("0");
return new ConstantTerm(value);
}
public String toString() { //把求导后的数转化为字符串
return getDerivative().toString();
}
}
class Expression { //用来把求导好的字符串输出
List<String> list = new LinkedList<String>();
public Expression(List<String> list) {
this.list = list;
}
public String toString() {
return list.toString();
}
}
class Polynomial {
private String data;
public Polynomial(String data) {
this.data = data;
}
public List<String> getPolynomial(){
List<String> list = new LinkedList<String>();
String[] arr = new String[1000];
String str = "";
int flag = 0;
//-2*x^-2+5*x^12-4*x+12
int flag1 = 0;
for(int i = 0 ; i < data.length() ; i++) {
String a = String.valueOf(data.charAt(i));
if(a.equals("-") || a.equals("+")) {
if(i == 0) {
if(a.equals("-")) //当负号为第一位的时候可以保留
str = str+a;
}
else {
String lowa = String.valueOf(data.charAt(i-1));
String longa = String.valueOf(data.charAt(i+1));
if(lowa.equals("^"))
str = str+a;
else if(lowa.matches("[0-9]+") || longa.matches("[0-9]+")) { //jia[]+
if(a.equals("-")) {
flag1 = 1;
}
flag = 1;
}
}//这个if-else是判断为负号时是否保留
}
else {
str = str+a;
}
if(flag == 1) {
list.add(str);
flag = 0;
str = "";
if(flag1 == 1) {
str = "-"+str;
flag1 = 0;
}
}
if(i == data.length()-1) {
list.add(str);
}
}
return list;
}
public boolean isPolynomial(String s) { //判断是不是多项式，符合进行拆分
boolean judge = true;
if(!s.matches("([+-]?([1-9][0-9]*)?((\\*)?x(\\^[+-]?[1-9][0-9]*)?)?)+")) {
judge = false; //"^([-+]?([1-9][0-9]*)?(\\*)?(x(\\^[+-]?[0-9]+)?)?)+$"
}
return judge;
}
public boolean isInteger(String s) { //判断是不是多项式
boolean judge = true;
for(int i = 0 ; i < s.length(); i++) {
if(String.valueOf(s.charAt(i)).compareTo("x") == 0) {
judge = false;
break;
}
}
return judge;
}
public BigInteger getIndex(String s) {
String[] test = s.split("\\^");
if(test[0].compareTo(s) == 0) {
if(test[0].endsWith("x")) {
test[0] = "1";
}
}
else {
test[0] = test[1];
}
return new BigInteger(test[0]);
}
public BigInteger getCoeff(String s) {
String[] test = s.split("\\*");
if(test[0].compareTo(s) == 0) {
if(String.valueOf(test[0].charAt(0)).compareTo("x") == 0) {
test[0] = "1";
}
else {
test[0] = "-1";
}
}
return new BigInteger(test[0]);
}
}
abstract class Term {
public abstract Term getDerivative(); //用来求每个单项
}
class Special {
String s1,s2;
int i;
public Special(String s1,String s2,int i) {
this.s1 = s1;
this.s2 = s2;
this.i = i;
}
public String index1() { //
String end = "";
if(s1.equals("1")&&s2.equals("0"))
end = "1";
else if(s1.equals("1")&&s2.equals("1"))
end = "x";
else if(s1.equals("-1")&&s2.equals("0"))
end = "-1";
else if(s1.equals("-1")&&s2.equals("1"))
end = "-x";
else if(s1.equals("1"))
end = "x^"+s2 ;
else if(s1.equals("-1"))
end = "-x^"+s2;
else if(s2.equals("0"))
end = s1;
else if(s2.equals("1"))
end = s1+"x";
else {
if(s1.compareTo("0") > 0 && i != 0)
end = "+"+s1+"*x^"+s2;
else if(s1.compareTo("0") > 0 && i == 0)
end = s1+"*x^"+s2;
else if(s1.compareTo("0") < 0)
end = s1+"*x^"+s2;
}
return end;
}
}
设计思路
这道题还是有着很鲜明的特点，拿到这道题的时候脑子中没有任何思路，后来通过查阅资料时看到了这张类图，有了解题的思路。这说明我在初期的设计中有着明显的能力不足，导致我在看到这道题是没有任何思路。
首先要学会正则表达式对输入的多项式进行判断是否为合法输入，然后设计待指数求导并返回值------字符串的类，常数项类、幂函数类返回值都为常数项来继承Term类中的求导方法来求每个单项的导数，最后是对多项式中特殊情况的处理，单独设计了Special类来对特殊情况进行处理，特殊情况一般为系数或是指数为1，0之类的情况的处理。文中的每部分代码中都有一些相对总结性的注释。
问题
对于题目中设置的测试节点，最后两个大数据测试无法通过，以及无法判断第一项系数为负数的多项式，不可以使用int型来存储数据。需要使用大数类型来存储数据。目前遇到的问题还待解决。希望可以在后期的讲解中找到解决方案。
作业总结
通过这几次的作业效果来看，我编写的代码对于老师设定的测试节点通过率不高，而且设计的代码在细节上还是很繁琐的，整体结构不够简洁，代码的可阅读性不高,我的编写能力在这几方面还有待提高。通过这几次作业强化我在类的构造方法、方法的调用、参数传递、对象的构造与使用；练习循环结构、控制结构；练习数据的输入与输出；学习编写结构清晰、逻辑正确、功能完善的java代码。学习使用工具对代码进行跟踪调试。理解抽象类与子类的关系，实现继承操作，构造类族；正确使用抽象类和子类实现多态操作；理解接口的意义，并实现行为的多态；理解了解抽象类、类以及接口三者的异同以及使用场合。掌握UML基本用法和画法，并能根据题目描述画出类、接口、类等方面的提高。希望在后期的讲解中找到待解决问题的解决方法。
标签：总结性,Blog1,public,month,int,year,day,输入 来源： https://www.cnblogs.com/handongbo/p/14616092.html