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

m0Java门徒2025-04-26 11:10

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

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

1. 封装的本质与作用

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

  • 三大优势：

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

// 统一接口：通过公共方法控制访问逻辑
public void setPassword(String pwd) {
    if (pwd.length() >= 6) this.password = pwd;
}

  • 访问修饰符：

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

2. 封装最佳实践

属性私有，get/set

java 复制代码 
// 推荐：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;
        }
    }
}
java 复制代码 
狂神说课堂笔记
    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;
        }
    }
}
java 复制代码 
狂神说课堂笔记
    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"的关系.

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

    java 复制代码 
    // 父类
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()）

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

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

    java 复制代码 
    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 的三大核心用法

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

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

    访问父类版本

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

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

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

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

    java 复制代码 
    public Child() {
    super("参数"); // 调用父类有参构造
}

2. Super vs This

关键字 指代对象 调用构造器时机 访问范围
super 父类对象 子类构造器第一行 父类成员
this 当前对象 本类构造器第一行 本类成员
plaintext 复制代码 
super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中!
    3.super和 this 不能同时调用构造方法!

VS this：
    代表的对象不同:
        this:本身调用者这个对象
        super:代表父类对象的应用
    前提
        this:没有继承也可以使用
        super:只能在继承条件才可以使用
    构造方法
        this();本类的构造
        super():父类的构造!

3. 本节狂神说笔记

java 复制代码 
Application.java
    
package 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();
    }
}
java 复制代码 
Person.java
    
package 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");
    }
}
java 复制代码 
Student.java
    
package 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();//Student
        this.print();//Student
        super.print();//Person
    }
    public void test(String name){
        System.out.println(name);//秦疆
        System.out.println(this.name);//qinjiang
        System.out.println(super.name);//kuangshen
    }
}

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

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

  • 三同原则：方法名、参数列表、返回类型必须相同（返回类型可协变，如子类返回父类返回类型的子类型）

  • 访问修饰符 ：子类方法不能比父类更严格（父类protected，子类可以是public）

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

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

2. 本节狂神说笔记

java 复制代码 
Application.java
    
package 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
    }
}
java 复制代码 
A.java
    
package com.oop.demo05;
//继承
public class A extends B {
    //Override 重写
    @Override//注解：有功能的注释
    public void test() {
        System.out.println("A=>text()");
    }
}
java 复制代码 
B.java
    
package com.oop.demo05;
//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>text()");
    }
}
plaintext 复制代码 
重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同，否则就变成重载了
    3.修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
    4.抛出的异常:范围，可以被缩小，但不能扩大;ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必要一致;方法体不同!

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足!
    Alt + Insert ;override;

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

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

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

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

1. 多态的三大要素

java 复制代码 
// 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. 多态的优势与局限

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

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

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

4. 本节狂神说笔记

java 复制代码 
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方法:
 */
java 复制代码 
package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("sound");
    }
    public void eat(){
        System.out.println("eat");
    }
}
java 复制代码 
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 向下转型

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

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

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

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

2. instanceof 关键字

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

java 复制代码 
if (shape instanceof Circle) { // 先校验再转型
    Circle circle = (Circle) shape;
    circle.setRadius(5); // 调用子类特有方法
} else {
    System.out.println("转型失败，非Circle对象");
}
  • 最佳实践 ：转型前必须使用 instanceof 校验，避免ClassCastException

3.本节狂神说笔记

java 复制代码 
public class Application {
    public static void main(String[] args) {
        //Object > Person > Student
        //Object > Person > Teacher
        //Object > String
        Object object = new Student();

        //System.out.println(X instanceof Y);  能不能编译通过取决于X是否与Y有继承关系，且类X是实例x的引用类型

        //简单点说，如果是父子关系，那就是true;是兄弟关系就是false;毫无关系就是"编译报错"
        System.out.println(object instanceof Student); //true
        System.out.println(object instanceof Person); //true
        System.out.println(object instanceof Object); //true
        System.out.println(object instanceof Teacher); //False
        System.out.println(object instanceof String); //False
        System.out.println("=================================");
        Person person = new Student();
        System.out.println(person instanceof Student); //true
        System.out.println(person instanceof Person); //true
        System.out.println(person instanceof Object); //true
        System.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); //true
        System.out.println(student instanceof Person); //true
        System.out.println(student instanceof Object); //true
        //System.out.println(student instanceof Teacher); // 编译报错！
        //System.out.println(student instanceof String);  // 编译报错！
    }
}
java 复制代码 
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;
    java 复制代码 
    public class Counter {
    public static int count = 0; // 静态计数器
}

  • 静态方法：

    • 不能直接访问实例成员（无this对象）
    • 常用于工具类（如Math.sqrt()、Arrays.sort()）
    java 复制代码 
    public static int add(int a, int b) {
    return a + b; // 无this引用
}

  • 静态代码块：

    • 类加载时执行，用于初始化静态资源（早于构造器执行）
    java 复制代码 
    static {
    System.out.println("静态代码块执行，初始化配置文件..."); // 早于构造器执行
}

2. 静态成员内存模型

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

3. 本节狂神说笔记

java 复制代码 
package com.oop.demo07;

public final class Person {//通过final修饰的类就不能被继承了⚠️
    //2：赋初值~
    {
        System.out.println("匿名代码块");
    }
    //1：只执行一次~
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("================================");
        Person person1 = new Person();
    }
}
java 复制代码 
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关键字修饰的类，它可以包含抽象方法和非抽象方法。抽象方法是只有方法声明，没有方法体的方法，必须在子类中实现。例如：

java 复制代码 
//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;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

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

抽象类的特点

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

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

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

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

2. 接口

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

java 复制代码 
interface Flyable {//interface定义的关键字，接口都需要有实现类
    void fly();    //接口中的所有定义其实都是抽象的，默认以已经有了public abstract，所以可以直接写void()
}
//抽象类 extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法

//侧面实现多继承~利用接口
//必须要重写接口中的方法
class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在飞翔。");
    }
}

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

3 抽象类和接口的区别

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

九、高频面试题解析

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

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

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

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

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

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

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

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

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

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

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

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

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

plaintext 复制代码 
面向对象三大特性：
├─ 封装：数据隐藏，访问控制（private/public）
├─ 继承：代码复用，is-a关系（extends关键字）
└─ 多态：动态绑定，父类引用子类对象（重写+转型）

辅助关键字：
├─ super：访问父类成员，调用父类构造器
├─ static：类级成员，无需对象即可访问
└─ instanceof：安全向下转型的前提

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

  • 数据保护优先使用封装
  • 代码复用优先考虑继承（或组合）
  • 接口统一优先利用多态
  • 全局共享逻辑使用 static 修饰
相关推荐
夏婵语冰1 小时前
实用R语言机器学习指南：从数据预处理到模型实战（附配套学习资源）
开发语言·学习·r语言
cyforkk2 小时前
ArrayList vs LinkedList：底层原理与实战选择指南
java
孟婆来包棒棒糖～4 小时前
泛型与反射
java·反射·javase·泛型
牛角上的男孩4 小时前
apt update Ign and 404 Not Found
开发语言·数据库
A尘埃4 小时前
Spring Event 企业级应用
java·spring·event
我一定会有钱4 小时前
Linux爆音问题解决方法（隔一会会有奇怪噪音）
linux·运维·服务器
yzzzzzzzzzzzzzzzzz5 小时前
JavaScript 操作 DOM
开发语言·javascript·ecmascript
海绵宝宝汉堡包6 小时前
c# 项目 文件夹
开发语言·c#
YuTaoShao6 小时前
【LeetCode 热题 100】139. 单词拆分——（解法一）记忆化搜索
java·算法·leetcode·职场和发展
Best_Liu~6 小时前
策略模式 vs 适配器模式
java·spring boot·适配器模式·策略模式
热门推荐
01UV安装并设置国内源02【踩坑笔记】50系显卡适配的 PyTorch 安装03KGG转MP3工具|非KGM文件|解密音频04Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06Claude Code VSCode集成开发指南：AI编程助手完整配置07【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）082025最新国内服务器可用docker源仓库地址大全（2025年8月更新）0920个国内外主流AI绘画工具大汇总（最新免费可用~）10DeepSeek更新！速览DeepSeek V3.1新特性