Java OOP三大特征之封装继承与多态详解

更新时间：2022年07月25日 08:55:49 作者：陈亦康

本文主要讲述的是面向对象的三大特性：封装，继承，多态，内容含括从封装到继承再到多态的所有重点内容以及使用细节和注意事项，内容有点长，请大家耐心看完

封装

官话：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口进行交互

通俗讲，不让类外看到实现的细节，通过技术手段对这些细节包装一个外壳，同时提供几个公开的接口，让你进行交互即可（例如：手机，内部的具体零件，不会让你观察到，使用者只能看到外壳，通过外壳的显示屏，充电口进行交互）简而言之——套壳屏蔽细节

实际上通过private来实现

例如：

继承

面向对象的思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

通俗来讲，就是将两个或多个类（“子类”或者叫“派生类”）的共同的特点抽取出来，放在一个类（“父类”或叫“基类”或叫“超类”）里面，对具有共同特点的代码实现重复利用，大大的减少了代码量。

例如：人与人之间具有相同的属性（都有名字，年龄...），但同时也有不一样的地方(每个人具体的特点，有人会弹钢琴...)

父与子的继承顺序：

故名思意，肯定是先有父后有子，所以在子类构造对象时，他们的初始化顺序是先完成父类的初始化，再调用子类的构造方法，{ super()将父类初始化好的内存地址传入 }，最后完成子类初始化。

super关键字:

1.super.data访问父类中的属性

2.super.func() 访问父类的方法

3.super() 访问父类的构造方法

注意：

this()用来调用本类的构造方法，super()用于调用父类的构造方法，这两不能同时出现！

父类与子类同名时，在子类调用同名变量时采用就近原则（调用子类）

当你未给子类提供构造方法时(或者是父类有不带参数的构造方法，子类也有构造方法，会自动给子类补上super)，编译器会自动补上一个不带参数的构造方法（前提是，父类的构造方法中不带参数，因为编译器只会自动不上不带参数的构造方法），如下：

class A{
    A(){
        System.out.println("A");
    }
}
class B extends A{
    B(){
        super();//如果程序原没写构造方法，编译器会自己提供一个这样的不带参数的构造方法
    }
}
public class Test{
    public static void main(String[] args){
        new B();
    }
}

class A{
    A(){
        System.out.print("A");
    }
}
class B extends A{
    B(){  //程序会自动补上super,最终打印AB
        System.out.print("B");
    }
}
public class Test{
    public static void main(String[] args){
        new B();
    }
}

class A{
    A(int a){
        System.out.println("A");
    }
}
class B extends A{
    //若父类构造方法带参数，子类不会自动补构造方法
    //程序编译失败
}
public class Test{
    public static void main(String[] args){
        new B();
    }
}

经典笔试题：以下代码会打印什么？（初始化顺序是什么？）

class Character{
    public int data1;
    public int data2;
    static{
     System.out.println("父类的静态内部类初始化完成！");
    }
    {
        System.out.println("父类的实例内部类初始化完成！");
    }
    public Character(){
        System.out.println("父类的构造方法初始化完成！");
    }
}
class Art extends Character{
    public int data3;
    public int data4;
    static{
        System.out.println("子类的静态内部类初始化完成！");
    }
    {
        System.out.println("子类的实例内部类初始化完成！");
    }
    public Art(){
        super();
        System.out.println("子类的构造方法初始化完成！");
    }
}
public class Test{
    public static void main(String[] args){
        Art art = new Art();
    }
}

运行结果：

分析：

多态

通俗来讲就是：不同人的通过同一种工具可以做出不同的事情

例如：一个音乐生和一个美术生看到一架钢琴的反应是不同的，音乐生可能会上去弹钢琴，而美术生则可能将他画下来...

实现多态的条件：

在父子的继承关系下；
子对父进行重写；
用一个方法调用父类被重写的方法；

代码如下：

//人类
class Human{
    private String name;
    Human(String name){
        setName(name);
    }
    public void action(){
        System.out.println(name + "看到一架钢琴~");
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}
//美术生
class Art extends Human{
    Art(String name){
        super(name);
    }
    public void action(){
        System.out.println(getName() + "开始绘画钢琴~");
    }
}
//音乐生
class Music extends Human{
    Music(String name){
        super(name);
    }
    public void action(){
        System.out.println(getName() + "开始弹钢琴~");
    }
}
public class Test{
    public static void function(Human human){
        human.action();
    }
    public static void main(String[] args){
        Human human1 = new Art("美术生");
        Human human2 = new Music("音乐生");
        function(human1);
        function(human2);
    }
}

分析：

发生重写的条件：

方法名相同；
返回类型相同；
形参类列表相同（个数、顺序、类型都要一致！）；
static 和 private 修饰的方法不能重写；
子类访问修饰符必须大于等于父类访问修饰符（后面会出文章专门讨论）；

此时会发生动态绑定（运行时绑定），其实此过程编译的时候还是调用父类的，但运行时发生动态绑定，运行子类的；也就是说，父类引用了子类的对象，调用了这个重写的方法，如下图：

拓展：

向下转型，也有，也就是子类当父类用也可，但是比较危险，如下代码：

public class Test{
    public static void function(Human human){
        human.action();
    }
    public static void main(String[] args){
        Human human = new Human("音乐生");
        Music music = (Music)human;
    }
}

运行结果：

可以这样理解，不是所有人都是音乐生，所以需要如下改法：（有的人是音乐生）

public class Test{
    public static void function(Human human){
        human.action();
    }
    public static void main(String[] args){
        Human human = new Music("音乐生");//这样写便是有些人是音乐生
        if(human instanceof Music) {//保证安全性，向下转型
            Music music = (Music) human;
        };
    }
}

到此这篇关于Java OOP三大特征之封装继承与多态详解的文章就介绍到这了,更多相关Java 封装继承多态内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Go Java算法重复的DNA序列详解
这篇文章主要为大家介绍了Go Java算法之重复的DNA序列的示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-08-08
SpringBoot接收参数的8种方式示例详解
这篇文章主要介绍了SpringBoot接收参数的8种方式,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2023-08-08
Spring Boot利用@Async如何实现异步调用：自定义线程池
这篇文章主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
2018-05-05
浅谈MyBatis-plus入门使用
这几天本人了解到了MyBatis-plus,一个 Mybatis 增强工具包.经过一番研究,发现这玩意真的好用,不用写任何 xml ,内置通用的 Mapper,而且完全是面向对象编程,文档给的示例代码,跟之前用过的 sequelize (Node.js 的 ORM)非常像,因此本人也尝试了一把, 需要的朋友可以参考下
2021-05-05
Java使用Redis实现秒杀功能
这篇文章主要为大家详细介绍了Java使用Redis实现秒杀功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2020-09-09
浅谈一下单体架构的缺点是什么
这篇文章主要介绍了单体架构的缺点是什么,通常我们所使用的传统单体应用架构都是模块化的设计逻辑，程序在编写完成后会被打包并部署为一个具体的应用，而应用的格式则依赖于相应的应用语言和框架,需要的朋友可以参考下
2023-04-04
Java内存泄漏问题排查与解决
大家好，本篇文章主要讲的是Java内存泄漏问题排查与解决，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下
2022-01-01
Java Lambda表达式之从集合到流
这篇文章主要介绍了Java Lambda表达式之从集合到流知识，非常不错，具有参考借鉴价值，需要的朋友可以参考下
2017-02-02
浅析java中print和println的区别
以下是对java中print和println的区别进行了详细的分析介绍，需要的朋友可以过来参考下
2013-08-08
迪米特法则_动力节点Java学院整理
这篇文章主要介绍了迪米特法则，迪米特法则就是一个在类创建方法和属性时需要遵守的法则，有兴趣的可以了解一下
2017-08-08

Java OOP三大特征之封装继承与多态详解

目录

封装

继承

多态

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具