欢迎光临
我们一直在努力

【超详细】Java基础入门:零基础吃透面向对象,附实战案例+避坑代码

文章目录

    • 第一章 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),这是目前企业中使用最广泛、最稳定的版本,兼容性最好,新手首选。

安装步骤(全程避坑):

  • 下载JDK 1.8安装包(官网或国内镜像源均可,镜像源下载更快);
  • 双击安装,安装路径建议默认,或自定义到无中文、无空格的路径(比如D:\\Java\\jdk1.8,这是关键!中文路径会导致后续运行报错);
  • 配置环境变量(重点!):右键“此电脑”→“属性”→“高级系统设置”→“环境变量”,新建“JAVA_HOME”变量,值为JDK的安装路径;然后在“Path”变量中,添加“%JAVA_HOME%\\bin”和“%JAVA_HOME%\\jre\\bin”;
  • 验证是否安装成功:打开cmd,输入“java -version”和“javac -version”,如果能显示JDK版本号,就说明安装配置成功。
  • 第二个是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个新手必踩的坑,一定要注意:

  • 类名必须和文件名一致,比如类名是HelloWorld,文件名就必须是HelloWorld.java,否则会报错;
  • main方法的语法不能错,少写一个关键字(比如static、void),程序都无法运行,建议新手先记住固定写法;
  • 每一条Java语句结束后,必须加“分号”,这是Java的语法规范,漏加分号会导致编译报错,很多新手都会忽略这一点。
  • 2.2 核心语法:变量与数据类型,避免类型错误

    变量是Java中最基础的概念,简单来说,变量就是“用来存储数据的容器”,比如我们想存储一个人的年龄、一个数字,就需要用变量来实现。而数据类型,就是变量存储的数据的“类型”,不同的数据类型,存储的数据范围、占用的空间不同,不能混用,否则会报错。

    Java中的数据类型,分为两大类:基本数据类型和引用数据类型,新手先掌握基本数据类型即可,引用数据类型后续学习面向对象时再深入。

    基本数据类型有8种,分为4类,每一种都有明确的存储范围和默认值,整理如下(新手建议收藏,避免忘记):

  • 整数类型:用于存储整数(正整数、负整数、0)
    • byte:存储范围-128~127,占用1个字节,默认值0;
    • short:存储范围-32768~32767,占用2个字节,默认值0;
    • int:存储范围-2147483648~2147483647,占用4个字节,默认值0(最常用,新手首选);
    • long:存储范围极大,占用8个字节,默认值0L(注意末尾要加L,区分int类型);
  • 浮点类型:用于存储小数(比如3.14、10.5)
    • float:单精度浮点型,占用4个字节,默认值0.0f(末尾要加f,区分double类型);
    • double:双精度浮点型,占用8个字节,默认值0.0(最常用,精度比float高);
  • 字符类型:用于存储单个字符(比如’a’、‘中’)
    • 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 (初始化变量; 判断条件; 更新变量) {
    // 循环体:需要重复执行的代码
    }

    逐部分解析:

  • 初始化变量:定义一个循环变量,用于控制循环次数(比如int i = 1;);
  • 判断条件:判断循环是否继续执行(比如i <= 100; 表示只要i小于等于100,就继续循环);
  • 更新变量:每次循环结束后,更新循环变量的值(比如i++; 表示每次循环,i都加1);
  • 循环体:需要重复执行的代码,循环多少次,这段代码就执行多少次。
  • 举个实战例子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 = “小明”),如果属性很多,手动赋值会非常繁琐。这时候,我们就可以使用“构造方法”,在创建对象的同时,给属性赋值,简化操作。

    构造方法的核心特点:

  • 构造方法的名称,必须和类名完全一致,首字母大写,没有返回值类型(甚至不能写void);
  • 构造方法不需要手动调用,创建对象时(new 类名()),会自动调用构造方法;
  • 一个类可以有多个构造方法(重载),根据参数列表的不同,调用不同的构造方法。
  • 构造方法的语法格式:

    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),这时候就可以用封装,将成绩属性私有化,然后提供公共的“设置成绩”和“获取成绩”的方法,在方法中添加判断逻辑,保证成绩的合法性。

    封装的实现步骤(固定写法):

  • 将类的属性私有化(用private修饰),私有化的属性,只能在当前类中访问,外部无法直接访问;
  • 提供公共的getter方法(获取属性值)和setter方法(设置属性值),外部只能通过这两个方法,访问和修改属性;
  • 在setter方法中,添加判断逻辑,保证属性值的合法性(比如成绩必须在0-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 代码运行说明:新手必看

  • 运行StudentManager类(因为main方法在这个类中),控制台会显示系统菜单;
  • 按照菜单提示,输入对应的数字,执行相关功能:
    • 输入1:录入学生信息,依次输入姓名和成绩(成绩必须是0-100的整数,否则会提示不合法,默认设置为0);
    • 输入2:查看所有已录入的学生信息,格式清晰,便于查看;
    • 输入3:查看成绩统计,自动计算学生总数、总分、平均分(保留1位小数)、最高分、最低分;
    • 输入4:查找指定学生,输入姓名后,会自动匹配,找到则显示信息,找不到则提示;
    • 输入5:退出系统,程序终止。
  • 这个程序虽然是基础版,但涵盖了Java基础的核心知识点,新手可以在此基础上拓展功能,比如添加“修改学生成绩”“删除学生信息”“按成绩排序”等功能,进一步巩固所学内容,提升编程能力。


    你在学习Java基础的过程中,有没有遇到过语法报错、逻辑混乱的问题?或者对面向对象、封装的理解还有疑问?又或者想拓展这个学生成绩管理系统的功能?欢迎留言交流,一起夯实Java基础,避开学习路上的坑。

    赞(0)
    未经允许不得转载:171主机测评 » 【超详细】Java基础入门:零基础吃透面向对象,附实战案例+避坑代码
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址