在学习 Java 这门编程语言的过程中，我收获了许多宝贵的知识和经验。Java 作为一种广泛应用的面向对象编程语言，具有强大的功能和良好的可扩展性，为我的编程之路打开了新的大门。
一、学习收获
1.面向对象编程思想
Java 让我深入理解了面向对象编程的核心概念，如类、对象、封装、继承和多态。通过将现实世界中的事物抽象为类和对象，并利用它们之间的关系来构建程序，使代码更加模块化、可维护和可扩展。
2.异常处理机制
Java 的异常处理机制让程序更加健壮。学会了如何捕获和处理可能出现的异常情况，避免程序因意外错误而崩溃，提高了程序的稳定性和可靠性。
3.集合框架
Java 的集合框架为数据存储和操作提供了丰富的类和接口，如 ArrayList、HashMap 等。能够根据不同的需求选择合适的集合类型，高效地管理和操作数据。
4.多线程编程
多线程编程是 Java 中的一个重要特性，它让程序能够同时执行多个任务，提高了程序的执行效率。通过学习线程的创建、同步和并发控制，我能够开发出更复杂的并发程序。
二、项目分析
在学习过程中，我参与了一个简单的学生计算成绩的项目开发。通过这个项目，我将所学的知识应用到实际中，进一步加深了对 Java 的理解。
以下是项目中的部分代码示例：
package zy;
public class Student {
public String id;
public String name;
public String className;
private double score1;
private double score2;
// 无参构造方法
public Student() {
this.id = "20110410000";
this.name = "李明";
this.className = "软件技术";
}
// 有参构造方法
public Student(String id, String name, String className, double score1, double score2) {
this.id = id;
this.name = name;
this.className = className;
this.score1 = score1;
this.score2 = score2;
}
// Getters
public String getId() {
return id;
}
public String getName() {
return name;
}
public String getClassName() {
return className;
}
public double getScore1(){
return score1;
}
public double getScore2(){
return score2;
}
// Setters
public void setId(String id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setClassName(String className) {
this.className = className;
}
public void setScore1(double score1) throws Exception{
if(score1 < 0 || score1 > 100){
throw new Exception("成绩值非法，不能小于0!");
}else{
this.score1=score1;
}
}
public void setScore2(double score2) throws Exception{
if(score2 < 0 || score2 > 100){
throw new Exception("成绩值非法，不能小于0!");
}else{
score2=score2;
}
}
public double sumOfScore() {
return score1 + score2;
}
public double maxOfScore() {
if (score1>score2){
return score1;
}else{
return score2;
}
}这个Java类 Student 定义了一个学生对象，包含学生的基本信息和成绩。类中包含了两个构造方法：一个无参构造方法，它为学生的ID、姓名和班级分配默认值；和一个有参构造方法，允许外部设置学生的所有属性。
这个类也包含了用于获取和设置学生属性的getter和setter方法。其中，setScore1和setScore2setter方法包含了异常处理，以确保成绩在0到100之间。如果成绩不在这个范围内，方法将抛出一个异常。
最后，类提供了两个计算方法：sumOfScore 用于计算和返回两个成绩的总和，maxOfScore 用于返回两个成绩中的最大值。
package zy;
import java.util.Scanner;
public class UseStudent {
public static void main(String[] args) throws Exception{
// TODO 自动生成的方法存根
try{
Student stud1 = new Student();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入分数1：");
stud1.setScore1(scanner.nextDouble());
System.out.println("请输入分数2：");
stud1.setScore1(scanner.nextDouble());
System.out.printf("学号:%s \n 姓名:%s \n 班级:%s\n 成绩1:%f \n成绩2:%f \n",
stud1.getId(),stud1.getName(),stud1.getClassName(),stud1.getScore1(),stud1.getScore2());
System.out.printf("成绩和为:%f\n最高成绩为:%f\n",stud1.sumOfScore(),stud1.maxOfScore());
Student stud2 = new Student("20230109001","林小同","2023大数据1班",95.5,96.5);
System.out.println("请输入分数1：");
stud2.setScore2(scanner.nextDouble());
System.out.println("请输入分数2：");
stud2.setScore2(scanner.nextDouble());
System.out.printf("\n学号:%s \n 姓名:%s \n 班级:%s\n 成绩1:%f \n成绩2:%f ",
stud2.getId(),stud2.getName(),stud2.getClassName(),stud2.getScore1(),stud2.getScore2());
System.out.printf("成绩和为:%f\n最高成绩为:%f\n",stud2.sumOfScore(),stud2.maxOfScore());
/*Student stud1 = new Student();
Student stud2 = new Student();
stud1.setId("t001");
stud1.setName("张三");
stud1.setClassName("2023大数据1班");
stud1.setScore1(20);
stud1.setScore2(90);
System.out.printf("学号:%s \n 姓名:%s \n 班级:%s\n 成绩1:%f \n成绩2:%f \n",
stud1.getId(),stud1.getName(),stud1.getClassName(),stud1.getScore1(),stud1.getScore2());
System.out.printf("成绩和为:%f\n最高成绩为:%f\n",stud1.sumOfScore(),stud1.maxOfScore());
stud2.setId("t002");
stud2.setName("李四");
stud2.setClassName("2023大数据1班");
stud2.setScore1(82.5);
stud2.setScore2(-91);
System.out.printf("\n学号:%s \n 姓名:%s \n 班级:%s\n 成绩1:%f \n成绩2:%f ",
stud2.getId(),stud2.getName(),stud2.getClassName(),stud2.getScore2(),stud2.getScore2());
System.out.printf("成绩和为:%f\n最高成绩为:%f\n",stud2.sumOfScore(),stud2.maxOfScore());*/
}catch(Exception e){
System.out.println(e.getMessage());
}
}
}
这段代码主要是创建了两个 Student 类的对象 stud1 和 stud2 ，并通过用户输入为 stud1 的分数进行赋值，为 stud2 的部分分数进行用户输入赋值。然后打印出这两个学生对象的相关信息，包括学号、姓名、班级、成绩 1、成绩 2 ，以及成绩的总和和最高成绩。
我们运行一下，结果：
可以看到正常运行
三、Java 中的类与对象
在 Java 编程中，类和对象是构建程序的核心概念。理解类的定义和对象的创建对于掌握 Java 编程至关重要。类的定义和对象的创建是 Java 编程的基础。通过合理地设计类，我们能够更好地组织和管理代码，提高程序的质量和开发效率。熟练掌握这两个概念，将为我们进一步深入学习 Java 面向对象编程打下坚实的基础。
1、类的定义
类是对具有相同属性和行为的一组对象的抽象描述。它定义了对象的属性（成员变量）和行为（方法）。
以下是一个简单的类定义示例：
public class Student {
// 成员变量
String name;
int age;
// 方法
public void introduce() {
System.out.println("我叫 " + name + "，今年 " + age + " 岁。");
}
}在上述示例中，我们定义了一个名为 Student 的类，它具有两个成员变量 name 和 age，以及一个方法 introduce 用于输出学生的信息。
2、对象的创建
对象是类的实例化。通过使用 new 关键字，可以创建类的对象。
public class Main {
public static void main(String[] args) {
// 创建 Student 类的对象
Student student1 = new Student();
java
// 为对象的成员变量赋值
student1.name = "张三";
student1.age = 20;
// 调用对象的方法
student1.introduce();
}
}在上述代码中，我们在 main 方法中创建了一个 Student 类的对象 student1，并为其成员变量赋值，最后调用了 introduce 方法。
运行结果：
3、类与对象的重要性
1.封装性
类将数据和操作数据的方法封装在一起，隐藏了内部的实现细节，只对外提供必要的接口，提高了代码的安全性和可维护性。
2.可复用性
定义好的类可以在多个地方创建对象并使用，减少了代码的重复编写。
3.面向对象编程的基础
类和对象是实现面向对象编程的关键，使得程序的结构更加清晰、逻辑更加严谨。
4、getter与setter方法
在 Java 编程中，getter 和 setter 方法是非常常见且重要的概念。它们为类的属性提供了受控的访问方式，增强了代码的封装性、可维护性和可读性。
什么是 Getter 和 Setter 方法
getter 方法用于获取类中私有属性的值，而 setter 方法用于设置类中私有属性的值。通过这种方式，我们可以控制对属性的访问和修改，确保数据的完整性和安全性。
public class Student {
private String name;
// Getter 方法
public String getName() {
return name;
}
// Setter 方法
public void setName(String name) {
this.name = name;
}
} 在上述示例中，getName() 是 getter 方法，setName(String name) 是 setter 方法。
getter方法
返回对象内部的成员变量的值格式：
[访问修饰符] 成员变量类型 getXxx(){
return 成员变量;
}
setter方法
用来设置成员变量，可以在方法里面过滤掉一些不合理的值格式：
[访问修饰符] void setXxx(成员变量类型 参数) {
成员变量=参数；
}
getter与setter中代码处理
1.使用setter可以对输入的数据进行检验
2.使用getter可以对读出的数据进行处理
5、构造方法
在 Java 编程中，构造方法是一种特殊的方法，用于创建和初始化对象。它在对象创建时被自动调用，为对象的属性赋予初始值，确保对象在使用前处于一个合理的初始状态。如果在类中没有显式地定义构造方法，Java 编译器会自动为类添加一个无参的默认构造方法。但是，一旦显式定义了构造方法，编译器就不再添加默认的无参构造方法。
1.构造方法是特殊的方法
2.方法名与类名同名
3.不能有返回值，没有void
4.创建类的实例（对象）时自动调用
5.用于类的实例（对象）初始化
格式：
[访问修饰符] class 类名{
public 类名([形参列表]) {
方法体；
}
其它类成员声明；
}
public class Person {
private String name;
private int age;
// 无参构造方法
public Person() {
this.name = "Unknown";
this.age = 0;
}
// 有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
} 在上述示例中，Person 类有两个构造方法，一个无参，一个有参。
构造方法的重载
在一个类中，可以定义多个构造方法，只要它们的参数列表不同，这就是构造方法的重载。
public class Car {
private String brand;
private String model;
private int year;
public Car() {}
public Car(String brand) {
this.brand = brand;
}
public Car(String brand, String model) {
this.brand = brand;
this.model = model;
}
public Car(String brand, String model, int year) {
this.brand = brand;
this.model = model;
this.year = year;
}
}通过构造方法的重载，可以根据不同的场景创建具有不同属性值的 Car 对象。
构造方法与普通方法的区别
1.名称：构造方法与类名相同，普通方法具有自定义的名称。
2.返回值：构造方法没有返回值，普通方法有明确的返回值类型。
3.调用方式：构造方法在创建对象时自动调用，普通方法需要通过对象来调用。
使用构造方法的最佳实践
1.确保构造方法的逻辑简单和清晰，只用于初始化对象的关键属性。
2.如果类中的属性较多且初始化逻辑复杂，可以考虑使用工厂方法或构建器模式来替代复杂的构造方法。
3.合理地使用构造方法的重载，提供多种创建对象的方式，以满足不同的使用场景。
总之，构造方法是 Java 面向对象编程中非常重要的概念，正确地理解和使用构造方法对于编写高质量、可维护的代码至关重要。
实训练习
2.(1)创建时间(Time)类，它包含的三个字段hour、minute、second，含一个timePeriod方法，用于计算零点时刻到当前时间的时间间隔(秒)。
对每个成员变量，增加getter与setter，在setter中进行数据检查如果数据不合理，应给抛出异常信息。
公有的无参构造方法，分别设置小时、分钟和秒数为0。
公有的有参构造方法，它包含三个整型参数，用它们来设置时间，公有的有参构造方法，它包含二个整型参数，用它们来设置小时和分钟，秒数被设置为0。
(2)创建两个对象，使用setter为对象设置值，并按6个数位hh:mm:ss (2个表示小时，2个表示分钟、2个表示秒)输出相关信息。，如:03:24:33或14:05:45。计算并显示对象与零点时刻的时间间隔。
使用无参构造方法创建时间类对象time1，显示对象的相关信息
使用三个参数的有参构造方法创建时间类对象time2,显示对象的
相关信息。
使用二个参数的有参构造方法创建时间类对象time3,显示对象的相关信息。
提示:可以采用格式输出System.out.printf(“%2d”.5)://输出占2位system.out.printf(“%02d”,5);//输出占2位，不足2位用0补
package zy;
/**
* 表示时间的类
*/
public class time {
private int hour; // 私有成员变量，用于存储小时
private int minute; // 私有成员变量，用于存储分钟
private int second; // 私有成员变量，用于存储秒
/**
* 公有无参构造方法，将时间设置为 00:00:00
*/
public time() {
this.hour = 0; // 将小时初始化为 0
this.minute = 0; // 将分钟初始化为 0
this.second = 0; // 将秒初始化为 0
}
/**
* 公有有参构造方法，设置完整的时间
*
* @param hour 小时值
* @param minute 分钟值
* @param second 秒值
* @throws Exception 如果输入的小时、分钟或秒值不合法，抛出异常
*/
public time(int hour, int minute, int second) throws Exception {
setHour(hour); // 调用设置小时的方法，并检查值的合法性
setMinute(minute); // 调用设置分钟的方法，并检查值的合法性
setSecond(second); // 调用设置秒的方法，并检查值的合法性
}
/**
* 公有有参构造方法，设置小时和分钟，秒数为 0
*
* @param hour 小时值
* @param minute 分钟值
* @throws Exception 如果输入的小时或分钟值不合法，抛出异常
*/
public time(int hour, int minute) throws Exception {
this.hour = hour; // 直接设置小时值
this.minute = minute; // 直接设置分钟值
this.second = 0; // 将秒初始化为 0
}
/**
* 获取小时的方法
*
* @return 小时值
*/
public int getHour() {
return hour; // 返回存储的小时值
}
/**
* 设置小时的方法
*
* @param hour 要设置的小时值
* @throws Exception 如果输入的小时值不在 0 到 23 之间，抛出异常
*/
public void setHour(int hour) throws Exception {
if (hour < 0 || hour > 23) { // 检查小时值的合法性
throw new Exception("小时值非法，必须在 0 到 23 之间！"); // 不合法时抛出异常
} else {
this.hour = hour; // 合法时设置小时值
}
}
/**
* 获取分钟的方法
*
* @return 分钟值
*/
public int getMinute() {
return minute; // 返回存储的分钟值
}
/**
* 设置分钟的方法
*
* @param minute 要设置的分钟值
* @throws Exception 如果输入的分钟值不在 0 到 59 之间，抛出异常
*/
public void setMinute(int minute) throws Exception {
if (minute < 0 || minute > 59) { // 检查分钟值的合法性
throw new Exception("分钟值非法，必须在 0 到 59 之间！"); // 不合法时抛出异常
} else {
this.minute = minute; // 合法时设置分钟值
}
}
/**
* 获取秒的方法
*
* @return 秒值
*/
public int getSecond() {
return second; // 返回存储的秒值
}
/**
* 设置秒的方法
*
* @param second 要设置的秒值
* @throws Exception 如果输入的秒值不在 0 到 59 之间，抛出异常
*/
public void setSecond(int second) throws Exception {
if (second < 0 || second > 59) { // 检查秒值的合法性
throw new Exception("秒值非法，必须在 0 到 59 之间！"); // 不合法时抛出异常
} else {
this.second = second; // 合法时设置秒值
}
}
/**
* 计算时间的总秒数
*
* @return 时间的总秒数
*/
public int timePeriod() {
return hour * 3600 + minute * 60 + second; // 根据小时、分钟和秒计算总秒数
}
/**
* 将时间以格式化字符串形式返回
*
* @return 格式化的时间字符串，格式为 "HH:MM:SS"
*/
public String toString() {
return String.format("%02d:%02d:%02d", hour, minute, second); // 使用格式化字符串输出时间
}
}以上代码的详细解释：
1.定义了一个名为 time 的类，用于表示时间。
2.类中有三个私有成员变量 hour（小时）、minute（分钟）、second（秒），用于存储时间的各个部分。
3.无参构造方法 time() ：将时间的小时、分钟和秒都初始化为 0 ，即设置为 00:00:00 。
4.有参构造方法 time(int hour, int minute, int second) ：在创建对象时可以传入小时、分钟和秒的值。但在设置之前，会分别调用对应的 set 方法进行值的合法性检查，如果值不合法会抛出异常。
5.有参构造方法 time(int hour, int minute) ：创建对象时传入小时和分钟的值，秒默认为 0 。
6.getHour() 、 getMinute() 、 getSecond() 方法：分别用于获取小时、分钟和秒的值。
7.setHour(int hour) 、 setMinute(int minute) 、 setSecond(int second) 方法：用于设置小时、分钟和秒的值。在设置之前会检查输入值是否合法，如果不合法会抛出异常。合法范围是：小时在 0 到 23 之间，分钟和秒在 0 到 59 之间。
8.timePeriod() 方法：计算时间的总秒数，通过小时乘以 3600 加上分钟乘以 60 再加上秒来得到。
9.toString() 方法：将时间以格式化的字符串形式返回，格式为 HH:MM:SS ，如果小时、分钟或秒的数值小于 10 ，会在前面补 0 。
然后：
package zy;
/**
* 主类，用于测试和使用自定义的时间类'time'
*/
public class Usetime {
/**
* 主方法，程序入口
*
* @param args 命令行参数
* @throws Exception 当创建时间对象时，如果输入的时间参数不合法会抛出异常
*/
public static void main(String[] args) throws Exception {
// TODO 自动生成的方法存根
try {
// 使用无参构造方法创建一个'time'对象'time1'，初始化为 00:00:00
time time1 = new time();
System.out.println("time1: " + time1); // 打印'time1'对象的字符串表示
// 使用三个参数的有参构造方法创建一个'time'对象'time2'，并指定小时、分钟和秒
time time2 = new time(12, 30, 45);
System.out.println("time2: " + time2); // 打印'time2'对象的字符串表示
// 使用两个参数的有参构造方法创建一个'time'对象'time3'，指定小时和分钟，秒默认为 0
time time3 = new time(5, 15);
System.out.println("time3: " + time3); // 打印'time3'对象的字符串表示
} catch (Exception e) {
System.out.println(e.getMessage()); // 如果创建时间对象时出现异常，打印异常信息
}
}
}这段代码主要是对之前定义的time类进行实例化创建对象，并打印出对象的字符串表示形式。通过不同的构造方法创建了具有不同时间值的对象。
运行结果：
四、学习心得
1.实践出真知
只有通过实际编写代码，才能真正掌握 Java 的语法和特性。在学习过程中，要多动手实践，尝试解决各种实际问题，不断积累经验。
2.善于查阅文档和资料
Java 拥有丰富的文档和在线资源，当遇到问题时，要善于利用这些资源查找解决方案。同时，参与技术社区的交流和讨论，也能够从他人的经验中获得启发。
3.注重代码规范
良好的代码规范能够提高代码的可读性和可维护性。在编写代码时，要遵循一定的命名规范、代码格式和注释要求，养成良好的编程习惯。
4.持续学习
Java 技术在不断发展和更新，要保持学习的热情，关注新的特性和技术趋势，不断提升自己的编程能力。
总之，学习 Java 是一个充满挑战和乐趣的过程。通过不断地学习和实践，我相信自己能够在编程领域取得更大的进步。
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
