字符串常量池(StringTable)总结

目录

一、String的基本特性

二、String的不可变性

三、String的内存分配

四、String的基本操作

五、intern()的使用

六、常见面试题


一、String的基本特性

  • String:字符串,使用一对""引起来表示。
    • String s1 = "mogublog" ;    // 字面量的定义方式
    • String s2 = new String("abc");
  • String声明为final的,不可被继承
  • String实现了Serializable接口:表示字符串是支持序列化的。实现了Comparable接口:表示String可以比较大小;
  • String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[];

为什么JDK9改变了结构?

String类的当前实现将字符存储在char数组中,每个字符使用两个字节(16位)。从许多不同的应用程序收集的数据表明,字符串是堆使用的主要组成部分,而且,大多数字符串对象只包含拉丁字符,这些字符只需要一个字节的存储空间,因此这些字符串对象的内部char数组中有一半的空间将不会使用。

我们建议改变字符串的内部表示class从utf - 16字符数组到【字节数组 + 一个encoding-flag字段】。新的String类将根据字符串的内容存储编码为ISO-8859-1/Latin-1(每个字符一个字节)或UTF-16(每个字符两个字节)的字符。编码标志将指示使用哪种编码。

结论:String再也不用char[] 来存储了,改成了byte [] 加上编码标记,节约了一些空间。

// 之前
private final char value[];
// 之后
private final byte[] value

同时基于String的数据结构,例如StringBuffer和StringBuilder也同样做了修改。

二、String的不可变性

String:代表不可变的字符序列。简称:不可变性。

当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。 当调用String的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。 通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池中。

下面通过代码演示String的不可变性:

public class StringTest01 {
    private static void test1() {
        // 字面量定义的方式,“abc”存储在字符串常量池中
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);  //true
        s1 = "hello";
        System.out.println(s1 == s2);  //false
        System.out.println(s1);        //hello
        System.out.println(s2);        //abc
        System.out.println("----------------");
    }

    private static void test2() {
        String s1 = "abc";
        String s2 = "abc";
        // 只要进行了修改,就会重新创建一个对象,这就是不可变性
        s2 += "def";
        System.out.println(s1);        //abc
        System.out.println(s2);        //abcdef
        System.out.println("----------------");
    }

    private static void test3() {
        String s1 = "abc";
        String s2 = s1.replace('a', 'm');
        System.out.println(s1);       //abc
        System.out.println(s2);       //mbc
    }

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }

}

运行结果:

true
false
hello
abc
----------------
abc
abcdef
----------------
abc
mbc

通过上面的示例,我们应该了解了String的不可变性,下面我们再通过一道常见的面试题来加强对String不可变性的理解。

public class StringTest02 {
    String str = new String("good");
    char[] ch = {'t', 'e', 's', 't'};

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest02 stringTest02 = new StringTest02();
        stringTest02.change(stringTest02.str, stringTest02.ch);
        System.out.println(stringTest02.str); //good
        System.out.println(stringTest02.ch);  //best
    }
}

运行结果:

good
best

我们需要注意,字符串常量池是不会存储相同内容的字符串的。

String的string Pool是一个固定大小的Hashtable,默认值大小长度是1009。如果放进string Pool的string非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用string.intern时性能会大幅下降。

我们可以使用-XX:StringTablesize可设置stringTable的长度。

在jdk6中stringTable是固定的,就是1009的长度,所以如果常量池中的字符串过多就会导致效率下降很快。

在jdk7中,stringTable的长度默认值是60013,在JDK8中,StringTable可以设置的最小值为1009。

三、String的内存分配

在Java语言中有8种基本数据类型和一种比较特殊的类型string。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。

常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的,string类型的常量池比较特殊。它的主要使用方法有两种:

(一)、直接使用双引号声明出来的String对象会直接存储在常量池中。

  • 比如:String info= "abcd";

(二)、如果不是用双引号声明的String对象,可以使用String提供的intern()方法。

  • Java 6及以前,字符串常量池存放在永久代;
  • Java 7将字符串常量池的位置调整到Java堆内,所有的字符串都保存在堆(Heap)中,和其他普通对象一样,这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
  • Java8元空间,字符串常量还是在堆空间;

为什么StringTable从永久代调整到堆中?

在JDK 7中,interned字符串不再在Java堆的永久代中分配,而是在Java堆的主要部分(称为年轻代和年老代)中分配,与应用程序创建的其他对象一起分配。此更改将导致驻留在主Java堆中的数据更多,驻留在永久生成中的数据更少,因此可能需要调整堆大小。由于这一变化,大多数应用程序在堆使用方面只会看到相对较小的差异,但加载许多类或大量使用字符串的较大应用程序会出现这种差异。主要是下面两个原因:

  • 永久代的空间默认比较小,而且使用参数不好动态设置其大小;
  • 永久代的垃圾回收频率低,导致大量不使用的string字符串常量无法回收;

四、String的基本操作

Java语言规范里要求完全相同的字符串字面量,应该包含同样的Unicode字符序列(包含同一份码点序列的常量),并且必须是指向同一个String类实例。

(一)、字符串拼接操作

  • 常量与常量的拼接结果在常量池,原理是编译期优化;
  • 常量池中不会存在相同内容的变量;
  • 只要其中有一个是变量,结果就在堆中,变量拼接的原理是StringBuilder;
  • 如果拼接的结果调用intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址;

来看一个字符串拼接的例子:

public class StringTest03 {
    private static void test1() {
        String s1 = "a" + "b" + "c";  // 得到 abc的常量池
        String s2 = "abc"; // abc存放在常量池,直接将常量池的地址返回
        /**
         * 最终java编译成.class,再执行.class
         */
        System.out.println(s1 == s2);       // true,因为存放在字符串常量池
        System.out.println(s1.equals(s2));  // true
    }

    private static void test2() {
        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4); // true
        System.out.println(s3 == s5); // false
        System.out.println(s3 == s6); // false
        System.out.println(s3 == s7); // false
        System.out.println(s5 == s6); // false
        System.out.println(s5 == s7); // false
        System.out.println(s6 == s7); // false

        String s8 = s6.intern();
        System.out.println(s3 == s8); // true  由于s6拼接之后的javaEEhadoop已经在常量池中,intern将会直接返回javaEEhadoop的地址给s8
    }

    public static void main(String[] args) {
        test1();
        test2();
    }
}

从上述的结果我们可以知道:

如果拼接符号的前后出现了变量,则相当于在堆空间中new String(),具体的内容为拼接的结果;而调用intern方法,则会判断字符串常量池中是否存在JavaEEhadoop值,如果存在则返回常量池中的值,否则就在常量池中创建。

(二)、底层原理

拼接操作的底层其实使用了StringBuilder:

我们一起来看一下上述程序编译后的字节码文件:

上述程序中s1 + s2的执行细节大概如下:

  • StringBuilder s = new StringBuilder();
  • s.append(s1);
  • s.append(s2);
  • s.toString();    ->     类似于new String("ab");

在JDK5之后,使用的是StringBuilder,在JDK5之前使用的是StringBuffer。

String

StringBuffer

StringBuilder

String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间

StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量

可变类,速度更快

不可变

可变

可变

线程安全

线程不安全

多线程操作字符串

单线程操作字符串

注意,我们左右两边如果是变量的话,就是需要new StringBuilder进行拼接,但是如果使用的是final修饰,则是从常量池中获取。所以说拼接符号左右两边都是字符串常量或常量引用,则仍然使用编译器优化。也就是说被final修饰的变量,将会变成常量,类和方法将不能被继承。

  • 在开发中,能够使用final的时候,建议使用上。
public class StringTest04 {
    public static void test4() {
        final String s1 = "a";
        final String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2;
        System.out.println(s3 == s4);  //true
    }

    public static void main(String[] args) {
        test4();
    }
}

运行结果:

true

为什么是true呢?我们查看其字节码:

可以看到,如果是字符串常量的引用的话, 在编译的时候就已经拼接好了,还是使用的编译器优化,所以返回true。

(三)、拼接操作和append性能对比

public class StringTest05 {

    public static void method1(int highLevel) {
        long startTime = System.currentTimeMillis();
        String src = "";
        for (int i = 0; i < highLevel; i++) {
            src += "a"; // 每次循环都会创建一个StringBuilder对象
        }
        System.out.println("拼接操作耗时:" + (System.currentTimeMillis() - startTime));
    }

    public static void method2(int highLevel) {
        long startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            sb.append("a");
        }
        System.out.println("append拼接操作耗时:" + (System.currentTimeMillis() - startTime));
    }

    public static void main(String[] args) {
        method1(100000);
        System.out.println("============");
        method2(100000);
    }
}

运行结果:

拼接操作耗时:7656
============
append拼接操作耗时:8

可见,方法1耗费的时间:7656ms,方法2消耗时间:8ms。

结论:

  • 通过StringBuilder的append()方式添加字符串的效率,要远远高于String的字符串拼接方法。

好处:

  • StringBuilder的append的方式,自始至终只创建一个StringBuilder的对象;
  • 对于字符串拼接的方式,还需要创建很多StringBuilder对象和调用toString时候创建的String对象;
  • 内存中由于创建了较多的StringBuilder和String对象,内存占用过大,如果进行GC那么将会耗费更多的时间;

改进的空间:

  • 我们使用的是StringBuilder的空参构造器,默认的字符串容量是16,然后将原来的字符串拷贝到新的字符串中, 我们也可以默认初始化更大的长度,减少扩容的次数;
  • 因此在实际开发中,我们能够确定,前前后后需要添加的字符串不高于某个限定值,那么建议使用构造器创建一个阈值的长度;

五、intern()的使用

intern()是一个native方法,调用的是底层C的方法。

在调用intern方法时,如果常量池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串,则返回池中的字符串。否则,该字符串对象将被添加到池中,并返回对该字符串对象的引用。

如果不是用双引号声明的string对象,可以使用string提供的intern方法:intern方法会从字符串常量池中查询当前字符串是否存在,若不存在就会将当前字符串放入常量池中。比如:

String myInfo = new string("abc").intern();

也就是说,如果在任意字符串上调用string.intern方法,那么其返回结果所指向的那个类实例,必须和直接以常量形式出现的字符串实例完全相同。因此,下列表达式的值必定是true:

("a"+"b"+"c").intern()== "abc" =======> true

通俗点讲,Interned string就是确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池(String Intern Pool)。

结论:对于程序中大量使用存在的字符串时,尤其存在很多已经重复的字符串时,使用intern()方法能够节省内存空间。

六、常见面试题

(一)、new String("ab")会创建几个对象

public class StringTest06 {
    public static void main(String[] args) {
        String str = new String("ab");
    }
}

我们查看上述程序的字节码:

0 new #2 <java/lang/String>    //第一个对象:new关键字在堆空间中创建;
 3 dup
 4 ldc #3 <ab>                 //第二个对象:字符串常量池中的对象;
 6 invokespecial #4 <java/lang/String.<init>>      
 9 astore_1
10 return

可以看到,由字节码可知创建了2个对象。

  • 一个对象是:new关键字在堆空间中创建;
  • 另一个对象:字符串常量池中的对象;

(二)、new String("a") + new String("b") 会创建几个对象

public class StringTest07 {
    public static void main(String[] args) {
        String str = new String("a") + new String("b");
    }
}

我们查看上述程序的字节码:

0 new #2 <java/lang/StringBuilder>        //第一个对象:new StringBuilder()
 3 dup
 4 invokespecial #3 <java/lang/StringBuilder.<init>>
 7 new #4 <java/lang/String>      //第二个对象:new String("a")
10 dup
11 ldc #5 <a>     //第三个对象:常量池的"a"
13 invokespecial #6 <java/lang/String.<init>>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>     //第四个对象:new String("b")
22 dup
23 ldc #8 <b>        //第五个对象:常量池的 "b"
25 invokespecial #6 <java/lang/String.<init>>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return

由字节码可知,一共创建了5个对象:

  • 对象1:new StringBuilder()
  • 对象2:new String("a")
  • 对象3:常量池"a"
  • 对象4:new String("b")
  • 对象5:常量池的 "b"

但是如果更严谨一点来说,应该是6个对象,原因是StringBuilder.toString()方法内部是通过new String()也创建了一个对象。

//java.lang.StringBuilder#toString
public String toString() {
    return new String(value, 0, count);
}

一共创建了6个对象:

  • 对象1:new StringBuilder()
  • 对象2:new String("a")
  • 对象3:常量池的 a
  • 对象4:new String("b")
  • 对象5:常量池的 b
  • 对象6:toString中会创建一个 new String("ab")
    • 调用toString方法,不会在常量池中生成"ab"常量。

(三)、面试题拓展

来看下面一段程序,下面的程序在不同的JDK版本中,运行结果有点区别。

首先我们来看下在JDK6中:

String s = new String("1");  // 在常量池中已经有了
s.intern(); // 将该对象放入到常量池。但是调用此方法没有太多的区别,因为已经存在了1
String s2 = "1";
System.out.println(s == s2); //jdk6: false

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); //jdk6: false

解释:

a、s的地址指向的是堆空间中new String("1")对象的地址,而s2的地址指向的是常量池中"1"的地址,很显然,两个的地址不同,所以s == s2返回false。

b、s3的地址指向的是堆空间new String("11")对象的地址,执行完【new String("1") + new String("1")】之后,字符串常量池不会存在"11"字符串。然后调用s3.intern();这时候将会在常量池中保存"11"常量,s4指向的地址是前面intern方法放在常量池中"11"的地址,很显然,s3的地址和s4的地址不同,所以s3 == s4返回false。

然后我们再看下在JDK7/8中的运行结果:

String s = new String("1");  // 在常量池中已经有了
s.intern(); // 将该对象放入到常量池。但是调用此方法没有太多的区别,因为已经存在了1
String s2 = "1";
System.out.println(s == s2); //jdk6: false     jdk7/8:false

String s3 = new String("1") + new String("1");
//jdk6中,intern方法就创建了一个新的"11"常量,也就有新的地址;
//jdk7/8中,intern方法会先检查堆空间中是否已经创建了"11"字符串,而刚好上一行代码就创建了
//"11"字符串,所以这时候常量池中的对象,它的地址其实记录的是堆空间中创建的"11"的地址。
s3.intern();  
String s4 = "11";
System.out.println(s3 == s4); //jdk6: false     jdk7/8:true

解释:

a、同jdk6,s的地址指向的是堆空间中new String("1")对象的地址,而s2的地址指向的是常量池中"1"的地址,很显然,两个的地址不同,所以s == s2返回false。

b、s3的地址指向的是堆空间new String("11")对象的地址,执行完【new String("1") + new String("1")】之后,字符串常量池不会存在"11"字符串。然后调用s3.intern();注意了,在jdk7/8以后,字符串常量池放在堆空间了,intern方法会先检查堆空间中是否已经创建了"11"字符串,而刚好前面一行代码【new String("1") + new String("1")】就创建了"11"字符串,所以这时候常量池中的对象,它的地址其实记录的是堆空间中创建的"11"的地址,s4指向的地址是常量池中"11"的地址,很显然,s3的地址和s4的地址相同,所以s3 == s4返回true。

简单画了个图,帮助理解一下:

理解了上面的那个例子,我们再来看一下下面的例子:

public class StringTest09 {
    public static void main(String[] args) {
        String s3 = new String("1") + new String("1");
        String s4 = "11";  // 在常量池中生成的字符串
        s3.intern();  // 然后s3就会从常量池中找,发现有了,就什么事情都不做
        System.out.println(s3 == s4);  //false
    }
}

解释:

a、String s3 = new String("1") + new String("1");执行完后常量池中不会存在"11"字符串常量,然后执行String s4 = "11",这时候在常量池中生成"11"字符串,然后执行s3.intern(),然后s3就会从常量池中找,发现有了,就什么事情都不做。即s3执行的是堆空间中new出来的对象的地址,s4指向的是常量池"11"的地址,两者地址不同,所以s3 == s4,返回false。

简单做个总结:String的intern()的使用:

JDK1.6中,将这个字符串对象尝试放入常量池中:

  • 如果常量池中有,则并不会放入。返回已有的常量池中的对象的地址;
  • 如果没有,会把此对象复制一份,放入常量池中,并返回常量池中的对象地址;

JDK1.7起,将这个字符串对象尝试放入常量池中:

  • 如果常量池中有,则并不会放入。返回已有的常量池中的对象的地址;
  • 如果没有,则会把对象的引用地址复制一份,放入常量池中,并返回常量池中的引用地址;

热门文章

暂无图片
编程学习 ·

exe4j详细使用教程(附下载安装链接)

一、exe4j介绍 ​ exe4j是一个帮助你集成Java应用程序到Windows操作环境的java可执行文件生成工具&#xff0c;无论这些应用是用于服务器&#xff0c;还是图形用户界面&#xff08;GUI&#xff09;或命令行的应用程序。如果你想在任务管理器中及Windows XP分组的用户友好任务栏…
暂无图片
编程学习 ·

AUTOSAR从入门到精通100讲(126)-浅谈车载充电系统通信方案

01 引言 本文深入研究车载充电系统策略,设计出一套基于电动汽车电池管理系统与车载充电机的CAN通信协议,可供电动汽车设计人员参考借鉴。 02 电动汽车充电系统通讯网络 电动汽车整车控制系统中采用的是CAN总线通信方式,由一个整车内部高速CAN网络、内部低速CAN网络和一个充电…
暂无图片
编程学习 ·

CMake(九):生成器表达式

当运行CMake时&#xff0c;开发人员倾向于认为它是一个简单的步骤&#xff0c;需要读取项目的CMakeLists.txt文件&#xff0c;并生成相关的特定于生成器的项目文件集(例如Visual Studio解决方案和项目文件&#xff0c;Xcode项目&#xff0c;Unix Makefiles或Ninja输入文件)。然…
暂无图片
编程学习 ·

47.第十章 网络协议和管理配置 -- 网络配置(八)

4.3.3 route 命令 路由表管理命令 路由表主要构成: Destination: 目标网络ID,表示可以到达的目标网络ID,0.0.0.0/0 表示所有未知网络,又称为默认路由,优先级最低Genmask:目标网络对应的netmaskIface: 到达对应网络,应该从当前主机哪个网卡发送出来Gateway: 到达非直连的网络,…
暂无图片
编程学习 ·

元宇宙技术基础

请看图&#xff1a; 1、通过AR、VR等交互技术提升游戏的沉浸感 回顾游戏的发展历程&#xff0c;沉浸感的提升一直是技术突破的主要方向。从《愤怒的小鸟》到CSGO,游戏建模方式从2D到3D的提升使游戏中的物体呈现立体感。玩家在游戏中可以只有切换视角&#xff0c;进而提升沉浸…
暂无图片
编程学习 ·

flink的伪分布式搭建

一 flink的伪分布式搭建 1.1 执行架构图 1.Flink程序需要提交给 Job Client2.Job Client将作业提交给 Job Manager3.Job Manager负责协调资源分配和作业执行。 资源分配完成后&#xff0c;任务将提交给相应的 Task Manage。4.Task Manager启动一个线程以开始执行。Task Manage…
暂无图片
编程学习 ·

十进制正整数与二进制字符串的转换(C++)

Function one&#xff1a; //十进制数字转成二进制字符串 string Binary(int x) {string s "";while(x){if(x % 2 0) s 0 s;else s 1 s;x / 2;}return s; } Function two&#xff1a; //二进制字符串变为十进制数字 int Decimal(string s) {int num 0, …
暂无图片
编程学习 ·

[含lw+源码等]微信小程序校园辩论管理平台+后台管理系统[包运行成功]Java毕业设计计算机毕设

项目功能简介: 《微信小程序校园辩论管理平台后台管理系统》该项目含有源码、论文等资料、配套开发软件、软件安装教程、项目发布教程等 本系统包含微信小程序做的辩论管理前台和Java做的后台管理系统&#xff1a; 微信小程序——辩论管理前台涉及技术&#xff1a;WXML 和 WXS…
暂无图片
编程学习 ·

树莓派驱动DHT11温湿度传感器

1&#xff0c;直接使用python库 代码如下 import RPi.GPIO as GPIO import dht11 import time import datetimeGPIO.setwarnings(True) GPIO.setmode(GPIO.BCM)instance dht11.DHT11(pin14)try:while True:result instance.read()if result.is_valid():print(ok)print(&quo…
暂无图片
编程学习 ·

ELK简介

ELK简介 ELK是三个开源软件的缩写&#xff0c;Elasticsearch、Logstash、Kibana。它们都是开源软件。不过现在还新增了一个 Beats&#xff0c;它是一个轻量级的日志收集处理工具(Agent)&#xff0c;Beats 占用资源少&#xff0c;适合于在各个服务器上搜集日志后传输给 Logstas…
暂无图片
编程学习 ·

Linux 基础

通常大数据框架都部署在 Linux 服务器上&#xff0c;所以需要具备一定的 Linux 知识。Linux 书籍当中比较著名的是 《鸟哥私房菜》系列&#xff0c;这个系列很全面也很经典。但如果你希望能够快速地入门&#xff0c;这里推荐《Linux 就该这么学》&#xff0c;其网站上有免费的电…
暂无图片
编程学习 ·

Windows2022 无线网卡装不上驱动

想来 Windows2022 和 windows10/11 的驱动应该差不多通用的&#xff0c;但是死活装不上呢&#xff1f; 搜一下&#xff0c;有人提到 “默认安装时‘无线LAN服务’是关闭的&#xff0c;如果需要开启&#xff0c;只需要在“添加角色和功能”中&#xff0c;选择开启“无线LAN服务…
暂无图片
编程学习 ·

【嵌入式面试宝典】版本控制工具Git常用命令总结

目录 创建仓库 查看信息 版本回退 版本检出 远程库 Git 创建仓库 git initgit add <file> 可反复多次使用&#xff0c;添加多个文件git commit -m <message> 查看信息 git status 仓库当前的状态git diff 差异对比git log 历史记录&#xff0c;提交日志--pret…
暂无图片
编程学习 ·

用Postman生成测试报告

newman newman是一款基于nodejs开发的可以运行postman脚本的工具&#xff0c;使用Newman&#xff0c;可以直接从命令运行和测试postman集合。 安装nodejs 下载地址&#xff1a;https://nodejs.org/en/download/ 选择自己系统相对应的版本内容进行下载&#xff0c;然后傻瓜式安…
暂无图片
编程学习 ·

Java面向对象之多态、向上转型和向下转型

文章目录前言一、多态二、引用类型之间的转换Ⅰ.向上转型Ⅱ.向下转型总结前言 今天继续Java面向对象的学习&#xff0c;学习面向对象的第三大特征&#xff1a;多态&#xff0c;了解多态的意义&#xff0c;以及两种引用类型之间的转换&#xff1a;向上转型、向下转型。  希望能…