一、封装

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

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

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

示例：封装的典型应用

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();

    }
}

莫度编程网

技术文章干货、编程学习教程与开发工具分享

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