【java面试】之java基础

本篇博客是借鉴其他博主文章和自己理解整理所得。

1、JDK和JRE的区别

JDK(java Development Kit) 是整个java的核心，包含了java运行环境（Java Runtime Envirnment），java工具（javac/java/jdb等）和java的核心类库（java API，包含rt.jar）。
JRE （java Runtime Environment）包含了 JVM（java虚拟机）、库函数、运行java应用程序所必须的文件。
JVM（java Virtual Machine）是java虚拟机，用来执行bytecode字节码的虚拟计算机，和操作系统打交道。
JDK是java开发工具包，在其安装目录下有六个文件夹，包含一些可描述文件，一个src压缩文件。bin，include，lib，jre这四个文件夹在其中其重要作用，demo，sample是一些例子。也可以看出来，JDK包含JRE,而JRE包含JVM。

bin：最主要的是编译器（javac.exe）。

include：java和JVM交互的头文件。

lib：核心类库。

jre：java运行环境（jdk和jre中都有各自的bin，lib文件，他们是不同的）。

JDK是用于java程序开发的，JDK有编译功能，而JRE只是可以运行class文件，但是并没有编译的功能。JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。 其中的开发工具包括编译工具(javac.exe)打包工具(jar.exe)等。在JDK的安装目录下有一个jre目录，里面有两个文件夹bin和lib，在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和 lib合起来就称为jre。

2、java如何实现跨平台

首先，通过编译器将java源程序编译成字节码文件，字节码文件其实与平台没有关系，然后通过java虚拟机将字节码文件翻译成特定操作系统下的机器码运行。
注意：编译的结果一定是生成字节码文件，字节码文件并不能直接运行，只有通过jvm翻译成机器码才能够运行，不同操作系统系下的编译生成的字节码都是一样的，但是不同操作系统下的jvm翻译出来的机器码确实不一样的。扩平台的是java程序，并不是jvm。

3、java的基本数据类型

java是一种强类型语言，意思就是每个变量声明一种类型。一共有8中基本类型（primitive type）。其中4个整型（byte、short、int、long），2个浮点类型（float、double），一个表示Unicode编码的字符单元字符类型（char），1个表示真值的类型布尔类型（boolean）。
整型：整型表示没有小数部分的数值，可以有负数的存在。

• byte:字节类型，字节数：1，二进制位数：8，取值范围：-128~127
• short：短整型，字节数：2，二进制位数：16，取值范围：-32768~32767
• int：整型，字节数：4，二进制位数：32，取值范围：-2147483648~2147483647
• long：长整型，字节数：8，二进制位数：64，取值范围：-9.22337E+18~9.22337E+18
  注意事项：int a=1；1就是字面量，也就是直接写出来的常量，整数的字面量都默认是int类型。所以如果要是定义为long类型数据，要在数字后边加上L或者l。
  浮点型：浮点型表示有小数部分的数值，可以有负数的存在。
• float：单精度类型，字节数：4，二进制位数：32，取值范围：-3.40E+38~3.40E+38
• double：双精度类型，字节数：8，二进制位数：64，取值范围：-1.79E+308~-1.79E+308
  注意事项：如果不做声明的话，会默认小数位double类型，如果要使用float类型，必须进行强转。例如，float a=1.3；会编译报错，正确的写法为：float a=（float）1.3；或者是float a=1.3f；（或者是f/F）。
  一般来说，CPU处理单精度浮点数的速度比双精度浮点数要快很多。
  面试细节：
• 问：java中3*0.1==0.3将会返回什么？true or false？
  false，因为浮点数不能将完全精确的小数表示出来，在进行运算后，一般都会有精度损失。
• float=1.3；是否正确？
  错误方法，编译报错。1.3是双精度类型（double）赋值给单精度类型（float）属于向下转型，会造成精度的损失，因此需要进行强制类型转换，正确的表示方法为：float a=（float）1.3；或者是float a=1.3f；（或者是f/F）。
  字符类型：原本用于表示单个字符，不过现在有些Unicode字符可以用一个char值表示，另外一些Unicode字符则需要两个char值，char类型的字面量要用单引号括起来。
• char：字符类型，字节数：2，二进制位数：16，取值范围：0~65535
  布尔型：用true和false来表示。
• boolean：true/false
  数据类型之间转换：
  
  注意事项：小可转大，大转小会失去精度！！！
  在使用java运算符对数字进行操作时，两个数被称为是操作数。
  如果，两个操作数中有一个是double，那么另一个数字就会转成double。
  如果，两个操作数中有一个是float，那么另一个数字就会转成float。
  如果，两个操作数中有一个是long，那么另一个数字就会转成long。
  否则两个操作数都将转成int类型。

4、==和equals（）的区别

• == 是比较内存地址是否一样；equals（）则是比较字符串内容是否一样。
  1）对于 ==，如果是作用于基本数据类型的数据，那么则是比较其存储的“值”是否相等；
  如果是作用于引用数据类型，那么则比较的是指向的对象的地址值。
  2）对于equals（）方法，特别注意的是，不可以作用于基本数据类型数据，equals（）方法继承了Object类，比较的是是否是同一个对象；
  如果没有对equals（）方法重写，则等价于“ == ”，比较两个对象是否相等，实际上是比较指向两个对象的
  地址值是否相等；
  如果对equals（）方法重写了，则比较的是两个对象的内容是否相等。（诸如String、Date、Integer等类对equals方法进行了重写的话，比较的是所指向的对象的内容）

5、两个对象的hashcode（）相同，那么两个对象的equals（）也一定为true吗？

总结：
两个对象equals（）相等，那么他们的hashcode（）一定相等，但是他们的hashcode（）相等，他们equals（）结果不一定相等；
两个对象 == 相等，那么他们的hashcode（）一定相等，但是他们的hashcode（）相等，他们的equals（）结果不一定相等；
两个对象hashcode（）不相等，那么这两个对象一定不相等。
解决方案：（比较两个对象是否真正相等）
首先，使用hashcode（）作比较，如果hashcode（）结果不相等，那么两个对象一定不相等；如果hashcode（）相等，那么就再使用equals（）比较，如果相等，那么说明这两个对象是相等的。

6、final在java中的作用

在Java中，final关键字可以用来修饰类、方法和变量
当用final修饰类时，表明这个类不能被继承。
当用final修饰方法，此方法不能被重写（可以重载多个final修饰的方法）
当用final修饰变量，此变量表示常量，只能被赋值一次，赋值后值不再改变，被final修饰的成员变量必须要初始化，赋值后不能再重新赋值（可以调用本对象方法修改属性值），对基本类型来说其值是不可改变的，对引用变量来说其引用也是不可变的，即不能再指向其他对象。

7、java 中的 Math.round(-1.5) 等于多少？

• Math.round(-1.5)=-1
  Math.round(1.5)=2
  原因：Math.round()是对传入的参数，+0.5之后，再向下取整就是返回的结果（这里的向下取整指的是比他小的第一个整数或 者是和他相等的整数）。他的返回值类型是long型。
  Math.floor()方法，向下取整，返回值类型为double类型。
  Math.ceil()方法，向上取整，返回值类型为double类型。

8、String 属于基础的数据类型吗？

String不属于基本数据类型，只有8种基本数据类型。（见第三个问题—java基本数据类型）
String是个对象是引用类型。
String是final修饰的java类。
注意事项：
基本数据类型只表示简单的字符或数字，而引用类型可以表示复杂的数据类型。
java虚拟机会为基本数据类型分配实际的内存空间，而只会对引用类型指向堆中的某个实例的地址。

9、java 中操作字符串都有哪些类？它们之间有什么区别？

String、StringBuffer、StringBuilder

• String：被final修饰，String类的方法都是返回new String的。String对象的任何改变都不会影响到原对象的值，即对字符串String的操作每次都会生成新的对象。String的缺点是每次String在使用拼接符号+时，总是重新创建一个String字符串。大量的使用字符串拼接时不推荐使用String。（String方便，但是占用了大量的内存空间）

• StringBuffer：是可以直接改变对象的，对字符串操作的方法都添加了synchronized方法，保证了线程的安全。

• StringBuilder：可以改变操作对象，他不能保证线程的安全，在他的方法体内，需要进行对字符串的修改操作，可以使用new StringBuilder对象调用append（）、replace（）、delete（）等方法进行操作修改字符串。
  操作效率：StingBuilder>StringBuffer>String
  线程安全：StringBuilder是线程不安全的，用于单线程
  StringBuffer是线程安全的，用于多线程
  String是线程安全的，用于多线程

10、String str="i"与 String str=new String(“i”)一样吗？

String str = “i”; 在创建之后，会将“i”这个值放在常量池中，这个只是一个引用，内存中如果有“i"的话（java虚拟机会在常量池中自动检索），str就指向它；如果没有，才创建它;
如果出现了 String str1 = “i”; String str2 = “i”; String str3 = “i”; 那么str、str1、str2、str3都会指向这个“i”
而String str = new String(“i”);对象创建了以后放在堆内存中，这是根据"i"这个String对象再次构造一个String对象，将新构造出来的String对象的引用赋给str。
拓展：
String str="i"与 String str1=new String(“i”)一样吗？
（a）str == str1 结果是false（两个地址值是不同的）
（b）str.equals（str1） 结果为true（两个对象的值是相当的，所以内存中只能往HashSet中放一个）

• String str = new String(“Hello”);创建了几个对象？
  这个主要分2种情况：
  1）如果String的字符串常量池中有Hello这个对象，那么就只创建了一个对象。
  原因：因为字符串常量池中有Hello，字符串会用已有的Hello对象，所有不会再创建Hello这个对象了，只会创建一个new String对象。
  2）如果String的字符串常量池中没有Hello这个对象，那么久创建了两个对象。
  原因：只要是new了就一定会创建一个新对象，而字符串常量池中没有Hello，所以会在字符串常量池中创建一个Hello对象。
  
• Sting str = “a”;
  String str1 = “a”+“b”;
  创建了几个对象？
  一共创建了2个对象，一个是str对象a，一个str1对象ab。
• Sting str = “a”;
  String str1 = str+“b”;
  创建了几个对象？
  一共创建了3个对象，一个str对象a，一个b对象，一个str1对象ab。
  ————————————————
  版权声明：本文为CSDN博主「李小幺」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
  原文链接：https://blog.csdn.net/liyu4352502/article/details/100772926

11、如何实现字符串的反转

• StringBuiler / StringBuffer的reverse()的方法。

 public static String reverseStringBuilder(String s) {
        StringBuilder sb = new StringBuilder(s);                      
        String afterreverse = sb.reverse().toString()；
        return afterreverse;
    }
————————————————
版权声明：本文为CSDN博主「boyin333」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/boyin333/article/details/90582201

• 通过String类的charAt()的方法来获取字符串中的每一个字符，然后将其拼接为一个新的字符串。

 /**
      * 该方法是通过charAt()方法获得每一个char的字符，i=0时获得第一个字符a然后赋值给reverse
      * 此时reverse="a";i=1时获得第二个字符b然后加上reverse再赋值给reverse，此时reverse="ba";
      * 以次类推
      */
     public static String CharAtreverse(String s) {
          int length = s.length();
          String reverse = "";
          for (int i=0; i<length; i++)
              reverse = s.charAt(i) + reverse;
          return reverse;
      }
————————————————
版权声明：本文为CSDN博主「boyin333」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/boyin333/article/details/90582201

• 通过String的toCharArray()方法可以获得字符串中的每一个字符串并转换为字符数组，然后用一个空的字符串从后向前一个个的拼接成新的字符串。

  public static String reverseCharArray(String s) {
        char[] array = s.toCharArray();
        String reverse = "";
        for (int i = array.length - 1; i >= 0; i--) {
            reverse += array[i];
        }
        return reverse;
    }
————————————————
版权声明：本文为CSDN博主「boyin333」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/boyin333/article/details/90582201

• 通过递归的方式

  public static String reverseRecursive(String s) {
        int length = s.length();
        if (length <= 1)
            return s;
        String left = s.substring(0, length / 2);
        String right = s.substring(length / 2, length);
        String afterReverse = reverse1(right) + reverse1(left);
        return afterReverse;
    }
————————————————
版权声明：本文为CSDN博主「boyin333」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/boyin333/article/details/90582201

12、String 类的常用方法都有哪些

• str.length()
  获取字符串长度
• str.indexOf(String str)
  从头开始查找str在字符串中第一次出现的位置
• str.indexOf(String str,int fromIndex)
  从下标fromIndex处开始开始查找str在字符串中第一次出现的位置
• str.lastIndexOf(String str)
  从尾部开始查找str在字符串中最后一次出现的位置
• str.lastIndexOf(String str,int fromIndex)
  从下标fromIndex处开始开始查找str在字符串中最后一次出现的位置
• str.charAt(int index)
  查找字符串中下标为index位置出现的字符串
• str.substring(fromIndex，endIndex)
  从fromIndex处开始截取到endIndex处结束，不包含下标为endIndex的字符
• str.substring(fromIndex)
  从fromIndex处开始截取到最后
• 开始位置字符：str.startWith(String str1),返回Boolean值;
  结束位置字符：str.endWith(String str1),返回Boolean值;
• int num = str.compareTo(String str1)
  对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
• int num = str.compareToIgnore(String str1)
  和compareTo()方法类似，忽略大小写。
• boolean b = str.equals(Object obj);
  比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
• boolean b = str.equalsIgnoreCase(Object obj)
  和equals方法类似，忽略大小写。
• str2 = str.concat(String str1)
  用concat连接两个字符城成为一个新的字符串。
• 小写转大写：str.toUpperCase()
  大写转小写：str.toLowerCase()
• str.replace(oldStr，newStr)
  用新的字符代替就得字符
• str.trim()
  清除字符串str两侧的空字符串
• str.split(String str1)
  用str1将字符串str分割成数组

13、抽象类必须要有抽象方法吗？
不是

• 抽象类中必须有关键字abstract来修饰
• 抽象类中可以不包含抽象方法
• 如果一个类包含抽象方法，那么这个类一定是抽象类

14、final关键字在java中的作用？
final可以修饰类，方法，和变量（成员变量和局部变量）

• final修饰类，则表明这个类不能够被继承，final类中的所有方法均会被隐式的指定为final方法，也就是说final类没有子类。

• final修饰方法，则表明该方法所在的类的子类是不能够重写该方法的，（但是可以重载）如果父类中final修饰的方法同时访问控制权限为private，那么将会导致子类不能直接继承父类中的此方法。
  注意：此时，可以在子类中定义相同的方法名和参数，这不是重写，而是子类中重新定义了一个方法名和参数相同的方法。

• final修饰变量，final修饰基本数据类型时，这个值在初始化之后将永远不会改变；final修饰引用类型数据时，（即修饰一个对象）在初始化之后，将永远指向一个内存地址，不可修改，但是该内存地址中保存的是对象信息，可以修改。

15、static关键字在java中的作用？
static可以修饰变量，方法和静态代码块。

• final修饰成员变量，给变量加上statis之后，此变量就会变成全局变量，jvm在加载的时候，会将此变量直接加载到方法区中，而不是堆中，无论哪一个方法修改了此变量，此变量都会发生改变，可以让对象共享。
  注意:在再次初始化该对象时，static修饰的类成员就不会被初始化，在程序运行过程中，static只会在第一次new时初始化。

• final修饰成员方法，static修饰的方法，可以使用“类名.方法名”来直接访问成员变量，避免了new来创建对象，然后再通过对象来访问成员变量的步骤，避免了资源的消耗。

• static修饰静态代码块，在new一个对象时，static修饰的成员变量首先被初始化，其次是普通方法，最后是构造方法。
  注意事项：普通方法和构造方法的区别？

• 普通方法：

`[修饰符] 返回值类型  方法名  （参数）`{
			方法体；
}

返回值类型：
1、void无返回值
2、基本数据类型

public void demo（String name）{
System.out.println(name);
}

• 构造方法：

[修饰符]  构造器 （参数或者是无参）{

}

无返回值

public Student（参数）{

}

Student s = new Student（）；

区别：
1、构造方法中的构造器名字必须和类名相同；
2、构造方法中没有返回值类型的声明；
3、当类中没有构造方法时，系统会自动创建一个该类的无参构造；
4、构造方法创建对象时，需要调用new来创建；

构造方法主要用来实例化对象，并且可以通过实例化对象为成员变量赋值；

• 构造方法是一个与类同名的方法，在java类中必须有一个构造方法，如果一个java类中没有构造方法，那么编译器在编译的时候会自动添加一个无参构造。构造函数没有返回值，并且无需使用void来说明这个构造方法没有返回值。构造方法必须与类名相同，一个类中可以有多个构造方法，这些构造方法只是有相同的名字，但是参数是不一样的。

//定义一个类
public class Teacher{
//定义一个方法，方法名与类名相同的无参构造
	public Teacher(){
	//this关键字调用构造函数，"chen"调用有参构造
		this("chen");
	}
//定义一个方法，方法名与类名相同的有参构造
	public Teacher(String name){
	
	}
}

16、普通类和抽象类的区别？

• 抽象类用abstract修饰，普通类则是用public、private等修饰
• 抽象方法不能被实例化
• 抽象类可以有抽象方法，抽象方法只需声明无需实现
• 含有抽象方法的类一定为抽象类
• 抽象类中的子类必须实现抽象类中的所有抽象方法，否则子类也会成为抽象类
• 抽象方法不能够被static修饰为静态-----static修饰的方法在类实例化之前，就已经分配了内存，而抽象方法不能够被实例化，前后矛盾，故抽象方法不能够和static同时存在。
• 抽象方法不能够被private修饰-----private修饰后只能在本类中使用，而抽象方法一定在要子类中重写，故产生矛盾。
• 抽象方法不能被final修饰------final修饰后子类中不能够重写

17、接口和抽象类的区别？

• 接口是完全抽象的，不存在方法的实现（即不存在方法体），而抽象类是可以有默认的方法实现。
• 接口：子类需要提供接口中所有声明的方法的实现；抽象类：如果子类不是抽象类，它是需要提供抽象类中所有声明的方法的实现
• 接口没有构造函数，抽象类中可以有构造函数
• 接口方法默认的是public，不可以使用其他的修饰符；抽象方法可以使用public，protected，default等
• 接口可以继承多个接口，但是接口不能实现任何接口；抽象方法可以继承一个类，实现多个接口
• 如果往接口中添加新的方法，必须改变实现该接口的类；往抽象类中添加新方法，无需改变代码

18、java中的IO流分为几种？

	字符流	字节流
输出流	Writer	OutPutStream
输入流	Reader	InPutStream

数据传输的形式：字节流和字符流

异常在IO流中的处理办法：

• 流对象的初始值为null，真正的初始化过程是在try块中
• 在关流之前要保证流对象不为null，为null的文件不能够close
• 无论关流是否成功，都要将流对象置为null，变成无用对象，等待系统收回，提高内存资源的利用效率
• 关流可能失败，如果失败的话，自带的缓冲区操作没有完成，则需要手动冲刷，否则会造成文件数据的滞留

19、字节流和字符流的区别？

• 操作的单位不一致：一个是字节，一个是字符
• 字符流操作的是中文（文档）；字节流操作的是文本，视频，音频，图片等
• 字符流中有直接可以写字符串的方法
• 字节流如果不关闭流也会写入文件；字符流必须经过刷新或者关闭才能写入文件

20、BIO,NIO,AIO的区别及应用场景？

• BIO同步并阻塞，一个连接一个线程，适用于连接数目比较小的架构，这种方式对服务器资源的要求较高
• NIO同步非阻塞，一个请求一个线程，适用于连接数目较多且连接比较短的架构，比如聊天服务器
• AIO异步非阻塞，一个有效请求一个线程，适用于连接数目多且连接较长的架构，比如相册服务器

21、java中File类的常用方法及应用

• creatNewFile（）
  在制定位置创建一个空文件，成功返回true，如果已经存在则返回false
• mkdir（）
  在制定位置创建一个单级文件夹
• mkdirs（）
  在制定位置创建一个多级文件夹
• renameTo（File dest）
  如果目标文件与源文件是在同一路径下，那么renameTo的作用是重命名，如果目标文件与源文件不在同一个路径下，那么renameTo的作用是剪切，而且不能操作文件夹
• delete（）
  删除文件或者一个空文件夹，不能删除非空文件夹，返回值是布尔类型
• deleteOnExit（）
  jvm退出时，删除文件或者文件夹，用于删除临时文件，无返回值
• exists（）
  文件或者文件夹是否存在
• isFile（）
  是否是一个文件，若不存在则返回false
• isDierctory（）
  是否是一个目录，若不存在，始终为false
• isHidden（）
  是否是隐藏的文件或者目录
• isAbsolute（）
  测试此抽象路径是否是为绝对路径名
• getName（）
  获取文件或者文件夹的名称
• length（）
  获取文件的大小（字节数）
• list（）
  返回目录下的文件或者目录名，包含隐藏文件

22、重载和重写的区别？

重载（Overload）的实质表现参数不同（参数的个数，参数的类型，参数的顺序）的同名函数，这些同名函数的返回值类型没有任何限定，重载的判定也不能以返回值类型和跑出的异常种类作为判定的依据。这些同名函数存在于一个类中，重载也是java多态性的一个重要表现。在调用这些函数时，通过传递不同个数的参数和参数类型来确定具体调用哪个方法。

public class Person{
	String name;
	String sex;
	int age;
	int length;
	public void Student(String name){
	
	}
	public void Student(String name,String sex){
	
	}
	public void Student(String name,String sex,int age){
	
	}
	public void Student(String name,String sex,int age,int length){
	
	}
}

重写（overriding）：在父子类中，子类的方法和父类的方法完全相同，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法。

• 方法名称，参数类型，返回值类型全部相同
• 子类中重写的方法不能比父类有更加严格的权限访问修饰符
• 只能发生在父子类的继承中
• 重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。

23、java语言的特性并简述
封装，继承，多态

• 封装：java语言可以将事务抽象成一个类，然后进行封装，将事务拥有的属性和动作进行隐藏，只保留所需要用到的方法。
  封装的单一性原则，一个类把自己的一些方法和属性封装起来，其他的类并不会访问到这些方法，当这个类的内部逻辑发生变化以后，外部调用不会因为这个类内部的变化做一些对应的措施，他们只是调用开放的接口，并不需要担心类内部的实现。
• 继承：
  java的类可以分为三种：类，抽象类，接口

1）类：使用class定义，类中不能有抽象方法；
类可以extends（继承）类，抽象类（子类必须实现抽象类中的所有抽象方法）并且类只能继承一个类或者抽象类。但是可以implement多个接口（类必须实现接口中的所有方法）
2）抽象类：使用abstract class定义，类中的抽象方法可有可无
抽象类可以extends类，抽象类（抽象类继承抽象类时，可以全部，部分或者完全不实现父类抽象方法）可以implement多个接口（可以全部，部分或者完全不实现接口方法）
3）接口：使用interface定义，接口中只有抽象方法
接口可以extends多个接口

4）子类在继承以后可以获得（1）父类非private的属性和方法（2）子类也可以在本类中添加自己的属性和方法，实现对父类的扩展（3）可以重写父类的方法

注意事项：构造函数不能够被继承，子类可以通过super（）来显示的调用父类的构造函数；一旦确定了父子类的继承关系，那么编译器会自动的为子类调用父类的无参构造；如果父类没有定义无参构造，那么子类必须在构造函数的第一行代码上使用super（）显示调用。（所有的类都默认拥有无参构造，如果说定义了其他有参构造，那么无参构造则自动失效）

• 多态：“一个接口，多种形态”主要是有编译时多态（方法的重载）和运行时多态（继承中的方法的重写，向上造型）
  向上造型：父类声明，子类创建

24、this和super关键字的区别？

• this表示对当前对象的引用，调用本类中的成员变量和成员方法；this也可以用于构造函数之间的相互调用。
• super表示子类对父类的调用，可以调用父类的成员变量和成员方法。
• 注意事项：this（）和super（）都是必须写在第一行，所以this（）和super（）是不可能同时出现的。

25、简述包装类和基本数据类型的区别？

• 基本数据类型的值都是存储在栈中，包装类型存储在堆中。
• 包装类是对象，包装类创建的对象，是拥有字段和方法的，可以使用api提供的一些有用的方法。更为强大。
• 基本数据类型是值传递，而包装类是引用传递。
• 向ArrayList，LinkedList中放数据的时候，只能放Object类型的，基本数据类型是放不进去的。
• 包装类的默认值都是null。