企业官网建设流程全解析

简介：本资源是《Java基础入门》教材配套的完整课后习题答案，面向Java初学者、高校计算机专业学生及自学编程的入门者，有效解决课后练习无参考、知识点理解不透、代码调试无依据等常见学习痛点。压缩包为单个DOC文档（214KB），内容覆盖全书10章核心习题，含填空、判断、选择、简答与编程五大题型，每章均提供标准答案与详细解析——如JDK与JRE区别辨析、运算符&与&&执行差异说明、冒泡排序完整实现及Student类封装范例等，助力夯实Java开发入门、语言基础、程序设计与面向对象四大模块。目前已有5694人学习下载，答案排版清晰、代码可直接运行，是课前预习、课后巩固与考前复习的实用参考资料。

1. Java 入门不是学“一堆英文单词”，而是搭一座能跑起来的桥

你是不是也这样：打开教程，第一行就看到public class HelloWorld，心里一咯噔——这啥？public是公开？class是班级？static void main又是什么黑匣子？越往后翻，越像在看一本加密手册：JDK、JRE、classpath、.class文件、虚拟机……名词一个接一个砸过来，连“我到底在学什么”都还没搞清，就已经被劝退三次了。

别急。Java 入门，真没那么玄。它不是让你背概念，而是教你怎么用一套标准化的积木规则，把想法变成电脑能听懂、还能反复运行的指令。就像学骑自行车，没人先让你背《牛顿力学三大定律》——你得先扶住车把、踩稳踏板、感受平衡点在哪。Java 的“第一块踏板”，就是那个印在全世界所有 Java 教材第一页的HelloWorld程序。它不炫技、不复杂，但它完整走通了 Java 开发最核心的一条链路：写代码 → 编译成字节码 → 虚拟机执行 → 看到结果。这条链路，就是你以后写电商后台、做数据处理、甚至参与 Apache 旗下开源项目的底层地基。而你现在手上的这份《Java 基础入门》课后习题答案，不是标准答案集，它是你第一次踩上踏板时，旁边那位不说话、但每一步都给你标好脚印的教练——填空题帮你理清环境配置的关键路径，判断题帮你避开新手必踩的逻辑陷阱，编程题的答案里藏着最干净的语法骨架。它不承诺你速成，但它保证：只要你跟着第一个例子敲完、跑通、看懂为什么能跑通，你就已经站在了 Java 后端开发的起跑线上。接下来要做的，不是 memorize（死记），而是run（运行）、break（故意改错）、fix（自己修好）——这才是零基础真正能抓住的起点。

2. 先搞懂一个事实：Java 不是直接给电脑看的，而是给“虚拟机”看的

很多新手卡在第一步，不是因为不会写代码，而是根本没意识到：你写的.java文件，电脑压根儿不认。它需要先被“翻译”成一种中间语言，再由一个叫Java 虚拟机（JVM）的程序来执行。这个“翻译”过程，就叫编译。理解这一点，是解开所有“为什么报错”的钥匙。

2.1 为什么必须装 JDK，而不是只装 JRE？

想象一下你要开一家奶茶店：

• JRE（Java Runtime Environment）就像店里那台现成的封口机——它只负责“执行”：你把做好的奶茶杯放上去，“噗”一声，盖上盖子，完事。顾客（也就是你写的程序）只需要这个功能。
• JDK（Java Development Kit）则是整套开店工具包：除了封口机（JRE），还有配方本（文档）、量杯和电子秤（编译器javac）、清洁剂（调试工具）、打包盒（打包工具jar）……它专为“做奶茶的人”（开发者）准备。

提示：初学者安装 JDK 后，JRE 就自动包含在里面了，不用单独下载。你电脑上只要有一个 JDK，就能写代码、编译、运行——三件事全包圆。

2.2javac和java这两个命令，到底在干什么？

这是新手最容易混淆的两个命令，它们分工明确，像流水线上的两道工序：

• javac HelloWorld.java
  → 这是编译命令。它读取你写的HelloWorld.java源文件，检查语法有没有硬伤（比如少了个分号、括号没配对），如果没问题，就生成一个叫HelloWorld.class的文件。注意：这个.class文件不是给 Windows 或 macOS 直接运行的，它是 JVM 的“专属食谱”。

• java HelloWorld
  → 这是运行命令。注意！这里不带.class后缀。java命令会去当前目录找HelloWorld.class文件，把它加载进 JVM，然后一行行解释执行。最终，你看到"这是第一个 Java 程序!"跳出来。

我们来亲手跑一遍，验证这个流程：

# 第一步：用任意文本编辑器（如记事本、VS Code）创建 HelloWorld.java 文件 # 内容严格按下面写（注意大小写、标点、空格） public class HelloWorld { public static void main(String[] args) { System.out.println("这是第一个 Java 程序!"); } }

# 第二步：打开命令行（Windows 是 cmd 或 PowerShell，macOS/Linux 是 Terminal） # 进入你保存 HelloWorld.java 的文件夹，比如 D:\java\lesson1 cd D:\java\lesson1 # 第三步：执行编译（生成 .class 文件） javac HelloWorld.java # 如果没报错，说明编译成功！此时文件夹里多了一个 HelloWorld.class # 第四步：执行运行 java HelloWorld

✅ 正确输出：

这是第一个 Java 程序!

💡 关键参数说明：

• public class HelloWorld：public表示这个类是公开的，可以被其他程序访问；HelloWorld是类名，必须和文件名完全一致（包括大小写），否则javac会直接报错。
• public static void main(String[] args)：这是 Java 程序的唯一入口。main方法就像大门的门把手，JVM 启动时，只认这个方法名、这个参数格式、这个返回类型（void表示不返回任何值）。少了任何一个词，或者顺序错了，程序就无法启动。
• System.out.println(...)：这是向控制台（黑窗口）打印文字的固定写法。System是系统类，out是它的输出对象，println是“打印并换行”的方法。初学不必深究原理，把它当成一个“喊话喇叭”就行。

2.3path和classpath：两个常被忽略、却决定你能不能敲出第一个命令的环境变量

刚装完 JDK，很多人输javac却提示'javac' 不是内部或外部命令。这不是你装错了，而是电脑“找不到”javac这个程序藏在哪。这就引出了两个关键环境变量：

• path：告诉操作系统：“当我在任何地方敲javac，请去这些文件夹里找找看”。你需要把 JDK 安装目录下的bin文件夹路径加进去。例如，JDK 装在C:\Program Files\Java\jdk-17\bin，就把这个完整路径加到path里。加完后，重启命令行，javac -version就能显示版本号了。

• classpath：告诉 JVM：“当你运行java HelloWorld时，请去这些文件夹里找HelloWorld.class”。对于最简单的单文件程序，通常不用手动设classpath，因为 JVM 默认会在当前目录（.）找。但一旦你开始写多个类、放在不同文件夹，或者用到别人写的库（比如 Apache Commons），classpath就成了必选项。

注意：path是给操作系统用的，classpath是给 JVM 用的。一个管“找工具”，一个管“找原料”。

2.4 常见问题排查：为什么我的 HelloWorld 就是跑不起来？

新手在这一步翻车率极高，问题看似五花八门，根源其实就那么几条。以下是真实血泪经验总结的 5 个高频坑，按“现象→原因→解决”给你列清楚：

1. 现象：'javac' 不是内部或外部命令
   原因：JDK 的bin目录没加到系统path环境变量里，或者加了但没重启命令行窗口。
   解决：确认 JDK 安装路径（如C:\Program Files\Java\jdk-17\bin），复制该路径 → 右键“此电脑”→“属性”→“高级系统设置”→“环境变量”→ 在“系统变量”里找到Path→ “编辑”→ “新建”→ 粘贴路径 → 确定。然后彻底关闭并重新打开命令行，再试javac -version。

2. 现象：error: class HelloWorld is public, should be declared in a file named HelloWorld.java
   原因：Java 规定：如果一个类声明为public，那么它的类名必须和文件名完全一致（包括大小写）。你可能把文件存成了helloworld.java或HelloWorld.txt。
   解决：检查文件名是否真的是HelloWorld.java（注意.java后缀，不是.txt！），且首字母大写。Windows 资源管理器默认隐藏已知文件后缀，务必在“查看”选项卡里勾选“文件扩展名”。

3. 现象：Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
   原因：javac编译成功了（生成了.class文件），但java命令运行时，没在当前目录找到HelloWorld.class。常见于：你在 A 文件夹编译，却跑到 B 文件夹去运行；或者文件名大小写和类名不一致（Linux/macOS 对大小写敏感，Windows 有时会“假装不敏感”导致迷惑）。
   解决：用dir（Windows）或ls（macOS/Linux）命令，确认当前目录下确实有HelloWorld.class文件。确保java命令后跟的是类名HelloWorld，绝对不要加.class后缀。

4. 现象：error: cannot find symbol（找不到符号）
   原因：代码里用了某个类、方法或变量，但拼写错了，或者没导入（import）对应的包。比如把System.out.println错打成system.out.println（System首字母小写），JVM 就不认识system这个东西。
   解决：逐字核对错误提示里提到的“symbol”（符号）名，对照你的代码。Java 是大小写敏感的语言，String和string是两个完全不同的东西。

5. 现象：控制台什么也不输出，光标就卡住了
   原因：main方法里漏掉了System.out.println(...)这行，或者写成了System.out.print(...)（不换行），而后面又没跟其他输出，看起来像“没反应”。
   解决：检查main方法的大括号{}里，是否真的有一行以System.out.开头的输出语句。初学建议统一用println，避免换行问题。

3. 从“能跑”到“懂为什么跑”：拆解第一个编程题里的四个核心概念

现在你已经能打出HelloWorld并看到结果了，恭喜！但这只是“能跑”。下一步，我们要把这 5 行代码掰开揉碎，弄懂每一部分在 Java 世界里扮演什么角色。这四个概念——类（Class）、方法（Method）、主方法（main）、输出语句（System.out.println）——是你未来写任何 Java 后端服务（比如一个用户登录接口）的最小原子单位。

3.1 类（Class）：一切的蓝图和容器

public class HelloWorld { ... }这行定义了一个叫HelloWorld的类。你可以把它理解成一张“设计图纸”或一个“模具”。

• 为什么需要类？因为 Java 是面向对象语言，它要求你把相关的数据（比如人的姓名、年龄）和操作这些数据的行为（比如打印姓名、计算年龄）打包在一起。这张图纸本身不会动，但你可以用它造出无数个具体的“人”（对象）。
• public是什么？这是访问修饰符，意思是“这张图纸谁都能拿去看、去用”。还有private（只有自己家人才能看）、protected（自家人+亲戚能看）等，它们像门锁，控制着代码的可见范围。
• 为什么类名必须和文件名一样？这是 Java 的硬性规定，目的是让 JVM 能快速、无歧义地定位到你要运行的“图纸”。就像图书馆里，书名和书脊标签必须一致，管理员才能一秒找到。

3.2 方法（Method）：封装行为的“小盒子”

public static void main(String[] args) { ... }这整段是一个方法，更准确地说，是HelloWorld这张图纸里定义的一个“功能模块”。

• 方法是什么？它是一组被命名的、可重复使用的代码块。比如，你想算两个数的和，就可以写一个叫add(int a, int b)的方法，以后想算加法，就“喊”这个名字，传两个数进去，它就把结果“吐”出来。
• main是特殊方法：它是整个程序的唯一入口点。JVM 启动时，只认这个方法名、这个参数列表（String[] args）、这个返回类型（void）。你可以把它想象成大楼的正门，保安（JVM）只允许从这扇门进来，其他门（比如你自己写的printName()方法）都是内部通道，得先进来再说。
• String[] args是什么？这是给程序传递“启动参数”的入口。比如你运行java HelloWorld zhangsan 18，那么args[0]就是"zhangsan"，args[1]就是"18"。虽然 HelloWorld 例子里没用到它，但这个结构是强制的，就像身份证号必须有18位，哪怕你填的全是0。

3.3static关键字：让方法“不依赖对象也能干活”

static是 Java 里一个看似简单、实则容易翻车的概念。它出现在main方法声明里：public static void main(...).

• static的本质：它表示这个方法属于类本身，而不是属于某个具体的“对象”。
• 举个生活例子：假设Car是一个类（图纸），myCar和yourCar是根据图纸造出来的两辆具体汽车（对象）。myCar.startEngine()是让我的车发动，yourCar.startEngine()是让你的车发动——它们是各自独立的动作。但如果我们定义一个Car.getTotalCarsProduced()方法，并加上static，那它就不是某辆车的动作，而是“整个汽车厂”的统计功能，它不关心是哪辆车，只关心总产量。
• 为什么main必须是static？因为 JVM 启动时，还没有任何HelloWorld对象存在！它得先调用main方法，然后main方法里才会去new HelloWorld()创建对象。所以main必须是“不依赖对象就能运行”的，这就是static的意义。

3.4System.out.println()：Java 世界的“麦克风”

System.out.println("这是第一个 Java 程序!");这行是整个程序里唯一产生可见效果的语句。

• System是一个预定义的类，它在java.lang包里，这个包是 Java 自带的“基础工具箱”，所有程序默认都能用，不用import。
• out是System类里的一个静态成员变量，它的类型是PrintStream（打印流），你可以把它理解成一个已经接好电源、随时待命的“麦克风”。
• println()是out这个麦克风上的一个方法，意思是“把括号里的内容大声念出来，然后换行”。print()是不换行的版本，printf()则支持格式化（比如保留两位小数）。
• "..."里的内容叫字符串字面量，它必须用英文双引号包裹。单引号' '是给单个字符（char）用的，比如'A'。混用会直接报错。

提示：System.out.println()是你调试程序最忠实的伙伴。未来写后端接口时，你可能用log.info("用户ID: {} 登录成功", userId)，但原理一样——都是把信息“说”出来，只是输出目的地从控制台变成了日志文件。

3.5 避坑：新手写代码时最容易忽略的三个“隐形规则”

这些规则不写在语法书里，但违反了，轻则报错，重则程序行为诡异。它们是 Java 的“潜规则”，也是老手一眼就能看出你是新手的标志：

1. 大括号{}必须成对出现，且位置不能乱
   现象：error: reached end of file while parsing（解析到文件末尾）
   原因：你少写了一个}，或者把}放错了位置，导致编译器找不到匹配的结束符。Java 用大括号界定代码块的范围，class、method、if、for都需要它。
   解决：养成习惯——每写一个{，立刻敲下一行}，再把光标移回中间写代码。用 VS Code 或 IntelliJ 这类编辑器，它会自动帮你高亮匹配的括号，非常直观。

2. 分号;是语句的句号，不是可有可无的装饰
   现象：error: ';' expected（期待分号）
   原因：Java 规定，每一条完整的执行语句（比如赋值、方法调用、声明变量）后面必须跟一个分号。漏掉它，就像中文句子没写句号，编译器不知道这句话到哪结束。
   解决：把分号当作语句的“收尾动作”。写完System.out.println(...)，手指条件反射敲;。注意：if (x > 0) { ... }这种结构体后面不加分号，只有里面的x = 1;这样的执行语句才加。

3. 英文标点是铁律，中文标点是“定时炸弹”
   现象：error: illegal character: '\uFF08'（非法字符）
   原因：你用中文输入法写了括号（）、引号“”或分号；。Java 只认识 ASCII 字符集里的英文符号()、""、;。中文符号在 Java 看来就是乱码。
   解决：写代码前，务必切换到英文输入法。这是一个肌肉记忆，坚持一周，你的大脑会自动提醒：“要写代码了，切英文！”。

4. 从“抄答案”到“改答案”：动手改第一个编程题，理解变量、循环和数组

现在你已经读懂了HelloWorld，是时候让它“活”起来了。课后习题第二章的编程题1，要求计算 1 到 99 之间所有奇数的和。答案给了，但如果你只是复制粘贴，它永远是别人的代码。真正的入门，是从“改”开始的——改一个数、换一个符号、删一行，看看会发生什么。这比背一百遍语法都管用。

4.1 理解原题答案：getSum程序的逐行拆解

先看官方答案：

public class getSum { public static void main(String[] args) { int sum = 0; // ① 声明一个整数变量 sum，初始值为 0 for (int i = 1; i < 100; i++) { // ② for 循环：i 从 1 开始，每次加 1，直到 i=99（<100） if (i % 2 != 0) // ③ 判断：i 除以 2 的余数不等于 0？即 i 是奇数？ sum += i; // ④ 如果是奇数，就把 i 加到 sum 上 } System.out.println(sum); // ⑤ 打印最终的 sum 值 } }

• ①int sum = 0;：int是 Java 的基本数据类型，代表整数（integer）。sum是变量名，=是赋值操作符，0是初始值。这行代码的意思是：“给我划一块内存，名字叫sum，里面先放个数字 0”。
• ②for (int i = 1; i < 100; i++)：这是循环结构。for是关键字，括号里分三部分：初始化（int i = 1，定义循环变量i并赋初值 1）、条件（i < 100，只要i小于 100，就继续循环）、迭代（i++，每次循环结束后，i自增 1）。大括号{}里的代码，就是循环体。
• ③if (i % 2 != 0)：这是分支结构。if是关键字，括号里是条件表达式。%是取模运算符，i % 2就是i除以 2 的余数。!=是“不等于”。所以整个条件的意思是：“如果i除以 2 的余数不是 0，也就是i是奇数”。
• ④sum += i;：这是复合赋值运算符，等价于sum = sum + i;。它表示“把sum当前的值，加上i，再放回sum里”。这是一种简洁写法，Java 里还有-=、*=、/=等。
• ⑤System.out.println(sum);：把计算好的总和sum打印出来。

4.2 动手改：三个安全的“破坏性实验”，立刻加深理解

别怕改坏！编程的第一课，就是学会“破坏”。下面三个修改，每一个都只会让程序输出不同结果，绝不会让你的电脑冒烟。

实验一：把i < 100改成i <= 100，看看结果变多少？

• ✅ 修改后：循环会执行到i = 100。但100 % 2 == 0，所以它不是奇数，不会被加进sum。结果不变。
• 💡 学到的：<=和<的边界差异，以及if条件如何过滤数据。

实验二：把i % 2 != 0改成i % 2 == 0，求偶数和

• ✅ 修改后：程序会计算 2+4+6+...+98，结果是 2450。
• 💡 学到的：==（等于）和!=（不等于）是逻辑判断的核心，改变条件，就改变了程序的“意图”。

实验三：把sum += i;换成sum = sum + i * i;，求奇数的平方和

• ✅ 修改后：计算1² + 3² + 5² + ... + 99²。你会发现结果巨大（166650），而且代码只改了一行。
• 💡 学到的：运算符优先级（*比+优先级高，所以i * i先算）、以及如何用简单运算组合出复杂逻辑。

提示：每次修改后，务必javac getSum.java重新编译，再java getSum运行。观察输出变化，这就是你和代码对话的方式。

4.3 进阶挑战：用数组存储并打印前 10 个斐波那契数

第三章的编程题2给出了一个递归求斐波那契数的函数。但递归对新手有点绕。我们换个更直观的方式：用数组（Array）把前 10 个数存下来，再一个个打印。

public class FibonacciArray { public static void main(String[] args) { // ① 创建一个长度为 10 的 int 数组，索引从 0 到 9 int[] fib = new int[10]; // ② 初始化前两个数（斐波那契数列的起点） fib[0] = 0; fib[1] = 1; // ③ 用循环计算第 2 到第 9 个数（索引 2 到 9） for (int i = 2; i < fib.length; i++) { fib[i] = fib[i-1] + fib[i-2]; // 每个数 = 前一个 + 前前一个 } // ④ 用 for-each 循环打印所有数 System.out.print("前10个斐波那契数："); for (int num : fib) { System.out.print(num + " "); } System.out.println(); // 换行 } }

• ①int[] fib = new int[10];：int[]表示“整数数组”，fib是数组名，new int[10]是在内存里申请 10 个连续的“小格子”，每个格子能放一个int。
• ②fib[0] = 0;：方括号[ ]是数组访问操作符，fib[0]指的是第一个格子（索引从 0 开始，不是 1！这是所有编程语言的惯例）。
• ③fib[i] = fib[i-1] + fib[i-2];：这是数组的核心玩法——通过索引，读取和写入任意位置的值。i-1和i-2就是动态地指向“前一个”和“前前一个”格子。
• ④for (int num : fib)：这是增强型 for 循环（for-each），专门用来遍历数组或集合。num是每次循环中取出的当前元素值，fib是要遍历的数组。它比传统for更简洁，不易出错。

✅ 运行结果：

前10个斐波那契数：0 1 1 2 3 5 8 13 21 34

注意：数组的索引从 0 开始，fib.length返回数组长度（10），所以i < fib.length确保了i最大只能是 9，不会越界（fib[10]会报ArrayIndexOutOfBoundsException错误）。

4.4 常见问题排查：数组和循环里的“越界”与“死循环”

这两个问题是新手在写for和数组时的“天敌”，几乎人人都会撞上。

1. 现象：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 10
   原因：你试图访问fib[10]，但数组fib只有 10 个元素，索引是0到9。“长度为 10”不等于“最大索引是 10”，而是“最大索引是 9”。
   解决：循环条件永远写成i < array.length，而不是i <= array.length。记住：length是总数，索引最大值是length - 1。

2. 现象：程序卡住，控制台一直没反应，CPU 占用飙升
   原因：死循环（Infinite Loop）。最常见的原因是for循环的迭代部分写错了，比如for (int i = 0; i < 10; i--)（i一直减，永远小于 10），或者忘了写i++。
   解决：在循环体里加一句System.out.println("i = " + i);，运行看i的值怎么变。如果它不按预期增长或减少，就是迭代逻辑错了。

3. 现象：数组打印出来全是0
   原因：你只声明了数组int[] arr = new int[5];，但没给任何一个元素赋值。Java 会给int数组的每个元素自动赋初值0。
   解决：声明后，必须用arr[0] = 1;这样的方式，或用循环，给每个位置填上你想要的值。

5. 面向对象不是“玄学”，而是把代码组织成“人+事”的自然方式

学到这里，你已经会写流程化的代码了：定义变量、用if判断、用for循环、用数组存数据。但现实中的程序，比如一个电商网站的后端，不可能只靠一堆零散的int和String运转。它需要管理“用户”、“商品”、“订单”这些有血有肉的概念。Java 的面向对象（OOP），就是一套把代码组织得像现实世界一样的方法论。它不增加新语法，而是教你用class、object、method这些已有工具，搭出更有结构、更易维护的程序。

5.1 从“学生信息”看透封装：把数据和行为打包成一个“学生”

第三章的编程题1，定义了一个Student类。我们把它简化，聚焦核心：

class Student { private String name; // ① 私有属性：姓名 private double grade; // ② 私有属性：成绩 // ③ 构造方法：创建学生对象时，必须提供姓名和成绩 public Student(String name, double grade) { this.name = name; // this.name 指当前对象的 name 属性 this.grade = grade; } // ④ getter 方法：对外提供“读取”姓名的途径 public String getName() { return name; } // ⑤ setter 方法：对外提供“修改”成绩的途径 public void setGrade(double grade) { this.grade = grade; } } // ⑥ 使用：创建两个学生对象 public class Test01 { public static void main(String[] args) { Student stu1 = new Student("zhangsan", 99); Student stu2 = new Student("lisi", 100); System.out.println(stu1.getName()); // 输出：zhangsan stu2.setGrade(95); // 把 lisi 的成绩改成 95 } }

• ① & ②private String name;：private是访问修饰符，意思是“这个属性是私有的，只有Student类自己的代码能直接访问它”。这叫封装（Encapsulation）——把数据（name,grade）和操作数据的方法（getName,setGrade）打包在一个“盒子”（Student类）里，并控制外界怎么和它互动。好处是：防止别人乱改数据（比如把成绩改成负数），也方便以后修改内部实现（比如把grade存成百分制，改成五分制，只要getter/setter接口不变，外面的代码完全不用改）。

• ③public Student(String name, double grade)：这是构造方法（Constructor）。它的名字必须和类名完全一样，没有返回类型（连void都不能写）。它的作用是在new Student(...)时，自动执行，完成对象的初始化工作（比如给name和grade赋初值）。没有它，你创建的对象里name和grade就是null和0.0（Java 给的默认值）。

• ④ & ⑤getName()和setGrade()：这是公共方法（Public Method），也叫 getter/setter。它们是外界和Student对象沟通的“正规渠道”。getName()只负责“读”，setGrade()只负责“写”，而且可以在setGrade()里加校验逻辑（比如if (grade < 0 || grade > 100) throw new IllegalArgumentException("成绩必须在0-100之间");），这就是封装带来的控制力。

• ⑥Student stu1 = new Student("zhangsan", 99);：new是创建对象的关键字。Student("zhangsan", 99)是调用构造方法。stu1是一个引用变量，它不存数据，只存着“指向zhangsan这个学生对象的地址”。你可以把它想象成一张“学生证”，证上写着“张三”，但真正的张三本人，在内存的另一个地方。

5.2 从“本科生”和“研究生”看透继承：复用代码，避免重复劳动

第四章的编程题1，展示了UnderGraduate（本科生）继承Student（学生）的例子。这是继承（Inheritance）的典型应用。

class Student { public String name; // 注意：这里用了 public，为了演示方便，实际应 private + getter public int age; public Student(String name, int age) { this.name = name; this.age = age; } public void show() { System.out.println("name: " + name + " age: " + age); } } // UnderGraduate 继承 Student，自动获得 name, age, show() 方法 class UnderGraduate extends Student { public String degree; // 本科生特有的属性：学位 public UnderGraduate(String name, int age, String degree) { super(name, age); // ① 必须调用父类构造方法 <p> <a href="https://download.csdn.net/download/weixin_58330979/83071304" style="color:#ec7500;font-size:14px;"> 本文还有配套的精品资源，点击获取 </a> <img alt="menu-r.4af5f7ec.gif" src="https://csdnimg.cn/release/wenkucmsfe/public/img/menu-r.4af5f7ec.gif" style="width:16px;margin-left:4px;vertical-align:text-bottom;cursor:text;"> </p>