面向对象编程核心：封装、继承、多态与 static 关键字深度解析

一、封装：数据安全与接口规范

1. 封装的本质与作用

核心定义：将数据（属性）与操作数据的方法（行为）绑定在类中，隐藏内部实现细节，仅通过公开接口对外提供服务

三大优势：

数据保护：防止外部非法修改（如年龄不能为负数）
接口统一：通过规范的getter/setter方法控制属性访问
可维护性：内部逻辑变化不影响外部调用

// 数据保护：禁止外部直接修改私有属性
private String password; // 统一接口：通过公共方法控制访问逻辑
public void setPassword(String pwd) {if (pwd.length() >= 6) this.password = pwd;
}

访问修饰符：

修饰符	类内	同包	子类	全局	典型应用场景
private	✅	❌	❌	❌	类内私有属性 / 方法
default	✅	✅	❌	❌	同包可见的工具方法
protected	✅	✅	✅	❌	子类扩展的父类方法
public	✅	✅	✅	✅	对外公开的接口

2. 封装最佳实践

属性私有，get/set

// 推荐：Java Bean规范
public class User {// 私有属性private String username;private int age;// 无参构造（框架反射需要）public User() {}// 全参构造（明确初始化逻辑）public User(String username, int age) {this.username = username;this.age = age;}// Getter/Setter（带参数校验）public String getUsername() { return username; }public void setAge(int age) {if (age > 0 && age < 150) { // 参数校验：年龄合法性校验this.age = age;}}
}

狂神说课堂笔记package com.oop.demo04;
//类 private:私有
public class Student {//属性私有private String name;//名字private int id;//学号private int sex;//性别private int age;//提供一些可以操作这个属性的方法//提供一些public的get、set的方法//get 获得这个属性public String getName() {return this.name;
}//set 给这个数据设置值public void setName(String name){this.name = name;}//alt + insert快捷键⚠️//选择Getter and Setter可自动生成get和set方法public int getAge() {return age;}public void setAge(int age) {if(age >120 || age < 0){//不合法this.age = 3;}else {this.age = age;}}
}

狂神说课堂笔记public class Application {public static void main(String[] args) {Student s1 = new Student();String name = s1.getName();s1.setName("秦疆");System.out.println(s1.getName());s1.setAge(20);System.out.println(s1.getAge());}
}

二、继承：代码复用的核心机制与 is-a 关系

1. 继承的核心语法

定义格式：class 子类 extends 父类
extends的意思是“扩展”。子类是父类的扩展。
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义上讲应该具有"is a"的关系.

核心特性：子类自动拥有父类的非私有属性和方法，实现代码复用

// 父类
public class Animal {protected String name;public void eat() { System.out.println("动物进食"); }
}// 子类继承父类
public class Dog extends Animal {public void bark() { System.out.println("汪汪叫"); }
}

单继承限制：Java 只支持单继承（一个子类只能有一个父类），但可以多层继承（如 Dog → Animal → Object）
IDEA快捷键：Ctrl + H⚠️

2. 构造器继承规则

子类构造器默认调用父类无参构造（第一行隐含super()）

public class Dog extends Animal {public Dog() { super(); // 自动调用父类无参构造}
}

若父类无无参构造，子类必须显式调用父类有参构造

public class Animal {public Animal(String name) { this.name = name; } // 仅有参构造
}
public class Dog extends Animal {public Dog(String name) { super(name); // 必须显式调用父类有参构造}
}

3. 继承的优缺点

优点	缺点
代码复用，减少冗余	子类依赖父类实现，耦合度高
天然支持 is-a 关系建模	单继承限制扩展性（组合优于继承）

三、Super 关键字：父类访问的桥梁

1. Super 的三大核心用法

访问父类属性：解决子类与父类属性同名冲突

class Parent { protected String name = "Parent"; }
class Child extends Parent {private String name = "Child";public void printName() {System.out.println(super.name); // 输出"Parent"}
}

访问父类版本

public class Child extends Parent {private String name = "子类";public void printName() {System.out.println(super.name); // 输出父类的name属性}
}

调用父类方法：在子类重写方法中保留父类逻辑

@Override
public void eat() {super.eat(); // 先执行父类进食逻辑System.out.println("子类额外进食逻辑");
}

调用父类构造器：必须作为子类构造器第一行代码

public Child() {super("参数"); // 调用父类有参构造
}

2. Super vs This

关键字	指代对象	调用构造器时机	访问范围
super	父类对象	子类构造器第一行	父类成员
this	当前对象	本类构造器第一行	本类成员

super注意点：1.super调用父类的构造方法，必须在构造方法的第一个2.super 必须只能出现在子类的方法或者构造方法中!3.super和 this 不能同时调用构造方法!VS this：代表的对象不同:this:本身调用者这个对象super:代表父类对象的应用前提this:没有继承也可以使用super:只能在继承条件才可以使用构造方法this();本类的构造super():父类的构造!

3. 本节狂神说笔记

Application.javapackage com.oop;import com.oop.demo05.Person;
import com.oop.demo05.Student;public class Application {public static void main(String[] args) {Student student = new Student();student.test("秦疆");student.test1();}
}

Person.javapackage com.oop.demo05;
//在Java中，所有的类，都默认直接或者间接继承object
//Person 人：父类
public class Person/*extend Object*/{public Person(){System.out.println("Person无参执行了");}protected String name = "kuangshen";public void print(){System.out.println("Person");}
}

Student.javapackage com.oop.demo05;
//Student is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法!
public class Student extends Person{public Student(){//隐藏代码：默认调用了父类的无参构造// super();调用父类的构造器，必须要在于类构造器的第一行System.out.println("Student无参执行了");}private String name = "qinjiang";public void print(){System.out.println("Student");}public void test1(){print();//Studentthis.print();//Studentsuper.print();//Person}public void test(String name){System.out.println(name);//秦疆System.out.println(this.name);//qinjiangSystem.out.println(super.name);//kuangshen}
}

四、方法重写：多态的前置条件

1. 重写的核心规则（三同原则）

三同原则：方法名、参数列表、返回类型必须相同（返回类型可协变，如子类返回父类返回类型的子类型）
访问修饰符：子类方法不能比父类更严格（父类protected，子类可以是public）

注解校验：使用@Override强制编译器检查重写合法性强制编译器检查重写合法性

class Animal {public void move() { System.out.println("动物移动"); }
}
class Bird extends Animal {@Overridepublic void move() { // 合法重写System.out.println("鸟类飞翔");}
}

2. 本节狂神说笔记

Application.javapackage com.oop;import com.oop.demo05.A;
import com.oop.demo05.B;public class Application {//静态的方法和非静态的方法区别很大!//静态方法等于类的方法，非静态方法调用对象的方法/*静态方法：方法的调用只和左边定义的数据类型有关非静态：重写没有static时，b调用的是对象的方法，而b是用A类new的有static时，b调用了B类的方法，因为b是用b类定义的*/public static void main(String[] args) {//方法的调用只和左边定义的数据类型有关A a = new A();a.test();//A//父类的引用指向了子类B b = new A();//子类重写了父类的方法b.test();//B}
}

A.javapackage com.oop.demo05;
//继承
public class A extends B {//Override 重写@Override//注解：有功能的注释public void test() {System.out.println("A=>text()");}
}

B.javapackage com.oop.demo05;
//重写都是方法的重写，和属性无关
public class B {public  void test(){System.out.println("B=>text()");}
}

重写：需要有继承关系，子类重写父类的方法！1.方法名必须相同2.参数列表必须相同，否则就变成重载了3.修饰符：范围可以扩大但不能缩小：public>Protected>Default>private4.抛出的异常:范围，可以被缩小，但不能扩大;ClassNotFoundException --> Exception(大)重写，子类的方法和父类必要一致;方法体不同!为什么需要重写：1.父类的功能，子类不一定需要，或者不一定满足!Alt + Insert ;override;

3. 重写与重载的核心区别

特性	重写（Override）	重载（Overload）
作用范围	子类与父类之间	同一类中
参数列表	必须相同	必须不同
返回类型	必须相同（或协变）	无关
修饰符	不能更严格	无限制

五、多态：同一接口的不同实现

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多()

1. 多态的三大要素

// 1. 继承：定义父类与子类（如Shape与Circle）
class Shape { public void draw() { ... } }
class Circle extends Shape { @Override public void draw() { ... } }// 2. 重写：子类重写父类方法（如Circle重写Shape的draw方法）// 3. 父类引用子类对象：通过向上转型实现多态赋值
Shape shape = new Circle(); // 多态赋值
shape.draw(); // 动态调用Circle的draw方法（运行时多态）

2. 多态的内存本质

编译时类型：变量声明的类型（如Shape）
运行时类型：实际指向的对象类型（如Circle）
动态绑定：JVM 在运行时根据对象实际类型调用方法
注意:多态是方法的多态，属性没有多态性。

3. 多态的优势与局限

优势：提高代码扩展性（新增子类无需修改调用逻辑）

// 统一接口处理不同对象（扩展性极佳）
public void drawAll(Shape[] shapes) {for (Shape s : shapes) {s.draw(); // 多态调用，无需关心具体子类}
}

局限：无法调用子类特有方法（需向下转型）

4. 本节狂神说笔记

package com.oop.demo06;public class Person {public void run(){System.out.println("run");}
}
/*
多态注意事项:
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系  类型转换异常! ClassCastException!
3.存在条件: 继承关系， 方法需要重写， 父类引用指向子类对象! Father f1 = new Son();没办法重写的1.static 方法，属于类，它不属于实例2.final 常量;3.private方法:*/

package com.oop.demo06;public class Student extends Person{@Overridepublic void run() {System.out.println("sound");}public void eat(){System.out.println("eat");}
}

package com.oop;import com.oop.demo06.Person;
import com.oop.demo06.Student;public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的//new Person();//new Student();//可以指向的引用类型就不确定了：父类的引用指向子类//Student 子类型，能调用的方法都是自己的或者继承父类的！Student s1 = new Student();//Person 父类型，可以指向子类，但是不能调用子类独有的方法Person s2 = new Student();Object s3 = new Student();s2.run();//子类重写了父类的方法，执行子类的方法s1.run();//能调哪些方法，是引用决定的，具体要执行哪个类的方法，是引用指向的对象决定的//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!s2.eat();s1.eat();}
}

六、类型转换与 instanceof：多态的补充

1. 向上转型 vs 向下转型

向上转型（自动）：子类→父类（安全，子类是特殊的父类）

Shape shape = new Circle();// 自动转型，无需强制转换

向下转型（强制）：父类→子类（需确保实际类型匹配）

Circle circle = (Circle) shape; // 强制转型，需先用instanceof校验

2. instanceof 关键字

作用：判断对象是否是某个类（或子类）的实例

if (shape instanceof Circle) { // 先校验再转型Circle circle = (Circle) shape;circle.setRadius(5); // 调用子类特有方法
} else {System.out.println("转型失败，非Circle对象");
}

最佳实践：转型前必须使用 instanceof 校验，避免ClassCastException

3.本节狂神说笔记

public class Application {public static void main(String[] args) {//Object > Person > Student//Object > Person > Teacher//Object > StringObject object = new Student();//System.out.println(X instanceof Y);  能不能编译通过取决于X是否与Y有继承关系，且类X是实例x的引用类型//简单点说，如果是父子关系，那就是true;是兄弟关系就是false;毫无关系就是“编译报错”System.out.println(object instanceof Student); //trueSystem.out.println(object instanceof Person); //trueSystem.out.println(object instanceof Object); //trueSystem.out.println(object instanceof Teacher); //FalseSystem.out.println(object instanceof String); //FalseSystem.out.println("=================================");Person person = new Student();System.out.println(person instanceof Student); //trueSystem.out.println(person instanceof Person); //trueSystem.out.println(person instanceof Object); //trueSystem.out.println(person instanceof Teacher); //False//System.out.println(person instanceof String); // 编译报错！System.out.println("=================================");Student student = new Student();System.out.println(student instanceof Student); //trueSystem.out.println(student instanceof Person); //trueSystem.out.println(student instanceof Object); //true//System.out.println(student instanceof Teacher); // 编译报错！//System.out.println(student instanceof String);  // 编译报错！}
}

public class Application {public static void main(String[] args) {//类型之间的转化：  父  子//高                     低Person obj = new Student();//student将这个对象转换为student类型，我们就可以使用student类型的方法了!((Student)obj).go();//        Student student = (Student) obj;                    student.go();//子类转换为父类，可能丢失自己的本来的一些方法!低（子）转高（父）时，由于子已经继承了父的所有，所以删去属于自己的后自然而然就可以转化问父类的；而父想要转子，则需要重新开辟只属于子的空间，则需用强制转换Student student = new student();student.go();Person person =student;}
}

七、static 关键字：类级别的修饰符

1. static 修饰成员的特性

静态变量：
- 属于类而非对象，所有实例共享（建议通过类名访问ClassName.var）
- 示例：计数器public static int count = 0;
```
public class Counter {public static int count = 0; // 静态计数器
}
```
静态方法：
- 不能直接访问实例成员（无this对象）
- 常用于工具类（如Math.sqrt()、Arrays.sort()）
```
public static int add(int a, int b) {return a + b; // 无this引用
}
```

静态代码块：

类加载时执行，用于初始化静态资源（早于构造器执行）

static {System.out.println("静态代码块执行，初始化配置文件..."); // 早于构造器执行
}

2. 静态成员内存模型

静态变量和方法存储在方法区，属于类级内存
实例成员存储在堆内存，属于对象级内存
访问方式：无需创建对象，直接通过类名调用（如Utils.add(1, 2)）

3. 本节狂神说笔记

package com.oop.demo07;public final class Person {//通过final修饰的类就不能被继承了⚠️//2：赋初值~{System.out.println("匿名代码块");}//1：只执行一次~static {System.out.println("静态代码块");}//3public Person() {System.out.println("构造方法");}public static void main(String[] args) {Person person = new Person();System.out.println("================================");Person person1 = new Person();}
}

package com.oop.demo07;//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;public class Test {public static void main(String[] args) {System.out.println(random());System.out.println(PI);}
}

八、抽象类和接口

1. 抽象类

抽象类是用abstract关键字修饰的类，它可以包含抽象方法和非抽象方法。抽象方法是只有方法声明，没有方法体的方法，必须在子类中实现。例如：

//abstract 抽象类：类 extends：  单继承~   Java的类是单继承的，但接口可以多继承
abstract class Shape {//abstract ，抽象方法，只有方法名字，没有方法的实现public abstract double area();
}
//约束就是子类继承他必须实现他的方法，如果不想实现，那子类也必须是抽象类
//抽象类的所有方法，继承了他的子类，都必须要实现它的方法，除非子类也是abstract
class Circle extends Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double area() {return Math.PI * radius * radius;}
}

抽象类不能被实例化，只能作为父类被继承。

抽象类的特点

1.不能new这个抽象类，只能靠子类去实现它；约束！

2.抽象类中可以写普通方法

3.抽象方法必须在抽象类中~

抽象的抽象：约束~ 抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类

2. 接口

接口是一种特殊的抽象类，它只包含抽象方法和常量。接口不能被实例化_{，接口中没有构造方法}在 Java 中，使用interface关键字定义接口。例如：

interface Flyable {//interface定义的关键字，接口都需要有实现类void fly();    //接口中的所有定义其实都是抽象的，默认以已经有了public abstract，所以可以直接写void()
}
//抽象类 extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法//侧面实现多继承~利用接口
//必须要重写接口中的方法
class Bird implements Flyable {@Overridepublic void fly() {System.out.println("鸟儿在飞翔。");}
}

一个类可以实现多个接口，通过implements关键字，implements可以实现多个接口。接口的作用是定义一组规范，让实现类去实现这些规范。

3 抽象类和接口的区别

抽象类可以有构造器、非抽象方法和成员变量，而接口只能有常量和抽象方法。
一个类只能继承一个抽象类，但可以实现多个接口。

九、高频面试题解析

1 封装的作用是什么？如何实现封装？

封装的作用是保护数据的安全性和提高代码的可维护性。通过使用访问修饰符（如private）将属性隐藏起来，提供getter和setter方法来控制属性的访问和修改。

2 继承和组合的区别是什么？

继承是一种 “is - a” 关系，子类是父类的一种特殊类型；组合是一种 “has - a” 关系，一个类包含另一个类的对象。继承会导致子类和父类的耦合度较高，而组合的耦合度相对较低，更符合开闭原则。

3 多态的实现方式有哪些？

多态的实现方式主要有方法重载和方法重写。方法重载是在同一个类中，根据参数列表的不同定义多个同名方法；方法重写是在子类中重写父类的方法。另外，通过父类引用指向子类对象，也能实现运行时多态。

4 抽象类和接口的应用场景分别是什么？

抽象类适用于有部分公共实现，同时又需要子类实现特定功能的情况；接口适用于定义一组规范，让不同的类去实现这些规范，强调行为的一致性。

5 为什么 Java 不支持多继承？

Java 不支持多继承主要是为了避免菱形继承问题（钻石问题），即当一个子类继承多个父类，而这些父类有相同的方法时，会导致调用方法的歧义。

6 static 方法为什么不能重写？

静态方法属于类级别，重写针对实例方法
子类定义同名静态方法是隐藏父类方法（非重写），调用时根据变量编译类型决定

十、面向对象核心脉络总结

面向对象三大特性：
├─ 封装：数据隐藏，访问控制（private/public）
├─ 继承：代码复用，is-a关系（extends关键字）
└─ 多态：动态绑定，父类引用子类对象（重写+转型）辅助关键字：
├─ super：访问父类成员，调用父类构造器
├─ static：类级成员，无需对象即可访问
└─ instanceof：安全向下转型的前提

通过合理运用封装、继承、多态与 static 关键字，可构建出高内聚、低耦合的面向对象系统。在实际开发中，需根据场景选择合适的设计策略：

数据保护优先使用封装
代码复用优先考虑继承（或组合）
接口统一优先利用多态
全局共享逻辑使用 static 修饰

面向对象编程核心：封装、继承、多态与 static 关键字深度解析