【2025】 Java 从入门到实战：基础语法与面向对象三大特性巩固练习讲解（附案例练习与答案）

前言

        Java 作为一门跨平台、面向对象的编程语言，凭借其稳定性和广泛的应用场景（后端开发、Android 开发、大数据等），始终是程序员必学的语言之一。本文将从 Java 基础语法入手，深入解析面向对象的三大特性（封装、继承、多态），并通过案例练习帮助你巩固知识点，适合零基础入门或需要查漏补缺的同学。

一、Java 基础语法

1. 基本概念与环境搭建

• Java 特点：跨平台（依赖 JVM 虚拟机）、面向对象、安全性、健壮性。
• 核心组件：
  • JDK（Java Development Kit）：开发工具包，包含 JRE 和编译器（javac）、运行工具（java）等。
  • JRE（Java Runtime Environment）：运行环境，包含 JVM 和核心类库。
  • JVM（Java Virtual Machine）：虚拟机，负责将字节码（.class）翻译成机器码执行。
• 环境搭建：
  1. 下载对应系统的 JDK（推荐 JDK1.8或者JDK 17+，长期支持版本）；
  2. 配置环境变量（JAVA_HOME 指向 JDK 安装目录，Path 中添加 %JAVA_HOME%\bin）；
  3. 验证：命令行输入 java -version 和 javac -version，显示版本信息则成功。

2. 第一个 Java 程序

public class HelloWorld {// 程序入口：main 方法public static void main(String[] args) {// 输出语句System.out.println("Hello, 2025 Java!");}
}

• 解释：
  • public class HelloWorld：定义公开类，类名必须与文件名（HelloWorld.java）一致。
  • main 方法：程序执行的入口，固定格式为 public static void main(String[] args)。
  • System.out.println()：打印内容并换行（print() 不换行）。
• 运行步骤：
  1. 用 javac HelloWorld.java 编译生成 HelloWorld.class 字节码文件；
  2. 用 java HelloWorld 运行程序，输出 Hello, 2025 Java!。

3. 变量与数据类型

（1）变量定义

变量是内存中的存储空间，用于存储数据，定义格式：数据类型 变量名 = 初始值;

int age = 20; // 整数
double height = 1.75; // 小数
char gender = '男'; // 单个字符
String name = "张三"; // 字符串（引用类型）
boolean isStudent = true; // 布尔值（true/false）

（2）基本数据类型（8 种）

类型	占用空间	范围示例
byte	1 字节	-128 ~ 127
short	2 字节	-32768 ~ 32767
int	4 字节	-2^31 ~ 2^31-1（常用）
long	8 字节	需加 L 后缀（如 100L）
float	4 字节	需加 F 后缀（如 3.14F）
double	8 字节	小数默认类型（如 3.14）
char	2 字节	单引号包裹（如 'A'、' 中 '）
boolean	1 字节	true / false

（3）类型转换

• 自动转换：小范围类型 → 大范围类型（如 int → double）。
• 强制转换：大范围类型 → 小范围类型（可能丢失精度），格式：目标类型 变量 = (目标类型) 值;

int a = 10;
double b = a; // 自动转换：10 → 10.0
int c = (int) 3.9; // 强制转换：3.9 → 3（丢失 0.9）

4. 运算符

（1）算术运算符

+、-、*、/（整数除法取商）、%（取余）、++（自增）、--（自减）

int x = 10, y = 3;
System.out.println(x + y); // 13
System.out.println(x / y); // 3（整数除法）
System.out.println(x % y); // 1（10 = 3*3 + 1）
System.out.println(++x); // 11（先自增后使用）
System.out.println(y--); // 3（先使用后自减）

（2）赋值运算符

=、+=、-=、*=、/=（如 a += 3 等价于 a = a + 3）

（3）比较运算符

==（等于）、!=（不等于）、>、<、>=、<=，结果为 boolean 类型。

（4）逻辑运算符

&&（短路与，两边都为真才真）、||（短路或，一边为真就真）、!（非）

boolean a = true, b = false;
System.out.println(a && b); // false
System.out.println(a || b); // true
System.out.println(!a); // false

5. 流程控制

（1）分支结构

• if-else：

int score = 85;
if (score >= 90) {System.out.println("优秀");
} else if (score >= 60) {System.out.println("及格");
} else {System.out.println("不及格");
}
// 输出：及格

• switch-case（JDK 7+ 支持 String）：

String day = "周一";
switch (day) {case "周一":System.out.println("上班");break; // 跳出分支case "周日":System.out.println("休息");break;default: // 其他情况System.out.println("正常作息");
}
// 输出：上班

（2）循环结构

• for 循环（适合已知次数）：

// 打印 1~5
for (int i = 1; i <= 5; i++) {System.out.println(i);
}

• while 循环（适合未知次数，先判断后执行）：

int count = 1;
while (count <= 5) {System.out.println(count);count++;
}

• do-while 循环（先执行后判断，至少执行一次）：

int num = 1;
do {System.out.println(num);num++;
} while (num <= 5);

6. 数组

数组是存储相同类型数据的容器，长度固定。

（1）定义与初始化

// 方式1：声明并初始化
int[] arr1 = {1, 2, 3, 4, 5};// 方式2：指定长度，默认值初始化（int为0，String为null）
int[] arr2 = new int[3];
arr2[0] = 10; // 赋值（索引从0开始）
arr2[1] = 20;
arr2[2] = 30;

（2）遍历数组

// for循环遍历
for (int i = 0; i < arr1.length; i++) {System.out.println(arr1[i]);
}// 增强for循环（foreach）
for (int num : arr1) {System.out.println(num);
}

二、面向对象三大特性

        Java 是面向对象编程（OOP）语言，核心思想是将现实世界的事物抽象为 “对象”，通过类描述对象的属性和行为。三大特性是封装、继承、多态。

1. 封装（Encapsulation）

（1）概念

封装是将对象的属性（数据）和方法（操作）捆绑在一起，并隐藏内部实现细节，只通过公共接口（方法）对外暴露。

• 目的：保护数据安全，防止外部随意修改，提高代码复用性。
• 实现方式：
  1. 属性用 private 修饰（私有，仅本类可见）；
  2. 提供公共的 getter（获取属性值）和 setter（设置属性值）方法。

（2）案例：封装学生类

public class Student {// 私有属性（隐藏细节）private String name;private int age;// 公共getter方法（获取属性）public String getName() {return name;}// 公共setter方法（设置属性，可添加校验）public void setName(String name) {this.name = name; // this指代当前对象}public int getAge() {return age;}public void setAge(int age) {// 校验年龄合法性if (age < 0 || age > 150) {System.out.println("年龄不合法");return;}this.age = age;}// 行为方法public void study() {System.out.println(name + "正在学习");}
}

（3）使用封装类

public class TestStudent {public static void main(String[] args) {Student s = new Student();s.setName("李四");s.setAge(20); // 合法年龄s.setAge(200); // 输出：年龄不合法System.out.println(s.getName() + "的年龄是" + s.getAge()); // 李四的年龄是20s.study(); // 李四正在学习}
}

2. 继承（Inheritance）

（1）概念

继承是让一个类（子类）拥有另一个类（父类）的属性和方法，实现代码复用，体现 “is-a” 关系（如 “学生 is a 人”）。

• 关键字：extends（Java 单继承，一个子类只能有一个父类）。
• 特点：
  • 子类继承父类非私有（private）的属性和方法；
  • 父类用 protected 修饰的成员，子类可访问；
  • 子类可重写（@Override）父类方法，实现自己的逻辑。

（2）案例：继承关系实现

// 父类：人
public class Person {protected String name; // 受保护的属性，子类可访问private int age; // 私有属性，子类不可直接访问public void setAge(int age) {this.age = age;}public int getAge() {return age;}public void eat() {System.out.println(name + "在吃饭");}
}// 子类：学生（继承自Person）
public class Student extends Person {private String studentId; // 子类特有属性// 子类构造方法（需先调用父类构造）public Student(String name, int age, String studentId) {this.name = name; // 直接访问父类protected属性super.setAge(age); // 调用父类方法this.studentId = studentId;}// 重写父类方法@Overridepublic void eat() {System.out.println(name + "在学校食堂吃饭");}// 子类特有方法public void study() {System.out.println(studentId + "号学生" + name + "在学习");}
}

（3）测试继承

public class TestInheritance {public static void main(String[] args) {Student s = new Student("王五", 18, "2025001");s.eat(); // 输出：王五在学校食堂吃饭（调用重写后的方法）s.study(); // 输出：2025001号学生王五在学习System.out.println(s.getAge()); // 输出：18（调用父类方法）}
}

3. 多态（Polymorphism）

（1）概念

多态是指同一行为（方法）在不同对象上有不同表现形式，实现 “一个接口，多种实现”。

• 实现条件：
  1. 存在继承关系；
  2. 子类重写父类方法；
  3. 父类引用指向子类对象（父类类型 变量 = new 子类类型();）。

（2）案例：多态的应用

// 父类：动物
public class Animal {public void sound() {System.out.println("动物发出声音");}
}// 子类：猫
public class Cat extends Animal {@Overridepublic void sound() {System.out.println("猫喵喵叫");}
}// 子类：狗
public class Dog extends Animal {@Overridepublic void sound() {System.out.println("狗汪汪叫");}
}

（3）测试多态

public class TestPolymorphism {public static void main(String[] args) {// 父类引用指向子类对象（多态体现）Animal animal1 = new Cat();Animal animal2 = new Dog();// 调用方法时，实际执行的是子类重写的版本animal1.sound(); // 输出：猫喵喵叫animal2.sound(); // 输出：狗汪汪叫// 多态的好处：统一接口，灵活扩展makeSound(animal1); // 调用通用方法makeSound(animal2);}// 通用方法：接收父类类型，适配所有子类public static void makeSound(Animal animal) {animal.sound();}
}

• 多态的好处：降低代码耦合度，新增子类（如 Bird）时，无需修改 makeSound 方法即可直接使用。

三、案例练习与答案

练习 1：基础语法综合

题目：计算 1~100 中所有偶数的和，并打印结果。

答案：

public class EvenSum {public static void main(String[] args) {int sum = 0;for (int i = 1; i <= 100; i++) {if (i % 2 == 0) { // 判断偶数sum += i;}}System.out.println("1~100偶数和为：" + sum); // 输出：2550}
}

练习 2：封装与构造方法

题目：定义一个 Circle 类，封装半径（radius）属性，提供构造方法初始化半径，以及计算面积（getArea()）和周长（getPerimeter()）的方法（π 取 3.14）。

答案：

public class Circle {private double radius;// 构造方法（无返回值，与类名相同）public Circle(double radius) {this.radius = radius;}public double getArea() {return 3.14 * radius * radius;}public double getPerimeter() {return 2 * 3.14 * radius;}// 测试public static void main(String[] args) {Circle c = new Circle(5);System.out.println("面积：" + c.getArea()); // 78.5System.out.println("周长：" + c.getPerimeter()); // 31.4}
}

练习 3：继承与多态

题目：定义 Shape 父类（含 getArea() 方法），子类 Rectangle（矩形，属性长和宽）和 Triangle（三角形，属性底和高），分别重写 getArea()，使用多态计算不同图形的面积。

答案：

// 父类：形状
public abstract class Shape { // 抽象类，含抽象方法public abstract double getArea();
}// 子类：矩形
public class Rectangle extends Shape {private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}@Overridepublic double getArea() {return length * width;}
}// 子类：三角形
public class Triangle extends Shape {private double base;private double height;public Triangle(double base, double height) {this.base = base;this.height = height;}@Overridepublic double getArea() {return 0.5 * base * height;}
}// 测试多态
public class TestShape {public static void main(String[] args) {Shape rect = new Rectangle(4, 5);Shape tri = new Triangle(3, 6);System.out.println("矩形面积：" + rect.getArea()); // 20.0System.out.println("三角形面积：" + tri.getArea()); // 9.0}
}

综合练习：

练习 4：学生成绩管理系统（综合基础语法 + 封装）

题目：设计一个学生成绩管理系统，要求：

1. 定义Student类，封装学生姓名、学号、3 门课程成绩（语文、数学、英语）；
2. 提供getter/setter方法，设置成绩时需校验（0-100 分之间，否则提示错误）；
3. 提供计算平均分的方法getAverage()；
4. 在测试类中创建 3 个学生对象，手动输入成绩后，打印每个学生的信息（姓名、学号、各科成绩、平均分）。

答案：

import java.util.Scanner;// 学生类（封装）
class Student {private String name;       // 姓名private String studentId;  // 学号private double chinese;    // 语文成绩private double math;       // 数学成绩private double english;    // 英语成绩// 构造方法public Student(String name, String studentId) {this.name = name;this.studentId = studentId;}// getter/setter方法（含成绩校验）public String getName() {return name;}public String getStudentId() {return studentId;}public double getChinese() {return chinese;}public void setChinese(double chinese) {if (chinese < 0 || chinese > 100) {System.out.println("语文成绩不合法（必须0-100分），已设为0分");this.chinese = 0;} else {this.chinese = chinese;}}public double getMath() {return math;}public void setMath(double math) {if (math < 0 || math > 100) {System.out.println("数学成绩不合法（必须0-100分），已设为0分");this.math = 0;} else {this.math = math;}}public double getEnglish() {return english;}public void setEnglish(double english) {if (english < 0 || english > 100) {System.out.println("英语成绩不合法（必须0-100分），已设为0分");this.english = 0;} else {this.english = english;}}// 计算平均分public double getAverage() {return (chinese + math + english) / 3;}// 打印学生信息public void printInfo() {System.out.println("学号：" + studentId);System.out.println("姓名：" + name);System.out.println("语文：" + chinese + "分");System.out.println("数学：" + math + "分");System.out.println("英语：" + english + "分");System.out.println("平均分：" + String.format("%.1f", getAverage()) + "分"); // 保留1位小数System.out.println("---------------------");}
}// 测试类
public class ScoreManagement {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 创建3个学生对象Student s1 = new Student("张三", "2025001");Student s2 = new Student("李四", "2025002");Student s3 = new Student("王五", "2025003");// 输入并设置成绩（以s1为例，s2、s3类似）System.out.println("请输入张三的成绩（语文 数学 英语，空格分隔）：");double c1 = scanner.nextDouble();double m1 = scanner.nextDouble();double e1 = scanner.nextDouble();s1.setChinese(c1);s1.setMath(m1);s1.setEnglish(e1);System.out.println("请输入李四的成绩（语文 数学 英语，空格分隔）：");double c2 = scanner.nextDouble();double m2 = scanner.nextDouble();double e2 = scanner.nextDouble();s2.setChinese(c2);s2.setMath(m2);s2.setEnglish(e2);System.out.println("请输入王五的成绩（语文 数学 英语，空格分隔）：");double c3 = scanner.nextDouble();double m3 = scanner.nextDouble();double e3 = scanner.nextDouble();s3.setChinese(c3);s3.setMath(m3);s3.setEnglish(e3);// 打印所有学生信息System.out.println("\n===== 学生成绩列表 =====");s1.printInfo();s2.printInfo();s3.printInfo();scanner.close();}
}

运行示例：

请输入张三的成绩（语文 数学 英语，空格分隔）：
90 85 95
请输入李四的成绩（语文 数学 英语，空格分隔）：
105 70 80
数学成绩不合法（必须0-100分），已设为0分
请输入王五的成绩（语文 数学 英语，空格分隔）：
75 88 92===== 学生成绩列表 =====
学号：2025001
姓名：张三
语文：90.0分
数学：85.0分
英语：95.0分
平均分：90.0分
---------------------
学号：2025002
姓名：李四
语文：0.0分（因105分不合法）
数学：70.0分
英语：80.0分
平均分：50.0分
---------------------
学号：2025003
姓名：王五
语文：75.0分
数学：88.0分
英语：92.0分
平均分：85.0分
---------------------

练习 5：动物行为模拟器（综合继承 + 多态）

题目：设计一个动物行为模拟器，要求：

1. 定义抽象父类Animal，包含抽象方法move()（移动）和eat()（进食）；
2. 定义 3 个子类：Dog（狗）、Bird（鸟）、Fish（鱼），分别重写move()和eat()方法（体现不同行为）；
3. 定义测试类，创建一个Animal数组，存放不同动物对象，通过循环调用每个动物的move()和eat()方法（体现多态）。

答案：

// 抽象父类：动物
abstract class Animal {// 抽象方法：移动public abstract void move();// 抽象方法：进食public abstract void eat();
}// 子类：狗
class Dog extends Animal {@Overridepublic void move() {System.out.println("狗用四条腿奔跑");}@Overridepublic void eat() {System.out.println("狗吃骨头");}
}// 子类：鸟
class Bird extends Animal {@Overridepublic void move() {System.out.println("鸟用翅膀飞翔");}@Overridepublic void eat() {System.out.println("鸟吃虫子");}
}// 子类：鱼
class Fish extends Animal {@Overridepublic void move() {System.out.println("鱼用鳍游泳");}@Overridepublic void eat() {System.out.println("鱼吃浮游生物");}
}// 测试类（多态体现）
public class AnimalSimulator {public static void main(String[] args) {// 创建Animal数组，存放不同子类对象（多态：父类引用指向子类对象）Animal[] animals = new Animal[3];animals[0] = new Dog();animals[1] = new Bird();animals[2] = new Fish();// 循环调用方法（统一接口，不同实现）System.out.println("===== 动物行为模拟 =====");for (Animal animal : animals) {animal.move(); // 实际执行子类重写的move()animal.eat();  // 实际执行子类重写的eat()System.out.println("---"); // 分隔线}}
}

运行结果：

===== 动物行为模拟 =====
狗用四条腿奔跑
狗吃骨头
---
鸟用翅膀飞翔
鸟吃虫子
---
鱼用鳍游泳
鱼吃浮游生物
---

        这两个练习分别侧重 “封装 + 基础语法” 和 “继承 + 多态”，覆盖了 Java 核心知识点。练习时建议先独立编写，再对照答案优化，重点理解：

• 封装如何通过private和getter/setter保护数据；
• 多态如何通过 “父类引用 + 子类对象” 实现代码的灵活性和扩展性。

总结

        本文涵盖了 Java 基础语法（变量、运算符、流程控制、数组）和面向对象三大特性（封装、继承、多态），并通过案例练习帮助巩固。学习 Java 的关键在于多写代码，理解 “面向对象” 的思维方式。后续可深入学习接口、集合、异常处理等内容，逐步提升实战能力。