征服Java三大特性：封装×继承×多态+this/super高阶指南

大家好，欢迎来到IT知识分享网。

一、封装

• 本质理解：将数据 属性 和操作该数据的 方法 （行为）捆绑在 类 中，通过访问控制修饰符限制外部对其内部细节的直接访问
• 核心目的：
• 保护内部数据的完整性 ：防止外部代码随意修改导致状态不一致
• 隐藏实现细节 ：对外只暴露必要的接口，降低模块间的耦合度
• 简化使用复杂度 ：使用者只需关注接口，不必了解内部复杂逻辑
• 通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是 封装性的设计思想

访问控制修饰符的应用技巧

| 修饰符 | 本类 | 同包类 | 子类（不同包） | 其他包非子类 | 常用场景 | | —

| private | ✅ | ❌ | ❌ | ❌ | 字段隐藏，内部方法封装 | | default | ✅ | ✅ | ❌ | ❌ | 包级私有工具类与实现 | | protected | ✅ | ✅ | ✅ | ❌ | 子类需访 #技术分享 #掘金问的父类属性和方法 | | public | ✅ | ✅ | ✅ | ✅ | 对外接口、常量的暴露 |

示例：封装的典型应用

public class Person { private String name; private int age; public String getName() { return name; } public void setName(String name) { if (name == null || name.trim().isEmpty()) { throw new IllegalArgumentException("姓名不能为空"); } this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age < 0 || age > 150) { throw new IllegalArgumentException("年龄不合法"); } this.age = age; } } 

• name和age被声明为 private ，外部无法直接修改
• 通过 setName 和 setAge 方法设置值时，会先进行合法性校验，避免无效数据破坏对象状态

二、关键字this

在 Java 中，this 关键字是一个指向 当前对象实例 的引用变量，主要用于解决变量命名冲突、调用其他构造方法或传递当前对象。下面介绍5种核心用法。

1、解决成员变量与局部变量命名冲突

• 当成员变量（类属性）与局部变量（方法参数或内部变量）同名时，使用 this 明确指定成员变量

public class Person { private String name; public void setName(String name) { this.name = name; } } 

2、在构造方法中调用其他构造方法

• 使用 this(…) 在构造方法中调用同类其他构造方法（ 必须放在第一行 ）

public class Rectangle { private int width, height; public Rectangle() { this(10, 10); } public Rectangle(int width, int height) { this.width = width; this.height = height; } } 

3、作为参数传递当前对象

• 将 当前对象 传递给其他方法

public class Printer { public void print() { System.out.println("Printing..."); } } public class Document { private String content; public void sendToPrinter(Printer printer) { printer.print(this.content); } public void process() { new Printer().printDocument(this); } } 

4、返回当前对象（链式调用）

• 在方法中返回 this 实现链式调用

public class Calculator { private int value; public Calculator add(int num) { this.value += num; return this; } public Calculator subtract(int num) { this.value -= num; return this; } } Calculator calc = new Calculator(); calc.add(5).subtract(3).add(10); 

5、内部类中访问外部类对象

• 当内部类与外部类有同名变量时，用 外部类名.this 明确指定

public class Outer { private String name = "Outer"; class Inner { private String name = "Inner"; public void printNames() { System.out.println(name); System.out.println(Outer.this.name); } } } 

三、继承

• 本质理解：子类（派生类）继承父类（基类）的 非私有属性和方法 ，实现代码重用并扩展新功能或重写特定行为
• 核心目的：
• 代码复用：减少冗余代码，提升开发效率
• 建立类层级关系：通过 is-a 关系建模（如 Manager is an Employee ）
• 实现多态基础：子类可替代父类对象使用（里氏替换原则）
• 深度特性解析：
• extends 关键字实现单继承（Java不支持多继承）
• 父类构造方法通过 super() 调用
• @Override 注解确保正确重写方法
• 所有类隐式继承 Object 类（如 toString() 、 equals() 方法）

示例：公司员工体系建模

class Employee { private String name; private double baseSalary; public Employee(String name, double salary) { this.name = name; this.baseSalary = salary; } public double calculatePay() { return baseSalary; } } class Manager extends Employee { private double bonus; public Manager(String name, double salary, double bonus) { super(name, salary); this.bonus = bonus; } @Override public double calculatePay() { return super.calculatePay() + bonus; } public void conductReview() { System.out.println("Conducting performance review..."); } } 

四、关键字super

在 Java 中，super 是一个特殊的关键字，主要用于访问 父类（超类） 的成员（ 属性 、方法 、构造器 ）。它在继承关系中发挥着关键作用。

1、调用父类的构造器

• 在子类构造器中用 super(…) 调用父类构造器
• 必须是子类构造器的 第一行语句 （ this() 和 super() 不能共存）
• 若未显式调用，编译器会 自动插入 super() （调用父类无参构造器）

class Parent { Parent(int value) { System.out.println("Parent构造器: " + value); } } class Child extends Parent { Child() { super(10); System.out.println("Child 构造器"); } } 

2、访问父类的成员变量

• 当子类变量与父类同名时，用 super.变量名 区分父类变量

class Parent { String name = "父类"; } class Child extends Parent { String name = "子类"; void print() { System.out.println(super.name); System.out.println(this.name); } } 

3、调用父类被重写的方法

• 子类重写父类方法后，用 super.方法名() 调用父类原始方法：

class Parent { void show() { System.out.println("Parent的方法"); } } class Child extends Parent { @Override void show() { super.show(); System.out.println("Child 的方法"); } } 

this关键字（或者this和super都不写）查找变量或方法时，优先查找当前类，找不到则向父类逐层查找

五、多态

• 本质理解：同一个方法调用，在 不同对象 上表现出 不同的行为
• Java实现的两大途径：
• 编译时多态（静态/方法重载）： 相同方法名，不同参数列表
• 运行时多态（动态绑定/方法重写）： 父类引用指向子类对象，调用被重写方法

运行机制揭秘：

sequenceDiagram Main->>Employee: employee.calculatePay() Employee-->>Manager: JVM查实际对象类型 Manager-->>Manager: 执行Manager的calculatePay() Manager->>Main: 返回结果 

1、方法内局部变量的赋值体现多态

public class TestPet { public static void main(String[] args) { Pet pet = new Dog(); pet.setNickname("小白"); pet.eat(); pet = new Cat(); pet.setNickname("雪球"); pet.eat(); } } 

2、方法的形参声明体现多态

public class Person{ private Pet pet; public void adopt(Pet pet) { this.pet = pet; } public void feed(){ pet.eat(); } } 

3、方法返回值类型体现多态

public class PetShop { public Pet sale(String type){ switch (type){ case "Dog": return new Dog(); case "Cat": return new Cat(); } return null; } } 

4、成员变量没有多态性

• 即使子类定义了与父类同名的实例变量，该变量也不会覆盖父类的变量
• 访问变量时是基于 引用的编译时类型 决定的，而非对象的实际类型

public class TestVariable { public static void main(String[] args) { Base b = new Sub(); System.out.println(b.a); System.out.println(((Sub)b).a); Sub s = new Sub(); System.out.println(s.a); System.out.println(((Base)s).a); } } class Base{ int a = 1; } class Sub extends Base{ int a = 2; } 

5、向上转型和向下转型

向上转型

• 定义：将 子类对象引用 转换为 父类类型
• 特点：
• 自动 发生（隐式转换）
• 绝对 安全 （子类“是”父类的一种）
• 只能访问父类中定义的成员（方法或变量）， 不能访问子类独有成员

class Animal { void eat() { System.out.println("Animal eats"); } } class Dog extends Animal { @Override void eat() { System.out.println("Dog eats bones"); } void bark() { System.out.println("Dog barks"); } } public class Main { public static void main(String[] args) { Animal animal = new Dog(); animal.eat(); } } 

向下转型

• 定义：将 父类对象引用 强制转换回 子类类型
• 特点：
• 需显式 强制转换 （可能抛出 ClassCastException ）
• 不安全 （必须确保父类引用实际指向目标子类对象）
• 转换成功后，可访问子类特有成员
• 安全做法：先用 instanceof 检查类型

if (父类引用 instanceof 目标子类) { 目标子类 引用 = (目标子类) 父类引用; } 

public class Main { public static void main(String[] args) { Animal animal = new Dog(); if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.eat(); dog.bark(); } Animal cat = new Cat(); } }