一：前言
第一次题目集
第一次题目集涉及了基础的数学计算、数据类型转换、流程控制、数组、字符串操作、位运算等知识点。难度从较低到较高都有涉及，需要一定的编程基础和数学基础。其中，部分题目还可以通过扩展来增加难度。在解题过程中，需要注意特殊情况的处理，如输入非法等。对于第7题和第8题，则需要关注浮点数精度问题和二进制数值的基本知识。总体而言，第一次题目集适合Java编程入门或基础练习，也适合进行算法和逻辑思维训练。
第二次题目集
本次题目集主要涵盖了Java编程中的关键知识点，包括面向对象编程中的类、对象、属性和方法的基本概念与使用。同时，还包括了对数组的创建、访问和遍历等基本操作，以及创建多个类之间的关联关系，实现数据的交互和处理的技巧。此外，还包括了如何寻找和处理数组中的重复数据，理解封装性概念并将代码中的属性和方法进行封装的能力。同时，我们还将学习如何进行进制转换，将度分秒转换为十进制或将十进制转换为度分秒。最后，我们还将了解如何进行用户交互，基于命令行或控制台进行用户输入输出的交互操作。另外，我们需学习日期处理中的基本操作，包括日期格式化和计算日期差等技能。
第三次题目集
题目集三是围绕Java面向对象编程的一系列知识点展开的，这些知识点包括类和对象、数据封装、构造方法、成绩输入和统计以及输出结果等。掌握这些关键的编程技能是成为成功的Java开发人员的必要条件。通过实践题目集三中的问题，可以深入了解如何在Java中创建类和对象、使用访问修饰符控制属性的可访问性、初始化对象、输入学生的成绩并统计总分和平均分等。此外，还可以通过设计方法输出学生的成绩信息，并且可以将信息输出到控制台。
二： 设计与分析
复杂度：
1. 这段代码实现了一个简单的Java程序，用于存储和输出5个学生的信息。该程序包含两个类，一个是 student 类，用于存储学生的基本信息；另一个是 Main 类，用于输入学生信息，并进行输出处理。
首先， student 类有如下五个私有成员变量：
xuehao：学号，类型为字符串。
xinmin：姓名，类型为字符串。
yuwen：语文成绩，类型为整型。
shuxue：数学成绩，类型为整型。
wuli：物理成绩，类型为整型。
在 student 类中，定义了一个公共的构造方法，该方法接受上述五个参数，用于初始化这些成员变量。同时，该类还定义了一些公共的方法，用于获取成员变量或计算学生的总分和平均分。其中，计算平均分需要注意数据类型转换（利用除法 / 经行浮点数除法并返回一个浮点型结果）。
其次， Main 类主要用于输入学生信息、创建 student 对象、调用对象方法计算总分和平均分、输出处理，并通过输入输出流 Scanner 和控制台进行交互。具体来说，程序使用 Scanner 读取用户从控制台输入的字符串，将其以空格为分隔符分割，并依次赋值给 student 对象相应的成员变量。然后，程序通过循环遍历输出每个学生的信息，包括学号、姓名、总分、平均分等。
该程序在处理输入时，需要注意字符串的格式，输入语句和输出格式的处理方式。同时，还需要注意将字符串类型转换成数字类型，并进行浮点型除法操作。总之，这段代码是一个简单的Java程序，主要用于练习实现基本的输入输出、对象创建和调用方法等操作。
学生类：
class student {
private String xuehao,xinmin;
private int yuwen,shuxue,wuli,zongfen;
double pinjun;
public student(String xuehao, String xinmin, int yuwen,int shuxue,int wuli ) {
this.xuehao=xuehao;
this.xinmin=xinmin;
this.yuwen=yuwen;
this.shuxue=shuxue;
this.wuli=wuli;
}
public String getxuehao() {
return xuehao;
}
public String getxinmin() {
return xinmin;
}
public int getyuwen() {
return yuwen;
}
public int getshuxue() {
return shuxue;
}
public int getwuli() {
return wuli;
}
public int getzongfen() {
zongfen=yuwen+shuxue+wuli;
return zongfen;
}
public double getpinjun() {
pinjun=(zongfen)/3.00;
return pinjun;
}
}
2. 该源码主要实现了一个学生成绩管理系统。其中，student类表示学生信息，包括学号、姓名、语文成绩、数学成绩和物理成绩；chengji类表示学生成绩，包括平时成绩和期末成绩；Main类是程序的入口。
在Main类中，首先定义了一个student类型的数组arr，用于存储所有学生的信息。接着使用Scanner类获取用户输入的学生信息，将其分割并提取出学号、姓名和各科成绩，通过调用chengji类的方法计算出各门课程的总成绩，并存储在相应的变量中。最后，将每个学生的学号、姓名、总成绩、平均分和各科成绩输出到屏幕上。
值得注意的是，在该源码中，还使用了许多封装性较强的变量或方法，如私有成员变量和公有get方法等，保证了程序的安全性和可读性。同时，对输入的数据进行了一定的异常处理，使程序更加健壮。
复杂度：
学生类：
class student {
private String xuehao,name;
private int yuwen,shuxue,wuli;
double pingjun1,pingjun2,pingjun3;
public student(String xuehao,String name,int yuwen,int shuxue,int wuli) {
this.xuehao=xuehao;
this.name=name;
this.yuwen=yuwen;
this.shuxue=shuxue;
this.wuli=wuli;
}
public String getxuehao() {
return xuehao;
}
public String getname() {
return name;
}
public int getyuwen() {
return yuwen;
}
public int getshuxue() {
return shuxue;
}
public int getwuli() {
return wuli;
}
public double getpingjun3() {
pingjun3=(yuwen+shuxue+wuli)/3.0;
return pingjun3;
}
}
成绩类：
class chengji {
private int pingshi ,qimuo,zong;
public chengji(int pingshi,int qimuo) {
this.pingshi=pingshi;
this.qimuo=qimuo;
}
public int getpingshi()
{
return pingshi;
}
public int getqimuo()
{
return qimuo;
}
public int getzong()
{
zong=(int) ((pingshi*0.4)+(qimuo*0.6));
return zong;
}
}
3. 该源码是一个简单的命令行菜单点餐系统，由三个类组成：dish、menu、order以及record。
复杂度：
dish类表示每一道菜品的信息，其中包括菜名、价格和份额。其中的getPrice方法是一个计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）。
class dish {
private String name;//菜品名称
double price;
private int portion;//单价
public dish(String name, int price ) {
this.name=name;
this.price=price;
}
public String getname( ) {
return name;
}
double getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
{
if(portion==1) {
price= price;
}
if(portion==2) {
price= price*1.5;
}
if(portion==3) {
price= price*2.0;
}
price=Math.round(price);
return price;
}
}
menu类表示菜单，其中包含了四道菜品的信息（西红柿炒蛋、清炒土豆丝、麻婆豆腐、油淋生菜），用数组arr存储。其中的searthDish方法根据菜名在菜谱中查找菜品信息，返回Dish对象。getPrice方法根据菜名获取菜品价格。
class menu {
private dish[] arr=new dish[4];
private dish cai;
private double Price;
private String dishName,name;
public menu( ) {
arr[0]=new dish("西红柿炒蛋" ,15 );
arr[1]=new dish("清炒土豆丝" ,12 );
arr[2]=new dish("麻婆豆腐" ,12 );
arr[3]=new dish("油淋生菜" ,9 );
// this.dishName=dishName;
}
public String getname(String dishName) {
if( dishName.equals("西红柿炒蛋") ) {
name = "西红柿炒蛋";
}
else if( dishName.equals("清炒土豆丝") ) {
name = "清炒土豆丝";
}
else if( dishName.equals("麻婆豆腐") ) {
name = "麻婆豆腐";
}
else if( dishName.equals("油淋生菜") ) {
name = "油淋生菜";
}
else {
name = "无";
}
return name;
}
public double getPrice(String dishName) {
if( dishName.equals("西红柿炒蛋") ) {
Price = 15;
}
if( dishName.equals("清炒土豆丝") ) {
Price = 12;
}
if( dishName.equals("麻婆豆腐") ) {
Price = 12;
}
if( dishName.equals("油淋生菜") ) {
Price = 9;
}
return Price;
}
public dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
{
if( dishName.equals("西红柿炒番茄") ) {
cai= arr[0];
// price = 15;
}
if( dishName.equals("清炒土豆丝") ) {
cai= arr[1];
}
if( dishName.equals("麻婆豆腐") ) {
cai= arr[2];
}
if( dishName.equals("油淋生菜") ) {
cai= arr[3];
}
return cai;
}
}
record类表示一条订单记录，其中包括菜品和份额，其中的getPrice方法是计价，计算本条记录的价格。
class Record {
dish d;//菜品
private int portion;//份额（1/2/3代表小/中/大份）
private double Price2;
private menu caidang;
public Record( dish d, int portion ) {
this.d=d;
this.portion=portion;
}
public dish getd() {
return d;
}
public int getportion() {
return portion;
}
public double getPrice(dish d, int portion )//计价，计算本条记录的价格
{
if( d.getname().equals("西红柿炒蛋") ) {
Price2=d.getPrice( portion);
}
if( d.getname().equals( "清炒土豆丝") ) {
Price2=d.getPrice( portion);
}
if( d.getname().equals( "麻婆豆腐") ) {
Price2=d.getPrice( portion);
}
if( d.getname().equals( "油淋生菜") ) {
Price2=d.getPrice( portion);
}
return Price2;
}
}
order类表示一个订单，其中包含多条记录。其中的getTotalPrice方法是计算订单的总价，用到了record类的getPrice方法。addARecord方法是添加一条菜品信息到订单中。
class Order {
private double TotalPrice;
dish d2;
Record reco ;
menu caidan;
private Record[] rec=new Record[10] ;//保存订单上每一道的记录
//rec dish ,fenger
public Order( Record reco ) {
this.reco=reco;
}
public double getTotalPrice( Record rec )//计算订单的总价
{
TotalPrice= rec.getPrice( rec.getd(),rec.getportion() );//cai1.getPrice(caipin1, num)
return TotalPrice;
}
Record addARecord(String dishName,int portion) {
dish d2=new dish(dishName,(int) caidan.getPrice(dishName));
// Record rec2=new Record(d2.dish(dishName),portion);
Record rec2=new Record(d2, portion );
return rec2;
}
//添加一条菜品信息到订单中。
}
main方法是程序入口，在循环输入菜品和份额后，将其生成为菜品和份额的对象，再生成相应的订单记录，总价通过加上每一条记录的价格而得出。
public class Main {
public static void main(String[] args) {
Order c1;
Record cai1;
menu caidan=new menu() ;
double TotalPrice=0;
Scanner nb=new Scanner(System.in);
while(true) {
String arr=nb.nextLine();
if( arr.equals("end") ) {
break;
}
String[] arr2=arr.split(" ");
int num=Integer.parseInt(arr2[1]);//份额
//System.out.print( num );
dish caipin1=new dish(arr2[0],(int) caidan.getPrice(arr2[0]));//菜
if( caidan.getname(arr2[0]).equals("无")) {
//System.out.print();
System.out.print( arr2[0] +"does not exist" );
}
//System.out.print( (int) caidan.getPrice(arr2[0]) );
cai1=new Record(caipin1, num );//订单
//System.out.print(cai1.getPrice(caipin1, num) );//单价
c1=new Order( cai1 );
TotalPrice=TotalPrice+c1.getTotalPrice(cai1) ;
}
System.out.println( TotalPrice );
}
}
4.
复杂度：
bixiu 类：
成员变量：longbiao（表示课程表）、longkaobiao（表示考试安排）
构造函数：初始化 longbiao 和 longkaobiao
方法：
biao(String xueke)：将学科添加到课程表，并返回更新后的课程表
kaobiao(String xueke)：将学科添加到考试安排，并返回更新后的考试安排
getlongbiao()：获取当前课程表
getlongkaobiao()：获取当前考试安排
class bixiu {
String longbiao,longkaobiao;
public bixiu() {
longbiao = "";
longkaobiao="";
}
public String biao( String xueke ) {
longbiao=longbiao+xueke;
return longbiao;
}
public String kaobiao( String xueke ) {
longkaobiao=longkaobiao+xueke;
return longkaobiao;
}
public String getlongbiao() {
return longbiao;
}
public String getlongkaobiao() {
return longkaobiao;
}
}
kefeng 类：
成员变量：name（姓名）、qizhong（期中成绩）、qimuo（期末成绩）、feng（分数）
构造函数：初始化姓名、期中成绩、期末成绩和分数
方法：
getname()：获取姓名
getqizhong()：获取期中成绩
getqimuo()：获取期末成绩
getfeng()：获取分数
class kefeng {
private String name;
private int feng;
private int qizhong;
private int qimuo;
public kefeng( String name, int qizhong, int qimuo,int feng ) {
this.name=name;
this.feng=feng;
this.qizhong=qizhong;
this.qimuo=qimuo;
}
public String getname() {
return name;
}
public int getqizhong() {
return qizhong;
}
public int getqimuo() {
return qimuo;
}
public int getfeng() {
return feng;
}
}
student 类：
成员变量：name（姓名）、ID（学号）、qizhong（期中成绩）、qimuo（期末成绩）、zong（总成绩）、ke（学科）
关联关系：包含一个 bixiu 类的对象 biao
构造函数：初始化姓名、学号、学科、期中成绩和期末成绩
方法：
getname()：获取姓名
getID()：获取学号
getke()：获取学科
getqizhong()：获取期中成绩
getqimuo()：获取期末成绩
getzong()：计算总成绩
shifoubixiu(bixiu biao, String ke)：判断是否必修学科
shifoukaoshi(bixiu biao, String ke)：判断是否有考试安排
class student {
private String name;
private String ID;
private int qizhong;
private int qimuo,zong;
private String ke;
bixiu biao=new bixiu();
public student(String name,String ID,String ke,int qizhong,int qimuo) {
this.name=name;
this.ID=ID;
this.ke=ke;
this.qizhong=qizhong;
this.qimuo=qimuo;
}
public String getname() {
return name;
}
public String getID() {
return ID;
}
public String getke() {
return ke;
}
public int getqizhong() {
return qizhong;
}
public int getqimuo() {
return qimuo;
}
public int getzong() {
if(qimuo==0 ) {
return qizhong;
}else {
zong=(int) (qizhong*0.3+qimuo*0.7);
return zong;
}
}
public int shifoubixiu( bixiu biao,String ke ) {
if( biao.getlongbiao().contains( ke ) ) {
return 1;
}else {
return 0;
}
}
public int shifoukaoshi( bixiu biao,String ke ) {
if( biao.getlongkaobiao().contains( ke ) ) {
return 1;
}else {
return 0;
}
}
}
xueke 类：
成员变量：xuekename（学科名称）、xuekexinzhi（学科性质）、kaoshileixin（考试类型）
构造函数：初始化学科名称、学科性质和考试类型
方法：
getxuekename()：获取学科名称
getxuekexinzhi()：获取学科性质
getkaoshileixin()：获取考试类型
class xueke {
private String xuekename,xuekexinzhi,kaoshileixin;
public xueke(String xuekename,String xuekexinzhi,String kaoshileixin ) {
this.xuekename=xuekename;
this.xuekexinzhi=xuekexinzhi;
this.kaoshileixin=kaoshileixin;
}
public String getxuekename() {
return xuekename;
}
public String getxuekexinzhi() {
return xuekexinzhi;
}
public String getkaoshileixin() {
return kaoshileixin;
}
}
三：踩坑心得
1. 数据类型选择的问题：需要根据题目要求，选择合适的数据类型，避免在精度上出现问题。
例如7-4 NCHU_房产税费计算题
题目要求评估价（整数/单位万元）, 房屋面积（浮点数/单位平方米）
所以System.out.println((float)qs+" "+(float)yhs+" "+(float)jyf+" "+(float)chf);
2.Java方法名大小写问题：Java对于方法名的大小写非常敏感，需要遵循标准命名规范，避免因为大小写问题导致代码出错。
3.多条件判断问题：过多的if else语句会使得程序变得臃肿，影响代码的可读性和可维护性，可以使用switch语句进行优化。
例如7-2 课程成绩统计程序-1
其中有大量判断，选修-考试，选修考察，必修考试，必修考察，考试2成绩，考察1成绩，可以使用switch语句进行优化。
4.精度问题：对于需要涉及到浮点数计算的题目，需要注意精度问题，可以使用BigDecimal类等精度计算工具进行处理。
5.使用合适的数学公式：在数学问题中，需要根据实际情况选择合适的数学公式进行计算，避免精度丢失等问题。
例如7-1 成绩计算-1-类、数组的基本运用
其中要求平均分精确到小数点后两位，舍去部分按四舍五入规则计入最后一位
四：主要困难以及改进建议
主要困难：
1.类与对象的概念理解：理解类与对象的关系和区别可能是初学者的一个难点。确保清楚地理解类是对象的模板，而对象是根据类创建的实体。
2.数据封装的实现：封装是面向对象编程的重要概念，但对于如何正确地封装属性和方法会有困惑。需要注意使用合适的访问修饰符(private、protected、public)来限制属性的可访问性。
3.构造方法的使用：构造方法用于初始化对象，在正确地定义和使用构造方法方面会有困难。确保正确地在类中定义构造方法，并了解如何传递参数进行对象的初始化。
改进建议：
1. 在优化代码时，可以考虑以下几个方面来简化和提高代码效率：
2.模块化设计：将功能性需求封装成函数或方法，提高代码的可读性和复用性。将代码拆分成适当的模块，每个模块专注于特定的功能，并提供清晰的接口。
3.数据结构优化：选择合适的数据结构来存储和处理数据，以提高代码效率。例如，使用哈希表（HashMap）来存储课程表和考试安排，可以快速查找和更新。
4.算法优化：评估并改进算法的时间复杂度。使用更高效的算法可以降低代码的复杂度和执行时间。
5.代码重构：检查代码中是否存在重复的部分，通过抽象和重构来简化代码。避免冗长的条件判断和嵌套循环，提取公共代码段为函数，减少冗余和重复代码的出现。
通过优化代码，可以简化代码结构、提高代码效率，并降低调试代码时的困难度。
五：总结
通过完成这三次题目集，我对面向对象编程的理解有了进一步的提升。通过创建学生类和课程类作为基本数据结构，并合理地封装属性和方法，我学会了如何实现数据的封装和保护。此外，正确使用构造方法进行对象的初始化也是很重要的一点。在输入学生的成绩并统计总分、平均分等方面，我意识到需要考虑合适的逻辑和算法，以确保结果的准确性。最后，输出结果的选择和实现也是需要仔细考虑的，尤其是根据需求选择合适的输出方式。
通过解决问题中遇到的困难，我不仅巩固了面向对象编程的基础知识，还提升了逻辑思维和问题解决能力。我深刻体会到细心和耐心在编程过程中的重要性，同时也意识到沟通和寻求帮助的重要性。通过与其他人交流和查阅相关资源，我得到了很多宝贵的指导和建议。