【Java】2026 Java学习路线：语言根基（三）★ 核心

Java基础必学知识点 之 语言根基（三）

一、基础概念

1. 什么是面向对象？

• 核心：面向对象就是把现实世界中的“东西”直接映射成程序中的“对象”，每个对象有自己的数据（属性）和操作（方法）。

2. 类与对象

• 类 （Class）：模板/蓝图，定义了一类事物共有的属性和行为。不占内存。
• 对象 （Object）：根据类创建出来的具体实例。占内存，有具体的属性值。

示例：
定义一个Student类，创建多个学生对象。

// 1. 定义 Student 类（模板）publicclassStudent{// 成员变量（属性）Stringname;intage;StringstudentId;// 成员方法（行为）publicvoidstudy(){System.out.println(name+" 正在学习...");}publicvoidintroduce(){System.out.println("大家好，我叫 "+name+"，今年 "+age+" 岁，学号是 "+studentId);}}// 2. 在另一个类（比如 Main）中创建对象publicclassMain{publicstaticvoidmain(String[]args){// 创建第一个学生对象Studentstu1=newStudent();stu1.name="张三";stu1.age=18;stu1.studentId="20240001";stu1.introduce();// 输出：大家好，我叫 张三，今年 18 岁，学号是 20240001stu1.study();// 输出：张三 正在学习...// 创建第二个学生对象Studentstu2=newStudent();stu2.name="李四";stu2.age=19;stu2.studentId="20240002";stu2.introduce();// 输出：大家好，我叫 李四，今年 19 岁，学号是 20240002}}

Student类定义了“所有学生都有的东西”（姓名、年龄、学习），而stu1和stu2是两个具体的、不同的学生实例。

• 成员变量（属性）：对象拥有的数据，如name、age。
• 成员方法（行为）：对象能执行的操作，如study()。

二、OOP 三大核心特征（重中之重）

1. 封装

• 目的：保护数据不被外部随意修改，隐藏内部的复杂实现细节。使用时只需要通过已经提供的方法来操作，而不是直接碰内部零件。

• 实现：

  • private修饰属性 → 外部不能直接访问。
  • public的getter/setter→ 提供受控的访问入口。
    提供public的getter（获取值）和setter（设置值）方法，让外部通过方法来间接访问。在setter方法里，可以加入逻辑检查（比如余额不能为负数）。

• 示例：一个BankAccount类，余额不允许直接修改。

publicclassBankAccount{privateStringowner;// 私有属性privatedoublebalance;// 私有属性，不能直接修改// 构造方法（稍后细讲）publicBankAccount(Stringowner,doubleinitialBalance){this.owner=owner;if(initialBalance>0){this.balance=initialBalance;}else{this.balance=0;}}// Getter 方法：提供安全的读取方式publicdoublegetBalance(){returnbalance;}// 自定义的业务方法，而不是通用的 setterpublicvoiddeposit(doubleamount){// 存款if(amount>0){balance+=amount;System.out.println("存款成功，当前余额："+balance);}else{System.out.println("存款金额必须为正数");}}publicvoidwithdraw(doubleamount){// 取款if(amount>0&&amount<=balance){balance-=amount;System.out.println("取款成功，当前余额："+balance);}else{System.out.println("余额不足或金额无效");}}}// 测试publicclassMain{publicstaticvoidmain(String[]args){BankAccountmyAccount=newBankAccount("张三",1000);// myAccount.balance = -100; // 错误！balance 是 private，无法访问System.out.println("当前余额："+myAccount.getBalance());// 输出：1000.0myAccount.deposit(500);// 输出：存款成功，当前余额：1500.0myAccount.withdraw(2000);// 输出：余额不足或金额无效myAccount.withdraw(200);// 输出：取款成功，当前余额：1300.0}}

2. 继承

• 概念：一个类（子类）可以继承另一个类（父类）的属性和方法，实现代码复用。这是一个“is-a”的关系。Dog是一个Animal。

• 关键字：extends。

• 方法重写 （Override）：子类重新实现父类的方法。

• super关键字：在子类中调用父类的构造方法或成员。

• 示例：Animal→Dog/Cat

// 父类publicclassAnimal{Stringname;publicvoideat(){System.out.println(name+" 正在吃东西");}}// 子类 DogpublicclassDogextendsAnimal{// 子类特有的属性publicStringbreed;// 品种// 方法重写 (Override)@Overridepublicvoideat(){System.out.println(name+" 正在啃骨头");}// 子类特有的方法publicvoidbark(){System.out.println(name+" 汪汪叫");}}// 子类 CatpublicclassCatextendsAnimal{@Overridepublicvoideat(){System.out.println(name+" 正在吃鱼");}publicvoidmeow(){System.out.println(name+" 喵喵叫");}}// 测试publicclassMain{publicstaticvoidmain(String[]args){Dogdog=newDog();dog.name="旺财";dog.eat();// 输出：旺财 正在啃骨头 (调用的是重写后的)dog.bark();// 输出：旺财 汪汪叫Catcat=newCat();cat.name="咪咪";cat.eat();// 输出：咪咪 正在吃鱼cat.meow();// 输出：咪咪 喵喵叫}}

3. 多态

• 概念：同一个行为，作用于不同的对象，可以产生不同的结果。

• 核心语法：通过父类引用调用子类重写的方法。例如：Animal myAnimal = new Dog();

• 编译时类型 vs 运行时类型：

  • 编译时类型（声明类型）决定能调用哪些方法。
  • 运行时类型（实际类型）决定执行哪个版本的方法。

myAnimal的编译时类型是Animal，编译器只认Animal类里的方法（比如eat()）。
myAnimal的运行时类型是Dog，实际执行时，会执行Dog类里重写后的方法。

• 多态的好处：方法参数写成父类型，可以传入任意子类对象，扩展性强。

示例：写一个makeSound(Animal a)方法

// 沿用上面的 Animal, Dog, Cat 类publicclassMain{// 这个方法的参数是 Animal 类型，但你可以传入任何 Animal 的子类对象publicstaticvoidmakeSound(Animala){// 这里展示了多态：a 可能是 Dog，也可能是 Catif(ainstanceofDog){Dogd=(Dog)a;// 向下转型d.bark();}elseif(ainstanceofCat){Catc=(Cat)a;c.meow();}else{a.eat();// 默认行为}}// 更经典的多态例子publicstaticvoidletAnimalEat(Animala){a.eat();// 编译时看 Animal 有 eat()，运行时看具体子类的 eat()}publicstaticvoidmain(String[]args){Dogdog=newDog();dog.name="旺财";Catcat=newCat();cat.name="咪咪";letAnimalEat(dog);// 输出：旺财 正在啃骨头letAnimalEat(cat);// 输出：咪咪 正在吃鱼makeSound(dog);// 输出：旺财 汪汪叫makeSound(cat);// 输出：咪咪 喵喵叫}}

三、进阶 OOP 相关语法

1. 构造方法

• 特点：方法名与类名相同，没有返回值。在创建对象时（new）自动调用，用于初始化对象。

• 默认构造：如果不写构造方法，Java 会提供默认无参构造。

• 有参构造 & 重载：你可以定义多个构造方法，参数列表不同，方便用不同方式创建对象。

publicclassPerson{Stringname;intage;// 无参构造publicPerson(){}// 有参构造（重载）publicPerson(Stringname){this.name=name;// 用 this 区分成员变量和参数System.out.println("一个叫"+name+"的人被创建了");}// 另一个有参构造（重载）publicPerson(Stringname,intage){this.name=name;this.age=age;System.out.println("姓名："+name+"，年龄："+age);}}

2.this关键字

• 代表当前对象的引用。

• 用途：区分成员变量和局部变量（如this.name = name;）。

• 关键用法：

  限制
  this.属性/this.方法()	只能在非静态方法/构造方法中使用
  this(...)调用构造方法	必须是构造方法中的第一条语句，且只能在构造方法中使用

• 示例：

publicclassStudent{privateStringname;privateintage;// 构造方法1：两个参数publicStudent(Stringname,intage){this.name=name;this.age=age;System.out.println("调用2参数构造方法");}// 构造方法2：只有姓名，年龄使用默认值publicStudent(Stringname){this(name,18);// 调用上面的2参数构造方法System.out.println("调用1参数构造方法");}// 构造方法3：无参数，使用默认值publicStudent(){this("匿名",18);// 调用2参数构造方法System.out.println("调用无参数构造方法");}publicstaticvoidmain(String[]args){Students1=newStudent("张三",20);Students2=newStudent("李四");Students3=newStudent();}}

执行结果：
调用2参数构造方法
调用2参数构造方法
调用1参数构造方法
调用2参数构造方法
调用无参数构造方法

3.static关键字

• 实例变量/方法与静态变量/方法：

• 静态方法中不能直接访问实例变量和实例方法（因为没有this）,但是可以通过对象引用来访问。

publicclassSchool{publicstaticStringschoolName="第一中学";// 静态变量publicStringstudentName;// 实例变量publicstaticvoidprintSchoolName(){// 静态方法System.out.println("学校名称："+schoolName);// System.out.println(studentName); // 错误！静态方法不能访问非静态变量}publicvoidprintInfo(){// 实例方法System.out.println(schoolName+" 的学生："+studentName);}}// 使用publicclassMain{publicstaticvoidmain(String[]args){System.out.println(School.schoolName);// 直接通过类名访问Schools1=newSchool();Schools2=newSchool();s1.studentName="张三";s2.studentName="李四";s1.printInfo();// 输出：第一中学 的学生：张三s2.printInfo();// 输出：第一中学 的学生：李四}}

4. 代码块

• 构造块：写在类里，方法外的{ }。每次创建对象时，在构造方法之前执行。

• 静态块：用static { }包裹。在类第一次加载时执行一次，常用于初始化静态变量。

publicclassDemo{static{System.out.println("静态块：类加载时执行一次");}{System.out.println("构造块：每次创建对象前执行");}publicDemo(){System.out.println("构造方法执行");}publicstaticvoidmain(String[]args){newDemo();System.out.println("---");newDemo();}}// 输出顺序：// 静态块：类加载时执行一次// 构造块：每次创建对象前执行// 构造方法执行// ---// 构造块：每次创建对象前执行// 构造方法执行

四、抽象 & 接口（非常重要）

1. 抽象类

抽象类是使用abstract关键字修饰的类，不能被实例化，主要用于被其他类继承。

• 基本语法：

// 抽象类 public abstract class Animal { // 普通成员变量 private String name; // 普通方法（有实现） public void eat() { System.out.println("动物吃东西"); } // 抽象方法（没有方法体） public abstract void makeSound(); }

• 抽象方法

• 使用abstract关键字修饰。

• 没有方法体（没有大括号和实现代码）。

• 必须以分号结尾。

// 正确：抽象方法 public abstract void doSomething(); // 错误：抽象方法不能有方法体 public abstract void doSomething() { } // 编译错误

• 抽象类特点对比总结：

• 示例：

public abstract class Vehicle { private String brand; private int speed; // 构造方法（子类可以调用） public Vehicle(String brand) { this.brand = brand; System.out.println("Vehicle构造方法被调用"); } // 普通方法 public void setSpeed(int speed) { this.speed = speed; System.out.println(brand + " 速度设置为: " + speed); } // 抽象方法 public abstract void start(); public abstract void stop(); } // 子类必须实现所有抽象方法 public class Car extends Vehicle { public Car(String brand) { super(brand); // 调用父类构造方法 } @Override public void start() { System.out.println("汽车通过点火启动"); } @Override public void stop() { System.out.println("汽车踩刹车停止"); } } // 使用 public class Test { public static void main(String[] args) { // Vehicle v = new Vehicle(); // 错误：不能实例化抽象类 Car car = new Car("特斯拉"); car.start(); // 输出：汽车通过点火启动 car.setSpeed(100); // 输出：特斯拉 速度设置为: 100 car.stop(); // 输出：汽车踩刹车停止 } }

2. 接口

• 接口定义"规则"或"标准"。
• 任何类只要遵守这些规则，就能被统一使用。

1. 定义接口：

// 使用 interface 关键字，不是 class public interface Animal { // 接口中的方法没有方法体（没有大括号） void eat(); void sleep(); }

2. 实现接口（使用 implements 关键字）：

// 类使用 implements 实现接口 public class Dog implements Animal { // 必须实现接口中的所有方法 @Override public void eat() { System.out.println("狗吃骨头"); } @Override public void sleep() { System.out.println("狗趴着睡觉"); } } public class Cat implements Animal { @Override public void eat() { System.out.println("猫吃鱼"); } @Override public void sleep() { System.out.println("猫蜷缩着睡觉"); } }

3. 使用接口：

public class Test { public static void main(String[] args) { // 接口不能直接创建对象 // Animal a = new Animal(); 错误！ // 但可以用接口引用实现类的对象（多态） Animal dog = new Dog(); Animal cat = new Cat(); dog.eat(); // 输出：狗吃骨头 cat.eat(); // 输出：猫吃鱼 } }

4. 核心：

5. 接口的继承：

• 接口可以继承多个接口。

interface A { void methodA(); } interface B { void methodB(); } // 接口可以多继承 interface C extends A, B { void methodC(); } // 实现C的类必须实现所有方法（A、B、C中的） public class MyClass implements C { @Override public void methodA() { System.out.println("实现A"); } @Override public void methodB() { System.out.println("实现B"); } @Override public void methodC() { System.out.println("实现C"); } }

3. 抽象类 vs 接口（初学者必知）