面向对象编程核心：封装、继承、多态与 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 修饰
相关推荐
Lalolander6 分钟前
设备制造行业如何避免项目管理混乱？
运维·制造·工程项目管理·四算一控·epc·环保设备工程·设备制造
LucianaiB25 分钟前
【金仓数据库征文】_AI 赋能数据库运维：金仓KES的智能化未来
运维·数据库·人工智能·金仓数据库 2025 征文·数据库平替用金仓
24k小善29 分钟前
Flink TaskManager详解
java·大数据·flink·云计算
杜小暑33 分钟前
动态内存管理
c语言·开发语言·动态内存管理
想不明白的过度思考者35 分钟前
Java从入门到“放弃”（精通）之旅——JavaSE终篇（异常）
java·开发语言
prinrf('千寻)40 分钟前
nacos设置权重进行负载均衡不生效
运维·负载均衡
Lary_Rock1 小时前
Android 编译问题 prebuilts/clang/host/linux-x86
android·linux·运维
我真的不会C1 小时前
QT窗口相关控件及其属性
开发语言·qt
CodeCraft Studio1 小时前
Excel处理控件Aspose.Cells教程：使用 Python 在 Excel 中进行数据验
开发语言·python·excel
.生产的驴1 小时前
SpringBoot 封装统一API返回格式对象 标准化开发 请求封装 统一格式处理
java·数据库·spring boot·后端·spring·eclipse·maven
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10【2025年最新】OpenWrt 更换国内源的指南（图形界面版)