一、封装

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

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

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

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

    }
}