PTA题目集1-3总结（22207331-张博文）

总体情况预览：
第一次：
第二次：
第三次：

（1）前言：

前三次作业题量适中，但是难度较大！
题目集作业主要考察了以下知识点：

一、基础语法

1. 变量与数据类型：包括整型（int、long 等）、浮点型（float、double）、字符型（char）、布尔型（boolean）等数据类型的定义和使用。
2. 运算符：算术运算符（+、-、*、/、%）、关系运算符（==、!=、>、<、>=、<=）、逻辑运算符（&&、||、!）等的使用。
3. 控制流语句：
条件语句（if-else、switch-case）：根据不同条件执行不同的代码块。
循环语句（for、while、do-while）：用于重复执行一段代码。

二、面向对象编程

1. 类与对象：定义类、创建对象、访问对象的属性和方法。
要求理解类的封装性、继承性和多态性。
2. 方法：定义方法、调用方法、方法的参数传递和返回值。
可能涉及方法的重载和重写。
3. 构造函数：
封装：将数据和操作封装在类中，通过访问修饰符控制访问权限。
继承：子类继承父类的属性和方法，实现代码复用。
多态：通过方法重写和向上转型实现多态性，使程序更加灵活。

三、数组与集合

1. 数组：定义数组、初始化数组、遍历数组。
可能会涉及数组的排序和查找操作。
2. 集合框架：
ArrayList和LinkedList 等集合类的使用。
掌握集合的添加、删除、遍历等操作。

四、异常处理

1. 理解异常的概念和分类。
2. 掌握 try-catch 语句块的使用，捕获和处理异常。
3. 可能会要求自定义异常类并进行处理。

五、输入输出

1. 控制台输入输出：使用 Scanner 类进行控制台输入，System.out.println()进行输出。
2. 文件输入输出：了解如何读取和写入文件。

（2）设计与分析：

题目集一-7.1：
设计一个名为Fan的类表示一个风扇。这个类包括：

1.三个名为SlOW、MEDIUM和FAST，其值为1、2和3常量表示风扇的速度。

2.一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。

3.一个名为on的boolean类型私有数据域表示风扇是否打开（默认值为false）。

4.一个名为radius的double类型私有数据域表示风扇的半径（默认值为5）。

5.一个名为color的string类型数据域表示风扇的颜色（默认值为white）。

6.这四个成员变量(数据域)的访问器和修改器。

7.一个无参构造方法;

8.一个有参构造方法 public Fan(int fanSpeed,boolean fanOn,double fanRadius,String fanColor) { ... }，

9.一个名为toString()的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就会返回一个由"fan is off"和风扇颜色以及半径组合成的字符串。

请在自己的草稿本上画出UML图，养成良好的设计习惯。

要求：创建两个Fan对象：

第一个对象利用无参构造方法构造默认风扇对象Fan1；

第二个对象依据输入的风扇属性，调用有参构造方法构造自定义风扇对象Fan2。

通过调用它们的toString方法显示这些对象。

部分代码如下：
import java.util.*;
class Fan{
public final int SlOW=1;
public final int MEDIUM=2;
public final int FAST=3;
private int speed=SlOW;
private boolean on=false;
private double radius=5;
private String color="white";
public Fan(){}
public void setSpeed(int speed) {
this.speed = speed;
}
public Fan(int fanSpeed,boolean fanOn,double fanRadius,String Color){
this.speed=fanSpeed;
this.on=fanOn;
this.radius=fanRadius;
this.color=Color;
}
public String toString(){
String s="speed "+speed+"\n"+"color "+color+"\n"+"radius "+radius+"\n";
if(on==false) s+="fan is off";
else s+="fan is on";
return s;
}
public class Main{
public static void main(String[] args){
System.out.println("-------\n"+ "Default\n"+ "-------");
Fan fan1=new Fan();
System.out.println(fan1.toString());
System.out.println("-------\n"+ "My Fan\n"+ "-------");
Scanner in=new Scanner(System.in);
int fanSpeed=in.nextInt();
boolean fanOn=in.nextBoolean();
double fanRadius=in.nextDouble();
String Color=in.next();
Fan fan2=new Fan(fanSpeed,fanOn,fanRadius,Color);
System.out.println(fan2.toString());
}
}

代码解释：

1. Fan类的整体结构
   这个Java程序定义了一个名为Fan的类来表示风扇的相关属性和行为，以及一个包含main方法的Main类来测试Fan类的功能。
2. Fan类中的常量
   在Fan类中，定义了三个public final类型的常量：SlOW、MEDIUM和FAST，它们的值分别为1、2和3。这些常量用于表示风扇可能的速度级别，一旦定义就不能被修改，提供了一种清晰的方式来指定风扇速度的取值范围。
3. 私有数据域
   private int speed = SlOW;：定义了一个私有整数类型的数据域speed来表示风扇的速度，默认值被初始化为SlOW常量所代表的值，即1。
   private boolean on = false;：一个私有布尔类型的数据域on，用于表示风扇是否处于打开状态，初始默认值为false，表示风扇初始是关闭的。
   private double radius = 5;：私有双精度类型的数据域radius，用于表示风扇的半径，默认值为5。
   private String color = "white";：私有字符串类型的数据域color，用于表示风扇的颜色，默认值为"white"。
4. 访问器和修改器方法（getter 和 setter）
   对于每个私有数据域，都定义了相应的访问器（getter）和修改器（setter）方法。
   例如，public int getSpeed()方法用于获取风扇的速度值，它返回speed数据域的值。
   public void setSpeed(int speed)方法用于设置风扇的速度，它接受一个整数参数，并将该参数赋值给speed数据域。
   类似地，还有getOn、setOn、getRadius、setRadius、getColor和setColor等方法，分别用于获取和设置风扇的开关状态、半径和颜色等属性。
5. 构造方法
   无参构造方法：public Fan()是一个无参构造方法，当创建Fan对象时如果没有传入任何参数，就会调用这个构造方法。它会使用之前定义的私有数据域的默认值来初始化一个风扇对象，即速度为SlOW、关闭状态、半径为5、颜色为"white"。
   有参构造方法：public Fan(int fanSpeed, boolean fanOn, double fanRadius, String Color)是一个有参构造方法，它接受四个参数，分别用于初始化风扇的速度、开关状态、半径和颜色。在方法内部，将传入的参数值赋给相应的私有数据域，从而创建一个具有指定属性的风扇对象。
6. toString方法
   public String toString()方法用于返回一个描述风扇状态的字符串。它首先构建一个包含风扇速度、颜色和半径信息的字符串，然后根据风扇的开关状态（通过on数据域判断），如果风扇是关闭的（on == false），就在字符串末尾添加"fan is off"；如果风扇是打开的，就在字符串末尾添加"fan is on"。最后返回这个完整的描述字符串。
7. Main类中的main方法
   在Main类的main方法中：
   首先输出一段分隔线和"Default"字样，表示接下来要创建并展示默认的风扇对象。然后通过Fan fan1 = new Fan();使用无参构造方法创建了一个默认的风扇对象fan1，并通过System.out.println(fan1.toString());调用fan1的toString方法将其状态信息输出到控制台。
   接着输出另一段分隔线和"My Fan"字样，表示接下来要创建一个自定义属性的风扇对象。通过创建Scanner对象来获取用户从控制台输入的风扇属性值，包括速度（fanSpeed）、开关状态（fanOn）、半径（fanRadius）和颜色（Color）。然后使用这些输入的值通过Fan fan2 = new Fan(fanSpeed, fanOn, fanRadius, Color);调用有参构造方法创建了一个自定义的风扇对象fan2，最后通过System.out.println(fan2.toString());输出fan2的状态信息到控制台，展示了自定义风扇的相关属性和状态。
   总体来说，这段代码实现了一个简单的Fan类来模拟风扇的基本属性和行为，并通过Main类中的main方法进行了测试，展示了如何创建默认和自定义属性的风扇对象以及获取它们的状态信息。

题目集二-7.2：
按要求完成程序的编写。
1、定义圆类Circle，其中包括：
（1）成员变量：private int radius
（2）无参构造方法 ，给radius赋值为2，并输出信息："This is a constructor with no para."；
（2）有参构造方法 ，接收用户给的radius赋值，并输出"This is a constructor with para."（如果给的半径小于等于0,则赋默认值为2）；
（3）为radius添加set方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2；
（4）为radius半径添加get方法，返回用户输入的半径；
（5）求圆面积方法getArea(), π使用Math.PI代替；
（6）定义toString方法，public String toString( )方法体为：
return "Circle [radius=" + radius + "]";
2、定义Main类，在main方法中，完成下列操作：
（1）定义并创建Circle类对象c1，输出c1对象，求c1的面积并输出；
（2）定义并创建Circle类对象c2，输出c2对象，求c2的面积并输出；
（3）从键盘接收整数半径，赋值给c2的半径，输出c2对象，求c2的面积并输出；
（4）从键盘接收整数半径，用有参构造方法创建Circle类对象c3，输出c3对象，求c3的面积后输出。

部分代码如下：

import java.util.Scanner;
class Circle {
private int radius;
public Circle() {
radius = 2;
System.out.println("This is a constructor with no para.");
}
public Circle(int radius) {
if (radius <= 0) {
this.radius = 2;
} else {
this.radius = radius;
}
System.out.println("This is a constructor with para.");
}
}
public class Main {
public static void main(String[] args) {
Circle c1 = new Circle();
System.out.println(c1);
System.out.printf("%.2f\n", c1.getArea());
Circle c2 = new Circle();
System.out.println(c2);
System.out.printf("%.2f\n", c2.getArea());
Scanner scanner = new Scanner(System.in);
int radius = scanner.nextInt();
c2.setRadius(radius);
System.out.println(c2);
System.out.printf("%.2f\n", c2.getArea());
radius = scanner.nextInt();
Circle c3 = new Circle(radius);
System.out.println(c3);
System.out.printf("%.2f\n", c3.getArea());
}
}

代码解释：

1. Circle类
   成员变量：
   private int radius;：定义了一个私有整型变量radius，用于存储圆的半径。将其设为私有可以限制对该变量的直接访问，只能通过类提供的方法来操作它，保证了数据的封装性。
   构造方法：
   无参构造方法：
   public Circle() {... }：这是无参构造方法。当创建Circle对象时，如果没有传入任何参数，就会调用这个方法。在方法内部，将radius赋值为2，并输出"This is a constructor with no para."，用于提示用户当前调用的是无参构造方法且已完成对象的初始化操作。
   有参构造方法：
   public Circle(int radius) {... }：这个是有参构造方法，它接收一个整数参数radius。在方法内部，首先判断传入的radius值是否小于等于0，如果是，则将类中的radius成员变量赋值为2（即设置默认值）；如果传入的radius值大于0，则将传入的值赋给成员变量radius。最后输出"This is a constructor with para."，提示用户当前调用的是有参构造方法且已完成对象的初始化操作。
   访问器和修改器方法（getter 和 setter）：
   getRadius方法：
   public int getRadius() { return radius; }：这是radius的访问器方法（getter），它返回radius成员变量的值，使得外部代码可以获取圆的半径信息。
   setRadius方法：
   public void setRadius(int radius) {... }：这是radius的修改器方法（setter）。它接收一个整数参数radius，并在方法内部判断该参数是否小于等于0。如果是，则将类中的radius成员变量赋值为2；如果参数大于0，则将传入的参数值赋给成员变量radius。这样就可以通过这个方法来安全地修改圆的半径值，同时保证半径不会被设置为无效的值（小于等于0）。
   业务方法：
   getArea方法：
   public double getArea() { return Math.PI * radius * radius; }：这个方法用于计算圆的面积。它根据圆的面积公式S = πr²，其中π使用Math.PI来表示，radius是通过getRadius方法获取到的圆的半径值，计算出圆的面积并返回结果。
   toString方法：
   @Override
   public String toString() { return "Circle [radius=" + radius + "]"; }：这个方法重写了Object类中的toString方法。它返回一个包含圆的半径信息的字符串，格式为"Circle [radius=" + radius + "]"，这样当我们直接输出Circle对象时，就会显示出这个有意义的字符串，而不是对象的默认哈希码等无意义信息，方便我们查看圆的相关信息。
2. Main类
   main方法：
   首先创建了两个Circle类的对象c1和c2，都是通过无参构造方法创建的。
   对于c1：
   Circle c1 = new Circle();：调用无参构造方法创建c1对象，此时c1的半径被初始化为2，并且控制台会输出"This is a constructor with no para."。
   System.out.println(c1);：输出c1对象，由于Circle类重写了toString方法，所以会输出"Circle [radius=2]"，展示了c1的半径信息。
   System.out.printf("%.2f\n", c1.getArea());：调用c1的getArea方法计算并输出c1的圆面积，保留两位小数。
   对于c2：
   Circle c2 = new Circle();：同样调用无参构造方法创建c2对象，半径也初始化为2，控制台输出"This is a constructor with no para."。
   后续对c2进行的操作与c1类似，先输出c2对象（显示半径信息），再计算并输出c2的圆面积。
   然后从键盘接收一个整数半径值，并将其赋值给c2的半径。
   Scanner scanner = new Scanner(System.in);：创建一个Scanner对象，用于从键盘读取用户输入。
   int radius = scanner.nextInt();：从键盘读取一个整数，并将其赋值给radius变量。
   c2.setRadius(radius);：调用c2的setRadius方法，将读取到的半径值设置给c2。如果读取到的值小于等于0，setRadius方法会将c2的半径设置为2。
   之后再次输出c2对象和计算其圆面积并输出，此时c2的半径可能已经根据用户输入或默认值进行了更新。
   最后再次从键盘接收一个整数半径值，并用有参构造方法创建Circle类的对象c3。
   radius = scanner.nextInt();：再次从键盘读取一个整数，覆盖之前的radius变量值。
   Circle c3 = new Circle(radius);：调用Circle类的有参构造方法创建c3对象，根据读取到的半径值来初始化c3的半径。如果读取到的值小于等于0，有参构造方法会将c3的半径设置为2。
   同样，先输出c3对象展示半径信息，然后计算并输出c3的圆面积。
   总体来说，这段代码实现了一个简单的Circle类来表示圆的基本属性（半径）和行为（计算面积），并通过Main类中的main方法进行了测试，展示了如何通过不同的构造方法创建圆对象、修改圆的半径以及计算圆的面积等操作。

题目集三-7.2：
7-2 jmu-java-日期类的基本使用
要求，给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。

部分代码如下：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String line = input.nextLine();
String nextLine = input.nextLine();//输入日期 格式为2020/3/21
String[] arr = line.split("-"); // 以/为分隔符，提取年月日
int year = Integer.parseInt(arr[0]); //转换为int型
int mouth = Integer.parseInt(arr[1]);
int day = Integer.parseInt(arr[2]);
String[] arr1 = nextLine.split(" ");
boolean valid1=Main.isValidDate(arr1[0],"yyyy-MM-dd");
boolean valid2=Main.isValidDate(arr1[1],"yyyy-MM-dd");
if (valid1false||valid2false){
System.out.println(arr1[0]+"或"+arr1[1]+"中有不合法的日期.");
System.exit(0);
}
DateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
try {
Date star = dft.parse(arr1[0]);//开始时间
String[] st1=arr1[0].split("-");
Date end = dft.parse(arr1[1]);
if (star.before(end)){
Year firstYear = Year.of(t11);
i3=t22-t11;
Calendar c1 = Calendar.getInstance();
//这里有bug必须减1
c1.set(t11, t1-1, Integer.parseInt(st1[2])); // 设置年月日，时分秒将默认采用当前值
int yearDay = c1.get(Calendar.DAY_OF_YEAR);
Calendar c2 = Calendar.getInstance();
//这里有bug必须减1
c2.set(t22, t2-1, Integer.parseInt(st2[2])); // 设置年月日，时分秒将默认采用当前值
int yearDa2y = c2.get(Calendar.DAY_OF_YEAR);
if (firstYear.isLeap(t11)){
int temp=yearDa2y+(366-yearDay);
if (end.before(star)){
System.out.println(arr1[1]+"早于"+arr1[0]+",不合法!");
System.exit(0);
}
if ((judge(t11,t1,Integer.parseInt(st1[2]))true)&&judge(t22,t2,Integer.parseInt(st2[2]))true){
System.out.println(arr1[1]+"与"+arr1[0]+"之间相差"+i1+"天,"+"所在月份相差"+i2+",所在年份相差"+i3+".");
}else {
System.out.println(arr1[0]+"或"+arr1[1]+"中有不合法的日期.");
}
} catch (ParseException e) {
e.printStackTrace();
}
public static boolean isValidDate(String dttm,String format) {
if (dttm == null || dttm.isEmpty() || format == null || format.isEmpty()) {
return false;
}
if (format.replaceAll("'.+?'", "").indexOf("y") < 0) {
format += "/yyyy";
DateFormat formatter = new SimpleDateFormat("/yyyy");
dttm += formatter.format(new Date());
}
String regex = "^\d{4}\-(0[1-9]|1[012])\-(0[1-9]|[12][0-9]|3[01])$";
DateFormat formatter = new SimpleDateFormat(format);
formatter.setLenient(false);
ParsePosition pos = new ParsePosition(0);
Date date = formatter.parse(dttm, pos);
代码解释：

1. 整体功能概述
   这段 Java 代码主要实现了两个功能：一是判断给定的单个日期是否合法，并在合法的情况下进一步判断该年是否为闰年以及该日期在当年、当月、当周是第几天；二是判断给定的起始日期和结束日期是否合法，且结束日期是否不早于起始日期，若均合法则计算并输出两个日期之间相差的天数、月数和年数。
2. 代码结构及主要方法解释
   main方法
   在main方法中，首先通过Scanner从控制台读取用户输入的两行字符串，分别用于处理单个日期判断和起始日期与结束日期的判断相关操作。
   处理单个日期判断：
   读取用户输入的单个日期字符串（格式如2020/3/21），通过split方法以/为分隔符将其拆分成包含年、月、日的字符串数组，再将各部分转换为整数类型。
   调用isValidDate方法判断该日期是否合法格式，同时调用judge方法进一步从数值范围角度判断日期是否合理（例如每月的天数是否符合实际情况）。若两者都为真，则进行后续操作：
   创建Calendar实例，设置其年、月（这里存在一个小问题，设置月份时应该减 1，因为Calendar类中月份是从 0 开始计数的）、日，然后通过Calendar的相关方法获取该日期是当年第几天（DAY_OF_YEAR）、当月第几天（DAY_OF_MONTH）以及当周第几天（DAY_OF_WEEK，这里还对获取到的星期值进行了调整，将周日的值从 1 调整为 7，其他星期值减 1，使其符合常规的星期计数习惯）。
   通过Year类判断该年是否为闰年，如果是则输出相应提示，并最终输出该日期在当年、当月、当周的天数信息。若日期不合法，则输出相应的无效提示。
   处理起始日期与结束日期判断：
   读取用户输入的包含起始日期和结束日期的字符串（格式如2020-03-21 2021-05-10），同样通过split方法拆分出两个日期字符串，分别调用isValidDate方法判断它们是否合法格式。若其中有不合法的日期，则输出相应提示并结束程序。
   若两个日期格式都合法，通过SimpleDateFormat将日期字符串解析为Date类型对象，以便后续比较和计算。同时提取出年、月、日的整数值用于后续计算。
   判断起始日期和结束日期的先后顺序，若结束日期早于起始日期，则输出相应提示并结束程序。
   若起始日期和结束日期顺序正确且都合法，通过一系列复杂的计算来确定两个日期之间相差的天数、月数和年数：
   首先根据起始日期和结束日期的年份判断是否为闰年，然后通过Calendar实例分别获取两个日期是当年第几天。
   对于相差的天数计算，分闰年和非闰年情况进行处理，在计算过程中还需要考虑中间年份的闰年情况，通过循环遍历中间年份并根据是否为闰年累加相应的天数，最后加上起始日期到当年结束的天数以及结束日期在当年的天数得到总相差天数。
   对于相差的月数，直接用结束日期的月份减去起始日期的月份得到。
   对于相差的年数，用结束日期的年份减去起始日期的年份得到。
   最后输出两个日期之间相差的天数、月数和年数的信息。
   isValidDate方法
   该方法用于判断给定的日期字符串是否为合法的日期格式。
   首先进行一些基本的空值和格式字符串的校验，如果日期字符串或格式字符串为空，则直接返回false。
   如果格式字符串中不包含y（用于表示年），则在格式字符串末尾添加/yyyy，并将当前日期的年份添加到日期字符串末尾，以确保能够正确解析年份。
   通过正则表达式^\d{4}\-(0[1-9]|1[012])\-(0[1-9]|[12][0-9]|3[01])$来校验日期字符串是否符合yyyy-MM-dd的格式，如果不符合则返回false。
   创建SimpleDateFormat实例并设置为非宽松模式（setLenient(false)），然后通过ParsePosition尝试解析日期字符串。如果解析结果为null或者解析过程中出现错误（通过getErrorIndex判断），或者解析的索引位置不等于日期字符串的长度（表示没有完全解析成功），或者解析出的年份大于 9999，则都返回false。只有在所有校验都通过的情况下才返回true。
   judge方法
   该方法用于从数值范围角度判断给定的年、月、日组合是否合理。
   根据月份的不同情况进行判断：
   如果月份是 1、3、5、7、8、10、12，只要日期小于等于 31 就认为是合理的，返回true；否则返回false。
   如果月份小于 1 或大于 12，直接返回false。
   如果月份是 2，需要根据年份是否为闰年进一步判断日期的合理性。如果年份能被 400 整除或者能被 4 整除但不能被 100 整除（即闰年条件），且日期小于等于 29 则返回true；否则返回false。如果年份不是闰年，且日期小于等于 28 则返回true；否则返回false。
   如果是其他月份（4、6、9、12），只要日期小于等于 30 就认为是合理的，返回true；否则返回false。
3. 代码存在的问题
   在设置Calendar实例的月份时，代码中存在一个小错误，应该将传入的月份值减 1，因为Calendar类中月份是从 0 开始计数的，目前代码中虽然有相关注释指出这个问题，但实际操作中可能会因为疏忽而忘记修改。
   总体上来说，这段代码实现了较为复杂的日期相关的判断和计算功能，但在代码的简洁性和一些细节处理上还有一定的优化空间，比如可以考虑使用 Java 8 引入的新的日期时间 API（如java.time包下的相关类）来更加简洁和准确地实现类似功能，避免一些如Calendar类中月份计数起始点不同等带来的小麻烦。

（3）踩坑心得：

作为初学者，可能会遇到不少的“坑”，以下是我的踩坑心得：

一、语法错误方面

1. 括号不匹配：在编写复杂的表达式或方法调用时，很容易忘记括号的配对，导致编译错误。一定要仔细检查每一个括号的开闭。
2. 变量未初始化：Java 要求变量在使用前必须进行初始化。如果忘记初始化变量就进行使用，会引发编译错误。在定义变量时，最好养成同时进行初始化的习惯，或者在使用前确保变量已经被正确赋值。
3. 数据类型不匹配：在进行运算或赋值操作时，数据类型必须匹配。例如，不能将一个字符串直接赋值给一个整数变量。要注意数据类型的转换规则，避免出现类型不匹配的错误。

二、逻辑错误方面

1. 边界条件考虑不足：很多题目都有边界情况，比如数组的下标从 0 开始，循环的边界值设置错误可能导致结果错误或者数组越界异常。在编写代码时，要充分考虑各种边界情况，进行全面的测试。
2. 循环条件错误：循环是 Java 中常用的结构，但很容易出现循环条件设置错误的情况。例如，循环次数计算错误、循环条件判断不准确等。在编写循环代码时，要仔细分析循环的目的和条件，确保循环能够正确执行。
3. 方法调用错误：在调用方法时，参数传递错误或者对方法的返回值理解错误都可能导致程序出现问题。要仔细阅读方法的文档说明，了解方法的参数和返回值类型，确保正确调用方法。

三、调试技巧方面

1. 学会使用调试工具：在遇到问题时，不要盲目猜测错误原因，要学会使用调试工具，如 IDE 中的调试器。通过设置断点、单步执行等方式，可以逐步跟踪程序的执行过程，找出问题所在。
2. 打印调试信息：在无法使用调试工具的情况下，可以通过打印关键变量的值、程序执行的步骤等信息来帮助定位问题。但要注意不要过度打印信息，以免影响程序的性能和可读性。
3. 对比正确结果：如果有已知的正确结果，可以将自己的程序输出与正确结果进行对比，找出差异所在。

（4）改进建议：
有九点：
1. 巩固基础语法，定期复习和总结。
2. 建立自己的代码模板，用于常见的结构，如循环、输入输出。
3. 多做笔记，记录易错点和新学到的知识点。
4. 加入学习小组，和同学交流解题思路和经验。
5. 主动研究优秀代码，学习别人的编程习惯和技巧。
6.认真分析题目，可画流程图辅助理解逻辑。
7.在本地用测试用例充分测试代码后再提交。
8.总结错题，建立错题集并定期回顾。
9.积极参加线上线下编程交流活动。

（5）总结与反思:

在学习 PTA 中的 Java 题目集的过程中，作为初学者，我收获了许多宝贵的经验和教训。以下是我的总结和反思：

一、总结

（1）知识与技能的提升

1.通过完成各种题目，我对 Java 语言的基础语法有了更深入的理解，包括变量、数据类型、运算符、控制流语句等。同时，也掌握了一些常用的编程技巧，如循环的使用、条件判断、数组操作等。
2.学习了面向对象编程的基本概念，如类、对象、方法、属性等。能够创建简单的类，并使用对象进行操作。了解了封装、继承和多态的概念，并在实际编程中尝试运用。
3.掌握了基本的输入输出操作，能够从控制台读取用户输入，并将结果输出到控制台。同时，也学会了如何处理异常情况，提高了程序的稳定性和可靠性。
4.提升了解决问题的能力。在面对各种题目时，学会了分析问题、设计算法、编写代码和调试程序。通过不断地尝试和实践，逐渐提高了自己的编程能力。

（2）学习方法的改进

1.学会了如何有效地阅读题目。在开始编程之前，认真阅读题目要求，理解问题的本质和输入输出格式。对于复杂的题目，可以通过画图、举例等方式帮助理解。
2.掌握了调试技巧。在编程过程中，不可避免地会遇到各种错误。学会了使用调试工具，如断点调试、输出中间结果等，快速定位错误并进行修复。
3.注重代码规范。良好的代码规范可以提高代码的可读性和可维护性。在编程过程中，注意变量命名、代码缩进、注释等方面的规范，养成良好的编程习惯。
4.多做练习。编程是一项需要不断练习的技能。通过完成更多的题目，不仅可以巩固所学的知识，还可以提高自己的编程速度和准确性。

二、反思

1. 基础知识的不扎实

在做题过程中，发现自己对一些基础知识的掌握还不够扎实。例如，对数据类型的转换、运算符的优先级等方面的理解还存在一些模糊的地方。需要进一步加强对基础知识的学习和理解，打牢基础。
面向对象编程的理解还不够深入。在编写类和对象的代码时，有时会出现一些逻辑错误。需要更加深入地学习面向对象编程的概念和原则，提高自己的编程思维能力。

2. 编程习惯的问题

代码的可读性有待提高。在编写代码时，有时会为了追求速度而忽略了代码的可读性。这会给后续的调试和维护带来困难。需要养成良好的编程习惯，注重代码的可读性和可维护性。
缺乏代码优化的意识。在完成题目后，没有对代码进行优化的习惯。这可能会导致程序的性能不够高效。需要学习一些代码优化的技巧，提高程序的性能。

3. 解决问题的能力有待提高
在面对一些复杂的题目时，有时会感到无从下手。需要进一步提高自己分析问题和解决问题的能力。可以通过学习更多的算法和数据结构知识，拓宽自己的解题思路。
缺乏独立思考的能力。在遇到问题时，有时会过于依赖搜索引擎和他人的帮助。需要培养自己独立思考的能力，尝试自己解决问题。只有通过不断地尝试和实践，才能真正提高自己的编程能力。

总之，通过学习 PTA 中的 Java 题目集，我在知识与技能、学习方法等方面都有了很大的提升。同时，也认识到了自己存在的不足之处。在今后的学习中，我将继续努力，不断提高自己的编程能力，为今后的学习和工作打下坚实的基础。