文章目录
-
- 第一章 Java入门:搞懂这3个问题,避免走弯路
-
- 1.1 Java到底是什么?新手能快速上手吗
- 1.2 入门必备:Java开发环境搭建,全程无坑
- 1.3 Java核心特点:搞懂这些,才算真正入门
- 第二章 Java基础语法:从HelloWorld开始,夯实基础
-
- 2.1 第一个Java程序:HelloWorld,逐行解析
- 2.2 核心语法:变量与数据类型,避免类型错误
- 2.3 常用运算符:掌握这些,实现简单计算
- 第三章 流程控制:控制代码执行顺序,实现逻辑判断
-
- 3.1 分支结构:if-else语句,实现“二选一”判断
- 3.2 循环结构:for循环,实现重复执行代码
- 3.3 循环进阶:while循环,适合未知循环次数场景
- 第四章 面向对象核心:吃透类与对象,告别面向过程
-
- 4.1 类与对象:搞懂两者的关系,不再混淆
- 4.2 构造方法:初始化对象,简化赋值操作
- 4.3 封装:隐藏细节,让代码更安全、更易维护
- 第五章 实战综合:编写一个完整的Java程序,学以致用
-
- 5.1 实战目标:编写一个“学生成绩管理系统”(基础版)
- 5.2 完整代码:逐模块解析,可直接运行
-
- 1. Student类(封装学生信息,和第四章的Student类类似,略有修改)
- 2. StudentManager类(系统核心逻辑,实现所有功能)
- 5.3 代码运行说明:新手必看
第一章 Java入门:搞懂这3个问题,避免走弯路
1.1 Java到底是什么?新手能快速上手吗
很多新手入门编程,都会纠结“先学Java还是Python”,其实Java的核心优势的是跨平台、稳定性强,广泛用于后端开发、Android开发、大数据开发等领域,就业场景广,学会后实用性极强。
简单来说,Java就是一种“编写一次,到处运行”的编程语言——你用Java写的程序,既能在Windows电脑上运行,也能在Mac、Linux电脑上运行,不用单独修改代码,这也是它能成为企业级开发首选语言的核心原因。
新手完全不用怕Java难学,它的语法规范、逻辑清晰,比C++简单,比Python更注重代码结构,适合零基础入门打基础。很多人觉得Java难,是因为一开始就陷入了“复杂概念堆砌”,其实只要循序渐进,从基础语法到面向对象,一步步落地实操,2-3周就能掌握基础,写出简单的Java程序。
这里要纠正一个新手常见误区:Java和JavaScript没有关系,只是名字里都有“Java”。Java是一门独立的编程语言,用于开发独立程序;JavaScript主要用于网页交互,两者的语法、用途完全不同,别再混淆了。
1.2 入门必备:Java开发环境搭建,全程无坑
学习Java的第一步,就是搭建开发环境,这也是新手最容易踩坑的地方,很多人因为环境配置失败,直接放弃学习。其实只要跟着步骤来,10分钟就能搭建完成,全程无复杂操作。
首先,我们需要安装两个核心工具:JDK和IDE,两者缺一不可,作用不同,不用混淆。
第一个是JDK(Java Development Kit) ,它是Java程序的“开发工具包”,包含了Java编译器、运行环境,没有JDK,就无法编写和运行Java程序。推荐安装JDK 1.8版本(也叫Java 8),这是目前企业中使用最广泛、最稳定的版本,兼容性最好,新手首选。
安装步骤(全程避坑):
第二个是IDE(集成开发环境) ,推荐使用IntelliJ IDEA(简称IDEA),它是目前最流行、最便捷的Java开发工具,能自动补全代码、排查错误、管理项目,大大提升开发效率。新手可以安装社区版(免费),功能完全满足入门需求,无需破解。
IDE安装后,无需额外配置,打开后新建“Java Project”(Java项目),选择我们安装的JDK路径,就能开始编写Java代码了,全程傻瓜式操作,新手轻松上手。
1.3 Java核心特点:搞懂这些,才算真正入门
学习Java之前,先了解它的3个核心特点,能帮助我们更好地理解Java的设计思想,后续学习面向对象、语法规则时,会更轻松,避免死记硬背。
第一个特点:面向对象。这是Java的核心思想,简单来说,就是“万物皆对象”——我们把现实中的事物,抽象成程序中的“对象”,比如“人”可以是一个对象,“手机”可以是一个对象,每个对象都有自己的“属性”(比如人的姓名、年龄,手机的品牌、价格)和“行为”(比如人会吃饭、走路,手机会打电话、发消息)。这种思想能让代码更贴近现实,结构更清晰,便于维护和扩展。
第二个特点:跨平台。前面提到过,Java程序之所以能跨平台,核心是因为有“JVM(Java虚拟机)”——JVM就像一个“翻译官”,它会把Java代码翻译成不同操作系统能识别的语言,不管是Windows、Mac还是Linux,只要安装了对应的JVM,就能运行Java程序。这也是Java区别于其他编程语言的核心优势之一。
第三个特点:安全性高。Java取消了C++中的指针操作,避免了指针越界导致的程序崩溃、数据泄露等问题;同时,Java有严格的异常处理机制,能及时捕获程序运行中的错误,避免程序异常终止;此外,Java还支持沙箱机制,限制程序的权限,防止恶意程序破坏系统,这也是它被广泛用于企业级开发的重要原因。
第二章 Java基础语法:从HelloWorld开始,夯实基础
2.1 第一个Java程序:HelloWorld,逐行解析
学习任何编程语言,都是从“HelloWorld”开始,Java也不例外。这个程序虽然简单,但能帮我们熟悉Java的代码结构、运行流程,掌握最基础的语法规则,新手一定要亲手写一遍,不要直接复制粘贴。
首先,打开IDEA,新建Java项目,新建一个“类”(Class),类名建议首字母大写(Java语法规范),比如“HelloWorld”,然后编写以下代码,每一行都有详细注释,看懂再运行:
// 这是单行注释,注释不会被程序执行,用于说明代码含义(快捷键:Ctrl+/)
/*
这是多行注释,
可以换行,
同样不会被程序执行(快捷键:Ctrl+Shift+/)
*/
public class HelloWorld { // 定义一个类,类名是HelloWorld,必须和文件名一致(关键!)
// main方法:Java程序的入口,所有程序都从这里开始执行,固定写法
public static void main(String[] args) {
// 输出语句:在控制台打印括号中的内容,分号是语句结束的标志(关键!不能漏)
System.out.println("HelloWorld!我是Java新手,正在入门!");
}
}
代码编写完成后,点击IDE右上角的“运行”按钮,就能在控制台看到输出结果:“HelloWorld!我是Java新手,正在入门!”,这就说明你的第一个Java程序运行成功了。
这里有3个新手必踩的坑,一定要注意:
2.2 核心语法:变量与数据类型,避免类型错误
变量是Java中最基础的概念,简单来说,变量就是“用来存储数据的容器”,比如我们想存储一个人的年龄、一个数字,就需要用变量来实现。而数据类型,就是变量存储的数据的“类型”,不同的数据类型,存储的数据范围、占用的空间不同,不能混用,否则会报错。
Java中的数据类型,分为两大类:基本数据类型和引用数据类型,新手先掌握基本数据类型即可,引用数据类型后续学习面向对象时再深入。
基本数据类型有8种,分为4类,每一种都有明确的存储范围和默认值,整理如下(新手建议收藏,避免忘记):
- byte:存储范围-128~127,占用1个字节,默认值0;
- short:存储范围-32768~32767,占用2个字节,默认值0;
- int:存储范围-2147483648~2147483647,占用4个字节,默认值0(最常用,新手首选);
- long:存储范围极大,占用8个字节,默认值0L(注意末尾要加L,区分int类型);
- float:单精度浮点型,占用4个字节,默认值0.0f(末尾要加f,区分double类型);
- double:双精度浮点型,占用8个字节,默认值0.0(最常用,精度比float高);
- char:占用2个字节,默认值’\\u0000’(空字符),注意字符必须用单引号包裹;
- boolean:只有两个值:true(真)、false(假),占用1个字节,默认值false。
变量的定义语法很简单,固定格式:数据类型 变量名 = 赋值; ,举几个例子,新手可以直接参考:
public class VariableDemo {
public static void main(String[] args) {
// 定义整数类型变量
int age = 20; // 存储年龄,int类型,赋值20
long phone = 13800138000L; // 存储手机号,数字太大,用long类型,末尾加L
// 定义浮点类型变量
double score = 95.5; // 存储成绩,double类型,最常用
float weight = 65.0f; // 存储体重,float类型,末尾加f
// 定义字符类型变量
char gender = '男'; // 存储性别,单引号包裹单个字符
// 定义布尔类型变量
boolean isStudent = true; // 存储是否是学生,true表示是
// 输出变量的值,查看结果
System.out.println("年龄:" + age);
System.out.println("手机号:" + phone);
System.out.println("成绩:" + score);
System.out.println("性别:" + gender);
System.out.println("是否是学生:" + isStudent);
}
}
这里有一个新手必避的坑:变量赋值时,不能超出数据类型的存储范围。比如int类型的存储范围是-2147483648~2147483647,如果给int变量赋值2147483648,就会报错;另外,不同数据类型之间的转换,要注意兼容性,比如int类型不能直接转换为char类型,需要手动强制转换。
2.3 常用运算符:掌握这些,实现简单计算
运算符是Java中用于实现“计算”或“判断”的符号,就像我们数学中的“+、-、×、÷”一样,新手只需掌握最常用的6种运算符,就能实现简单的计算和逻辑判断,无需死记硬背,多练习就能熟练掌握。
算术运算符:用于实现基本的数学计算,最常用的有5种
- +:加法(比如3+5=8)、字符串拼接(比如"Hello"+“World”=“HelloWorld”);
- -:减法(比如10-4=6);
- :乘法(比如23=6);
- /:除法(注意:整数除以整数,结果还是整数,比如5/2=2,不是2.5;如果想得到小数,需要将其中一个数改为浮点类型,比如5.0/2=2.5);
- %:取余(求余数,比如7%3=1,因为7除以3商2余1);
赋值运算符:用于给变量赋值,最常用的是=,还有复合赋值运算符(简化代码)
- =:基本赋值(比如int a = 10;);
- +=:加后赋值(比如a += 5; 等价于a = a + 5;);
- -=:减后赋值(比如a -= 3; 等价于a = a – 3;);
比较运算符:用于比较两个值的大小,结果是布尔类型(true/false),常用于判断
- ==:等于(比如3 == 5,结果是false);
- !=:不等于(比如3 != 5,结果是true);
-
:大于(比如5 > 3,结果是true);
- <:小于(比如5 < 3,结果是false);
-
=:大于等于,<=:小于等于;
逻辑运算符:用于连接多个判断条件,结果是布尔类型,最常用的3种
- &&:逻辑与(两个条件都为true,结果才为true;只要有一个为false,结果就是false);
- ||:逻辑或(两个条件只要有一个为true,结果就为true;两个都为false,结果才为false);
- !:逻辑非(取反,比如!true就是false,!false就是true);
举个实战例子,用运算符实现简单的成绩判断,代码如下:
public class OperatorDemo {
public static void main(String[] args) {
// 定义成绩变量
double score = 88.5;
// 算术运算符:计算总分(假设语文88.5,数学92,英语85)
double total = score + 92 + 85;
System.out.println("三科总分:" + total);
double average = total / 3;
System.out.println("三科平均分:" + average);
// 比较运算符+逻辑运算符:判断成绩是否合格(60分及以上合格,且平均分不低于70)
boolean isPass = score >= 60 && average >= 70;
System.out.println("成绩是否合格:" + isPass);
// 复合赋值运算符:给平均分加2分
average += 2;
System.out.println("加分后的平均分:" + average);
}
}
运行代码后,就能看到对应的计算结果和判断结果,新手可以修改成绩的值,观察结果的变化,加深对运算符的理解。这里要注意:逻辑运算符中,&&和||有“短路特性”——&&只要第一个条件为false,就不会判断第二个条件;||只要第一个条件为true,就不会判断第二个条件,这能提高程序的运行效率。
第三章 流程控制:控制代码执行顺序,实现逻辑判断
3.1 分支结构:if-else语句,实现“二选一”判断
在Java程序中,代码默认是“从上到下”顺序执行的,但很多时候,我们需要根据不同的条件,执行不同的代码,这就需要用到分支结构,最常用的就是if-else语句,实现“二选一”或“多选一”的判断。
if-else语句的核心逻辑:先判断一个条件,如果条件成立(true),就执行if后面的代码;如果条件不成立(false),就执行else后面的代码,语法固定,新手可以直接套用。
基础语法格式:
if (判断条件) {
// 条件成立时,执行的代码
} else {
// 条件不成立时,执行的代码
}
举个实战例子:判断一个学生的成绩是否合格(60分及以上合格),并输出对应的提示,代码如下:
public class IfElseDemo {
public static void main(String[] args) {
// 定义成绩变量
int score = 75;
// 判断成绩是否合格
if (score >= 60) {
// 条件成立(成绩≥60),执行这里的代码
System.out.println("成绩合格!");
System.out.println("继续加油,争取更好的成绩!");
} else {
// 条件不成立(成绩<60),执行这里的代码
System.out.println("成绩不合格!");
System.out.println("需要重新复习,下次争取通过!");
}
}
}
如果我们需要实现“多选一”的判断(比如成绩分级:90分及以上优秀、80-89良好、70-79中等、60-69及格、60以下不及格),就可以使用if-else if-else语句,语法格式如下:
if (条件1) {
// 条件1成立,执行这里
} else if (条件2) {
// 条件1不成立,条件2成立,执行这里
} else if (条件3) {
// 条件1、2不成立,条件3成立,执行这里
} else {
// 所有条件都不成立,执行这里
}
对应的实战代码(成绩分级):
public class IfElseIfDemo {
public static void main(String[] args) {
int score = 88;
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 80) {
System.out.println("良好");
} else if (score >= 70) {
System.out.println("中等");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
}
这里有一个新手必踩的坑:判断条件的顺序不能乱。比如上面的代码,不能把“score >= 60”放在最前面,否则不管成绩是多少,只要≥60,都会输出“及格”,后面的判断就不会执行了。判断条件要从“范围大的”到“范围小的”,或者从“高到低”排列,避免逻辑错误。
3.2 循环结构:for循环,实现重复执行代码
很多时候,我们需要让一段代码“重复执行”多次,比如打印1-100的数字、计算1-100的和,如果手动写100次代码,会非常繁琐,这时候就需要用到循环结构,最常用的就是for循环,适合“已知循环次数”的场景,新手容易掌握。
for循环的语法格式(固定写法):
for (初始化变量; 判断条件; 更新变量) {
// 循环体:需要重复执行的代码
}
逐部分解析:
举个实战例子1:打印1-100的数字,每5个数字换行,代码如下:
public class ForDemo1 {
public static void main(String[] args) {
// 循环1-100,i从1开始,到100结束,每次加1
for (int i = 1; i <= 100; i++) {
// 打印i的值,不换行(print不换行,println换行)
System.out.print(i + " ");
// 每5个数字换行(判断i是否是5的倍数)
if (i % 5 == 0) {
System.out.println(); // 换行
}
}
}
}
举个实战例子2:计算1-100的和,代码如下:
public class ForDemo2 {
public static void main(String[] args) {
// 定义变量sum,用于存储总和,初始值为0
int sum = 0;
// 循环1-100,将每个数字加到sum中
for (int i = 1; i <= 100; i++) {
sum += i; // 等价于sum = sum + i;
}
// 循环结束后,打印总和
System.out.println("1-100的和是:" + sum);
}
}
运行代码后,就能得到1-100的和是5050,新手可以修改循环范围(比如1-50、1-1000),观察结果的变化。这里要注意:循环变量的初始化,要放在for循环的括号里,不要放在循环体外,否则会导致变量作用域错误;另外,不要忘记更新变量(比如i++),否则会导致“死循环”(循环永远不会结束,程序卡住)。
3.3 循环进阶:while循环,适合未知循环次数场景
除了for循环,Java中还有while循环,它和for循环的作用一样,都是实现代码重复执行,但适用场景不同——for循环适合“已知循环次数”的场景,while循环适合“未知循环次数”的场景(比如直到满足某个条件,才停止循环)。
while循环的语法格式:
// 初始化变量(在循环外面定义)
int i = 1;
while (判断条件) {
// 循环体:需要重复执行的代码
// 更新变量(必须有,否则会死循环)
i++;
}
举个实战例子:猜数字游戏,系统随机生成一个1-100的数字,用户输入猜测的数字,直到猜对为止,代码如下(结合 Scanner 输入工具,新手可直接复制运行):
import java.util.Scanner; // 导入Scanner工具,用于获取用户输入
public class WhileDemo {
public static void main(String[] args) {
// 1. 系统随机生成一个1-100的数字(Math.random()生成0-1的随机数,乘以100再加1,得到1-100)
int randomNum = (int) (Math.random() * 100 + 1);
// 2. 初始化变量,用于存储用户输入的猜测数字
int guessNum;
// 3. 初始化Scanner工具,获取用户输入
Scanner scanner = new Scanner(System.in);
// 4. while循环:只要用户没猜对,就一直循环
while (true) { // 条件为true,无限循环,直到猜对后用break跳出
System.out.print("请输入你猜测的数字(1-100):");
guessNum = scanner.nextInt(); // 获取用户输入的数字
// 判断猜测结果
if (guessNum > randomNum) {
System.out.println("猜大了!再试试更小的数字~");
} else if (guessNum < randomNum) {
System.out.println("猜小了!再试试更大的数字~");
} else {
System.out.println("恭喜你,猜对了!");
break; // 猜对了,跳出循环,结束程序
}
}
scanner.close(); // 关闭Scanner工具,避免资源浪费
}
}
这个例子结合了while循环、if-else判断、用户输入,非常实用,新手可以运行代码,亲自玩一玩,加深对while循环的理解。这里要注意:while循环一定要有“跳出循环”的条件(比如break语句),或者在判断条件中设置终止条件,否则会导致死循环;另外,使用Scanner工具后,要记得关闭,避免资源浪费。
第四章 面向对象核心:吃透类与对象,告别面向过程
4.1 类与对象:搞懂两者的关系,不再混淆
面向对象是Java的核心,而类和对象是面向对象的基础,很多新手都会混淆“类”和“对象”,其实用一个简单的类比,就能轻松理解:
- 类:相当于一个“模板”,比如“汽车”类,它定义了汽车的共同属性(品牌、颜色、价格)和共同行为(行驶、刹车、鸣笛),但它不是一辆具体的汽车,只是一个抽象的模板;
- 对象:相当于根据“模板”创建出来的“具体事物”,比如根据“汽车”类,创建出“特斯拉Model 3”“比亚迪汉”这两个具体的对象,每个对象都有自己的属性值(特斯拉的品牌是特斯拉,颜色是白色;比亚迪的品牌是比亚迪,颜色是黑色),也能执行类中定义的行为。
简单来说:类是对象的模板,对象是类的实例,一个类可以创建多个对象,每个对象都具有类中定义的属性和行为,但属性值可以不同。
类的定义语法(固定写法):
public class 类名 {
// 1. 定义属性(成员变量):类的特征,比如人的姓名、年龄
数据类型 属性名;
// 2. 定义方法(成员方法):类的行为,比如人的吃饭、走路
public 返回值类型 方法名(参数列表) {
// 方法体:行为的具体实现
return 返回值; // 如果返回值类型是void,不需要return
}
}
举个实战例子:定义一个“Person(人)”类,包含属性(姓名、年龄、性别)和方法(吃饭、睡觉),然后根据这个类创建对象,代码如下:
// 定义Person类(模板)
public class Person {
// 定义属性(成员变量)
String name; // 姓名
int age; // 年龄
char gender; // 性别
// 定义方法:吃饭
public void eat() {
// 方法体:具体实现,这里可以使用类中的属性
System.out.println(name + "正在吃饭,今年" + age + "岁");
}
// 定义方法:睡觉
public void sleep() {
System.out.println(name + "正在睡觉,性别是" + gender);
}
}
// 测试类:创建对象,调用方法
public class PersonTest {
public static void main(String[] args) {
// 1. 根据Person类,创建第一个对象(小明)
Person xiaoming = new Person();
// 给对象的属性赋值
xiaoming.name = "小明";
xiaoming.age = 18;
xiaoming.gender = '男';
// 调用对象的方法
xiaoming.eat();
xiaoming.sleep();
// 2. 创建第二个对象(小红)
Person xiaohong = new Person();
xiaohong.name = "小红";
xiaohong.age = 17;
xiaohong.gender = '女';
xiaohong.eat();
xiaohong.sleep();
}
}
运行代码后,就能看到两个对象的方法调用结果,每个对象的属性值不同,方法执行的结果也不同。这里要注意:类名首字母必须大写,属性和方法的访问修饰符(public)新手暂时记住public即可,后续会深入讲解;创建对象时,必须使用new关键字,比如new Person(),否则会报错。
4.2 构造方法:初始化对象,简化赋值操作
在上面的例子中,我们创建对象后,需要手动给每个属性赋值(比如xiaoming.name = “小明”),如果属性很多,手动赋值会非常繁琐。这时候,我们就可以使用“构造方法”,在创建对象的同时,给属性赋值,简化操作。
构造方法的核心特点:
构造方法的语法格式:
public 类名(参数列表) {
// 构造方法体:给属性赋值
this.属性名 = 参数值;
}
举个实战例子:给Person类添加构造方法,创建对象时直接赋值,代码如下:
public class Person {
// 属性
String name;
int age;
char gender;
// 1. 无参构造方法(默认存在,如果手动写了有参构造,默认的无参构造会消失,建议手动加上)
public Person() {
// 无参构造,可用于创建对象后,手动赋值
}
// 2. 有参构造方法(参数列表:姓名、年龄、性别)
public Person(String name, int age, char gender) {
// this关键字:代表当前对象,用于区分成员变量和参数(避免重名)
this.name = name;
this.age = age;
this.gender = gender;
}
// 3. 重载构造方法(参数列表:姓名、年龄,性别默认值为'男')
public Person(String name, int age) {
this.name = name;
this.age = age;
this.gender = '男'; // 性别默认值
}
// 方法
public void eat() {
System.out.println(name + "正在吃饭,今年" + age + "岁");
}
public void sleep() {
System.out.println(name + "正在睡觉,性别是" + gender);
}
}
// 测试类
public class PersonTest {
public static void main(String[] args) {
// 1. 调用无参构造,创建对象后手动赋值
Person xiaoming = new Person();
xiaoming.name = "小明";
xiaoming.age = 18;
xiaoming.gender = '男';
xiaoming.eat();
// 2. 调用有参构造(3个参数),创建对象时直接赋值
Person xiaohong = new Person("小红", 17, '女');
xiaohong.sleep();
// 3. 调用重载构造(2个参数),性别使用默认值
Person xiaoli = new Person("小李", 19);
xiaoli.eat();
}
}
这里有一个新手必避的坑:如果手动写了有参构造方法,默认的无参构造方法会自动消失,如果后续需要用无参构造创建对象,就会报错,所以建议不管是否写有参构造,都手动加上无参构造,避免出错;另外,this关键字的作用是“区分成员变量和参数”,如果参数名和成员变量名不重名,也可以不用this,但建议养成使用this的习惯,提高代码可读性。
4.3 封装:隐藏细节,让代码更安全、更易维护
封装是面向对象的三大特性之一(封装、继承、多态),新手先掌握封装即可,后续再深入继承和多态。封装的核心思想是:隐藏对象的属性和实现细节,只对外提供公共的访问方式,这样可以避免外部直接修改对象的属性,保证数据的安全性,同时也能简化代码,便于维护。
比如我们定义一个“Student(学生)”类,学生的“成绩”是一个敏感属性,不能让外部直接修改(比如不能直接把成绩改成100),这时候就可以用封装,将成绩属性私有化,然后提供公共的“设置成绩”和“获取成绩”的方法,在方法中添加判断逻辑,保证成绩的合法性。
封装的实现步骤(固定写法):
举个实战例子:封装Student类,控制成绩的访问和修改,代码如下:
public class Student {
// 1. 属性私有化(private修饰)
private String name; // 姓名
private int score; // 成绩(敏感属性,私有化)
// 2. 无参构造
public Student() {
}
// 3. 有参构造
public Student(String name, int score) {
this.name = name;
// 调用setter方法,设置成绩(利用setter中的判断逻辑)
this.setScore(score);
}
// 4. getter方法:获取姓名
public String getName() {
return name;
}
// 5. setter方法:设置姓名
public void setName(String name) {
this.name = name;
}
// 6. getter方法:获取成绩
public int getScore() {
return score;
}
// 7. setter方法:设置成绩,添加判断逻辑
public void setScore(int score) {
// 判断成绩是否合法(0-100之间)
if (score >= 0 && score <= 100) {
this.score = score;
} else {
// 成绩不合法,给出提示,设置默认值0
System.out.println("成绩不合法(必须在0-100之间),默认设置为0");
this.score = 0;
}
}
// 方法:打印学生信息
public void showInfo() {
System.out.println("学生姓名:" + name + ",成绩:" + score);
}
}
// 测试类
public class StudentTest {
public static void main(String[] args) {
// 1. 创建学生对象,调用有参构造
Student student1 = new Student("小张", 95);
student1.showInfo(); // 输出:学生姓名:小张,成绩:95
// 2. 尝试设置非法成绩(105)
student1.setScore(105);
student1.showInfo(); // 输出:成绩不合法,默认设置为0;学生姓名:小张,成绩:0
// 3. 设置合法成绩(88)
student1.setScore(88);
student1.showInfo(); // 输出:学生姓名:小张,成绩:88
// 4. 尝试直接访问私有属性(报错!私有属性外部无法直接访问)
// student1.score = 100; // 报错,无法编译通过
}
}
运行代码后,就能看到封装的效果:外部无法直接访问私有属性score,只能通过setScore()方法设置成绩,并且设置非法成绩时,会给出提示并设置默认值,保证了数据的安全性。这里要注意:private修饰的属性,只能在当前类中访问,外部访问会报错;getter和setter方法的命名规范:get+属性名(首字母大写)、set+属性名(首字母大写),比如getScore()、setScore()。
第五章 实战综合:编写一个完整的Java程序,学以致用
5.1 实战目标:编写一个“学生成绩管理系统”(基础版)
本次实战,我们结合前面所学的知识点(类与对象、封装、流程控制、运算符),编写一个基础版的学生成绩管理系统,实现以下功能:
这个实战涵盖了Java基础的核心知识点,新手可以跟着代码逐行理解,亲手运行,感受Java编程的实用性,同时巩固所学内容,避免纸上谈兵。
5.2 完整代码:逐模块解析,可直接运行
整个程序分为两个类:Student类(封装学生信息)和StudentManager类(系统核心逻辑,实现各种功能),代码如下,每一部分都有详细注释,新手可以慢慢看,看懂后自己修改、拓展功能。
1. Student类(封装学生信息,和第四章的Student类类似,略有修改)
// 学生类:封装学生的姓名和成绩
public class Student {
// 私有属性
private String name;
private int score;
// 无参构造
public Student() {
}
// 有参构造
public Student(String name, int score) {
this.name = name;
this.setScore(score); // 调用setter方法,保证成绩合法
}
// getter和setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
if (score >= 0 && score <= 100) {
this.score = score;
} else {
System.out.println("成绩不合法,默认设置为0");
this.score = 0;
}
}
}
2. StudentManager类(系统核心逻辑,实现所有功能)
import java.util.ArrayList;
import java.util.Scanner;
// 学生成绩管理系统:核心逻辑类
public class StudentManager {
public static void main(String[] args) {
// 1. 创建集合,用于存储所有学生对象(ArrayList:动态数组,可自动扩容,适合存储多个对象)
ArrayList<Student> studentList = new ArrayList<>();
// 2. 初始化Scanner工具,获取用户输入
Scanner scanner = new Scanner(System.in);
// 3. 循环菜单,让用户选择功能,直到选择退出系统
while (true) {
// 打印系统菜单
System.out.println("====================学生成绩管理系统====================");
System.out.println("1. 录入学生信息");
System.out.println("2. 查看所有学生信息");
System.out.println("3. 查看成绩统计(平均分、最高分、最低分)");
System.out.println("4. 查找指定学生");
System.out.println("5. 退出系统");
System.out.println("======================================================");
System.out.print("请输入你的选择(1-5):");
// 获取用户输入的选择(判断是否是整数,避免报错)
int choice;
if (scanner.hasNextInt()) {
choice = scanner.nextInt();
scanner.nextLine(); // 吸收换行符,避免后续获取字符串时出错
} else {
System.out.println("输入不合法,请输入1-5之间的整数!");
scanner.nextLine(); // 清空输入缓冲区
continue;
}
// 根据用户选择,执行对应的功能(switch-case语句,多选一)
switch (choice) {
case 1:
// 功能1:录入学生信息
addStudent(studentList, scanner);
break;
case 2:
// 功能2:查看所有学生信息
showAllStudent(studentList);
break;
case 3:
// 功能3:查看成绩统计
showScoreStatistics(studentList);
break;
case 4:
// 功能4:查找指定学生
findStudent(studentList, scanner);
break;
case 5:
// 功能5:退出系统
System.out.println("感谢使用,退出系统!");
scanner.close(); // 关闭Scanner
System.exit(0); // 终止程序
break;
default:
System.out.println("输入不合法,请输入1-5之间的整数!");
}
}
}
// 方法1:录入学生信息(参数:学生集合、Scanner工具)
public static void addStudent(ArrayList<Student> studentList, Scanner scanner) {
System.out.println("====================录入学生信息====================");
// 获取学生姓名
System.out.print("请输入学生姓名:");
String name = scanner.nextLine();
// 获取学生成绩,判断是否是整数
int score;
while (true) {
System.out.print("请输入学生成绩(0-100):");
if (scanner.hasNextInt()) {
score = scanner.nextInt();
scanner.nextLine(); // 吸收换行符
break;
} else {
System.out.println("成绩不合法,请输入整数!");
scanner.nextLine(); // 清空缓冲区
}
}
// 创建学生对象,添加到集合中
Student student = new Student(name, score);
studentList.add(student);
System.out.println("录入成功!");
}
// 方法2:查看所有学生信息
public static void showAllStudent(ArrayList<Student> studentList) {
System.out.println("====================所有学生信息====================");
// 判断集合是否为空(没有学生信息)
if (studentList.isEmpty()) {
System.out.println("暂无学生信息,请先录入!");
return;
}
// 循环遍历集合,打印每个学生的信息
System.out.println("姓名\\t\\t成绩");
System.out.println("————————");
for (Student student : studentList) {
System.out.println(student.getName() + "\\t\\t" + student.getScore());
}
}
// 方法3:查看成绩统计(平均分、最高分、最低分)
public static void showScoreStatistics(ArrayList<Student> studentList) {
System.out.println("====================成绩统计====================");
if (studentList.isEmpty()) {
System.out.println("暂无学生信息,无法统计!");
return;
}
// 定义变量,存储总分、最高分、最低分
int total = 0;
int maxScore = studentList.get(0).getScore();
int minScore = studentList.get(0).getScore();
// 循环遍历集合,计算总分、最高分、最低分
for (Student student : studentList) {
int score = student.getScore();
total += score; // 累加总分
// 更新最高分
if (score > maxScore) {
maxScore = score;
}
// 更新最低分
if (score < minScore) {
minScore = score;
}
}
// 计算平均分(注意:强制转换为double,避免整数除法)
double average = (double) total / studentList.size();
// 打印统计结果(保留1位小数)
System.out.println("学生总数:" + studentList.size());
System.out.println("总分:" + total);
System.out.printf("平均分:%.1f\\n", average); // printf格式化输出
System.out.println("最高分:" + maxScore);
System.out.println("最低分:" + minScore);
}
// 方法4:查找指定学生
public static void findStudent(ArrayList<Student> studentList, Scanner scanner) {
System.out.println("====================查找学生====================");
if (studentList.isEmpty()) {
System.out.println("暂无学生信息,无法查找!");
return;
}
// 获取用户要查找的姓名
System.out.print("请输入要查找的学生姓名:");
String name = scanner.nextLine();
// 循环遍历集合,查找姓名匹配的学生
boolean isFound = false; // 标记是否找到
for (Student student : studentList) {
if (student.getName().equals(name)) {
// 找到学生,打印信息
System.out.println("找到该学生!");
System.out.println("姓名:" + student.getName() + ",成绩:" + student.getScore());
isFound = true;
break; // 找到后,跳出循环,避免重复查找
}
}
// 如果没找到
if (!isFound) {
System.out.println("未找到姓名为'" + name + "'的学生!");
}
}
}
5.3 代码运行说明:新手必看
- 输入1:录入学生信息,依次输入姓名和成绩(成绩必须是0-100的整数,否则会提示不合法,默认设置为0);
- 输入2:查看所有已录入的学生信息,格式清晰,便于查看;
- 输入3:查看成绩统计,自动计算学生总数、总分、平均分(保留1位小数)、最高分、最低分;
- 输入4:查找指定学生,输入姓名后,会自动匹配,找到则显示信息,找不到则提示;
- 输入5:退出系统,程序终止。
这个程序虽然是基础版,但涵盖了Java基础的核心知识点,新手可以在此基础上拓展功能,比如添加“修改学生成绩”“删除学生信息”“按成绩排序”等功能,进一步巩固所学内容,提升编程能力。
你在学习Java基础的过程中,有没有遇到过语法报错、逻辑混乱的问题?或者对面向对象、封装的理解还有疑问?又或者想拓展这个学生成绩管理系统的功能?欢迎留言交流,一起夯实Java基础,避开学习路上的坑。





