blog2
三次pta题目总结
学习面向对象这门课程已经有半个学期了，相对于之前来说有一定的收获，对于编程能力有一定的提升。
首先关于最近学习的相关知识做一个小总结。
一、
封装：隐藏对象属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性
继承：必须类与类间有关系才能继承，提高代码复用性，java只支持单继承，但是可以有多层继承，但是可以用实现来弥补
子类为什么一定要访问父类的构造函数呢：因为父类中的数据，子类是可以直接获取的，所以子类对象在建立的时候，需要先查看父类是如何对这些数据进行初始化的，如果要指定父类中指定的构造函数，可以手动定义super语句来实现。
例如：
二、
多态：某一类事物的多种存在形态
多态的实现：父类的引用指向了自己的子类对象（向上转型）
多态的前提：类与类之间有关系，继承或实现，通常还存在覆盖
多态的好处：提高程序扩展性，弊端：父类引用只能访问父类中成员。
例如：
三、
抽象类：
抽象方法一定在抽象类中，抽象方法和抽象类必须被关键字abstract修饰
抽象类不能用new创建对象，不能实例化，因为没意义，方法没内容
抽象类中的抽象方法要被使用，必须由子类重写所有的抽象方法后，建立子类对象调用
四、
接口：
接口是对外暴露的规则，是程序的功能扩展，接口可以用来多实现，类与接口是实现关系，类可以继承一个类的同时实现多个接口，接口与接口间可有继承关系。
接口是特殊的抽象类，接口成员有固定修饰符，常量：public static final 方法：public abstract
接口不能创建对象，被子类实现后，子类需重写接口中所有抽象方法，这样子类才能实例化，否则子类还是一个抽象类。
五、
重写与重载
重写：是对父类方法的重写，子父类方法要一模一样
重载：同名函数的参数列表不同，例如：
六、
内部类：
描述事物时，事物内部还有事物，该事物可用内部类描述。
Java的内部类构造时持有对外部类的应用，这点容易引起内存泄露，要注意在Java中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用。静态的内部类不会持有外部类的引用。
内部类可直接访问外部类（这里的意思当然就是包含内部类的类）中成员，包括私有外部类要访问内部类，必须建立内部类对象
内部类可被static修饰，此时其只能访问静态成员了，但是内部类定义在局部时，也就是在外部类的方法中定义一个类，此时的内部类是不能被成员修饰符修饰的，此时仍能访问外部类中的成员，并只能访问其所在的局部中的被final关键字修饰的局部变量。
对于这三次的pta大作业，个人觉得题目偏难。后面看了学习视频和书还好，刚开始的时候，完全不会，看书的话一时半会也看不懂，所以前面得分就很低。主要原因是涉及的知识点太深，题量倒不是很大。
class DateUtil{
private Day day = new Day();
public DateUtil() {
}
public DateUtil(int year, int month, int day) {
this.day.setvalue(day);
this.day.getmonth().setvalue(month);
this.day.getmonth().getyear().setvalue(year);
}
public Day getday() {
return day;
}
public void setday(int day) {
this.day.setvalue(day);
}
public boolean checkInputValidity() {
if(this.day.getmonth().getyear().validate()&&this.day.getmonth().validate()&&this.day.validate())
return true;
else
return false;
}
public boolean compareDates(DateUtil date) {
if(this.day.getmonth().getyear().getvalue()>date.day.getmonth().getyear().getvalue())
return true;
else if(this.day.getmonth().getyear().getvalue()==date.day.getmonth().getyear().getvalue()) {
if(this.day.getmonth().getvalue()>date.day.getmonth().getvalue())
return true;
else if(this.day.getmonth().getvalue()==date.day.getmonth().getvalue()) {
if(this.day.getvalue()>date.day.getvalue())
return true;
else
return false;
}
else
return false;
}
else
return false;
}
public boolean equalTwoDates(DateUtil date) {
if(this.day.getmonth().getyear().getvalue() == date.day.getmonth().getyear().getvalue()
&&this.day.getmonth().getvalue()==date.day.getmonth().getvalue()
&&this.day.getvalue()==date.day.getvalue())
return true;
else
return false;
}
public String showDate() {
return String.valueOf(this.getday().getmonth().getyear().getvalue()) + "-" + String.valueOf(this.day.getmonth().getvalue()) + "-" + String.valueOf(this.day.getvalue());
}
public DateUtil getNextNDays(int n){
if(this.day.getmonth().getyear().isLeapYear()==false)
for (int i = 0; i < n; i++) {
if (day.getvalue() == day.getMon_maxnum()[day.getmonth().getvalue()-1]) {
day.resetMin();
if(day.getmonth().getvalue()==12) {
this.day.getmonth().resetMin();
this.day.getmonth().getyear().yearIncrement();
}
else
this.day.getmonth().monthIncrement();
}
else
day.dayIncrement();
}
if(this.day.getmonth().getyear().isLeapYear())
for (int i = 0; i < n; i++) {
if (day.getvalue() == day.getMon_minnum()[day.getmonth().getvalue()-1]) {
day.resetMin();
if(day.getmonth().getvalue()==12) {
this.day.getmonth().resetMin();
this.day.getmonth().getyear().yearIncrement();
}
else
this.day.getmonth().monthIncrement();
}
else
day.dayIncrement();
}
return this;
}
public DateUtil getPreviousNDays(int n) {
if(this.day.getmonth().getyear().isLeapYear()==false)
for (int i = 0; i < n; i++) {
if (day.getvalue() == 1) {
day.resetMax();
if(day.getmonth().getvalue()==1) {
this.day.getmonth().resetMax();
this.day.getmonth().getyear().yearReduction();
}
else
this.day.getmonth().monthReduction();
}
else
day.dayReduction();
}
else
for (int i = 0; i < n; i++) {
if (day.getvalue() == 1) {
day.resetMax();
if(day.getmonth().getvalue()==1) {
this.day.getmonth().resetMax();
this.day.getmonth().getyear().yearReduction();
}
else
this.day.getmonth().monthReduction();
}
else
day.dayReduction();
}
return this;
}
public DateUtil getDaysofDates(DateUtil Date) {
return this;
}
}
class Day{
private int value ;
private Month month = new Month();
int mon_maxnum[]= {31,28,31,30,31,30,31,31,30,31,30,31};
int mon_minnum[]={31,29,31,30,31,30,31,31,30,31,30,31};
public Day() {
}
public int[] getMon_maxnum() {
return this.mon_maxnum;
}
public int[] getMon_minnum() {
return this.mon_minnum;
}
public int getvalue() {
return this.value;
}
public void setvalue(int value) {
this.value=value;
}
public Month getmonth() {
return this.month;
}
public void setmonth(Month month) {
this.month=month;
}
public void resetMin() {
this.value = 1;
}
public void resetMax() {
if(this.getmonth().getyear().isLeapYear()==false)
this.value = mon_maxnum[this.month.getvalue()-2];
else
this.value = mon_minnum[this.month.getvalue()-2];
}
public boolean validate() {
if(this.getmonth().getyear().isLeapYear()&&this.value>=1&&this.value<=mon_minnum[this.month.getvalue()-1])
return true;
else if(this.getmonth().getyear().isLeapYear()==false&&this.value>=1&&this.value<=mon_maxnum[this.month.getvalue()-1])
return true;
else
return false;
}
public void dayIncrement() {
this.value++;
}
public void dayReduction() {
this.value--;
}
}
class Month{
private int value;
private Year year = new Year();
public Month() {
this.year = new Year();
}
public int getvalue() {
return value;
}
public void setvalue(int value) {
this.value=value;
}
public Year getyear() {
return year;
}
public void setyear(Year year) {
this.year=year;
}
public void resetMin() {
this.value = 1;
}
public void resetMax() {
this.value = 12;
}
public boolean validate() {
if(this.value>=1&&this.value<=12)
return true;
else
return false;
}
public void monthIncrement() {
this.value++;
}
public void monthReduction() {
this.value--;
}
}
class Year{
private int value;
public int getvalue() {
return value;
}
public void setvalue(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>=1900&&this.value<=2050)
return true;
else
return false;
}
public void yearIncrement() {
this.value++;
}
public void yearReduction() {
this.value--;
}
}
所建立的类与类之间关系复杂，导致代码过多，而在改进后的类图所写出来的代码就会相对来说更加好理解类与类之间的关系。此处用到继承关系，很好的减少了代码长度，使编程更加轻松，更加节省时间。
题目集4（7-3）相对较为简单，先做一个父类。
class Shape{
public Shape() {
System.out.println("Constructing Shape");
}
public double getArea(){
return 0.0;
}
}
然后通过继承写出子类，例如：
class Rectangle extends Shape{
private double width;
private double length;
public Rectangle() {
System.out.println("Constructing Rectangle");
}
public double getwidth() {
return width;
}
public double getlength() {
return length;
}
public void setwidth(double width) {
this.width=width;
}
public void setlength(double length) {
this.length=length;
}
public double getArea() {
return width*length;
}
}
不需要太多的技术手段。
题目集6（7-5）相对来说就会难很多，首先要考虑新建对象的重复使用。 public static double getarea(ArrayList <Double> sumarea){
double a = 0;
for (double i:sumarea) {
a=a+i;
}
return a;
}
public static void outarea(ArrayList <Double> sumarea) {
for (double i:sumarea) {
System.out.printf("%.2f ",i);
}
System.out.println();
}
}
class gongjv implements Comparator<Double>{
public int compare(Double o1, Double o2) {
if(o1>o2) {
return 1;
}else if(o1<o2) {
return -1;
}else
return 0;
}
}
题目集6（7-6）则多在了一个接口问题上
interface GetArea{
double getArea();
}
这样一段简单代码就可以解决问题。
接受给定的字符串，判断该字符串是否属于验证码。验证码是由四位数字或者字母（包含大小写）组成的字符串。对于这一题，其中涉及到正则表达式，相对来说较为简单。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
String str = in.nextLine();
if(str.length()!=4) {
System.out.println(str+"不属于验证码");
System.exit(0);
}
for(int i=0;i<str.length();i++) {
if (!Character.isLowerCase(str.charAt(i))&&!Character.isUpperCase(str.charAt(i))&&!Character.isDigit(str.charAt(i))) {
System.out.println(str+"不属于验证码");
System.exit(0);
}
}
System.out.println(str+"属于验证码");
}
}
同理下一题：
校验键盘输入的 QQ 号是否合格，判定合格的条件如下：
- 要求必须是 5-15 位；
- 0 不能开头；
- 必须都是数字；
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in);
String QQ = in.nextLine();
if(QQ.length()<5||QQ.length()>15||QQ.charAt(0)==0) {
System.out.println("你输入的QQ号验证失败");
System.exit(0);
}
for(int i=0;i<QQ.length();i++) {
if (!Character.isDigit(QQ.charAt(i))) {
System.out.println("你输入的QQ号验证失败");
break;
}
}
System.out.println("你输入的QQ号验证成功");
}
}
编写程序统计一个输入的Java源码中关键字（区分大小写）出现的次数。说明如下：
- Java中共有53个关键字（自行百度）
- 从键盘输入一段源码，统计这段源码中出现的关键字的数量
- 注释中出现的关键字不用统计
- 字符串中出现的关键字不用统计
- 统计出的关键字及数量按照关键字升序进行排序输出
- 未输入源码则认为输入非法
这是一道较难的题，没写出来。
踩坑点：
一、 null值
1.null关键字，大小写敏感
2.null是引用类型的默认值
3.null既不是对象也不是类型
4.可以强制转换成任何引用类型。
String s = (String) null; //right
int a = (int) null; //false
5.null值的引用类型变量，instance会返回false，如下：
Integer iAmNull = null;
System.out.println(iAmNull instanceof Integer); //false
6.null值的引用变量调用非静态方法，会抛npe，调用静态方法是可以的。
二、void
void在逻辑上是一种数据类型，但不是基本类型，也不是引用类型。
void提供了包装类Void，被定义成final，而且构造方法是private，也就是说不能实例化。
Void类型只能赋值为null，而void不能赋值，仅仅用来作为方法返回值输出。
Void能作为方法输入参数当做占位符，只能传值为null。
三、继承与多态
1.父类引用能指向子类对象，调用的方法具体取决于引用的对象，而不是取决于引用。
2.子类对父类方法不可见的情况下是不会覆盖的，而是重新定义了一个方法。
3.继承关系只有方法会覆盖，成员变量不会被覆盖。
4. super并没有代表超类的一个引用的能力，只是代表调用父类的方法而已。
这里应结合多态的override来理解上面的输出。
总结：
不懈追求要对源码进行不断的完善，要尽可能地实现作业所要求的功能。对我们来说，大量的写程序是必要的，但是过了某个阶段之后，写程序所带来的技术能力成长到一个相对极限，还不如多花点时间看书，，学习新技术和新观念，可以从实现源程序功能入手。
希望以后老师讲课可以更加细致一点，课堂联系和课后作业以及实验不要太难，pta会花费大量的时间，同时我会更多的学习慕课书本及其他学习资料或者视频。学习Java编程能力，一定要会拓展思路，不能只局限于此。在学好Java技术的同时，还需要掌握更多的知识，像与Java息息相关的大数据技术、web技术、javaEE技术等都是我们需要去拓展学习的。同时，多看一些java书籍对学习Java技术也有很大帮助。
浙公网安备 33010602011771号