Java 第一个模块 java基础面试题

Java 第一个模块 java基础面试题

初级部分

1.JVM、JDK 和 JRE有什么区别？★★★★★

JVM：java虚拟机，是一个可以执行java字节码的虚拟机进程，java虚拟机可以在不同的操作系统上运行，
	 一次编译，多次运行
     将java源代码编译成字节码（class)文件，通过类加载，将字节码文件中的数据加载到运行时数据区，
     执行引擎根据指定的JVM指令将字节码翻译成机器码，再通过CUP去执行，本地类库接口是用来调用其
     他语言写的方法。
JDK：java 开发工具包，提供了 java 的开发环境和运行环境。
JRE：java 运行环境，为 java 提供运行环境。
	JDK中包含JRE，包含许多开发、调试、分析的工具
    编译命令：javac 解释命令：java 文档解析：javadoc 启动编译：javaw

2.== 和 equals 的区别是什么？ ★★★★

1.==:是关系运算符 equals是Object中的方法
2.==比较数值类型，比较的是值是否相等，引用类型比较的是地址值是否相等
  equals不能比较数值，引用对象比较时，就相当于“==”，重写equals()方法，比较的是其中的内容，
  而String类型已经重写过equals()方法，所以String比较的是其中的内容

3.“&”和“&&”的区别（逻辑运算符和位运算符）？ ★★★★

相同点：&和&&的运算结果相同，表达式两边都为true是，结果才为true
不同点：1.单&是位运算符，双&&是逻辑运算符
   	   2.当符号左边是false，&继续执行符号右边的运算，&&不在执行符号右边的运算

4.final 关键字在 java 中有什么作用？★★★★★

1.final修饰的类是最终类，不能被继承
2.final修饰的成员变量为常量，必须初始化，变量名通常用大写字母表示。修饰局部
变量时，在调用之前必须赋值
3.final修饰的方法不能被重写

5.基本数据类型中的默认数据类型 ★★★

整数数据类型默认为int型，浮点型的默认数据类型是double
！注意点：byte\char\short不能互转，只能自动转化为int型,因为操作数栈都是4个字节

6.java中精度类型有哪些？★★★

float:单精度浮点型
double：双精度类型
bigDecimal:巨大的容量实数
float和double是用二进制浮点型进行运算，计算的数据不能完全准确，多用于科学计算
和工程计算
bigDecimal:用于商业计算，结果相当精确，计算巨大的整数时，会使用bigInteger

7. java 中操作字符串都有哪些类？它们之间有什么区别? ★★★★★

1.操作字符串有：String类、StringBuffer类、StringBuilder
2.String类是不可更改字符串，使用final关键字，用数组进行存储
  StringBuffer是线程安全的，效率低
  StringBuilder是线程不安全的，效率高

8.如何将字符串反转？★

StringBuffer和StringBuilder中可以调用reverse()方法进行反转

9.String类的常用方法都有那些？★★★

indexOf():返回指定字符的索引
charAt():返回指定位置的字符
toCharArray():将字符串转化为字符数组
replace():字符串替换
split():切割字符串，返回字符数组
trim():去除字符串空白
subString():截取字符串
ValueOf():将其他类型转化为字符串 包装类.ParseXXX():转化为指定的数据类型
length():得到字符串的长度
toLowerCase():将字母全部变为小写字母
toUpperCase():将所有字母变为大写字母
getByte():返回byte数组
equals():比较字符串中的内容
equalIgnoreCase():忽略字母的大小写，在Compare的方法中使用ComparToIgnoreCase()方法
endsWith():截取最后的字符串
startWith():截取开头的字符串
    正则表达式所用到的方法：
    split():将字符串进行切割 1
	matches():把输入的字符串进行 匹配
	replaceAll():全部替换（根据正则表达式替换）

10.两个对象的 hashCode()相同，则 equals()也一定为 true吗? ★★★★★

	hash值（int型）相同，equals()不一定为true，因为在散列表中，两个键值对的hash值相等，并不
一定键值对相等，计算出hash值，找到散列表中的相应位置，同hash值可能存储多个 ，使用素数31相，结果
更容易是唯一性，选的素数太大，容易造成内存溢出，（map和set比较是先比较hash值在使用equals方法）
	equals为true时，hash值一定相同（List全用equals方法比较）    

11.String str="i"与 String str=new String("i")一样吗？★★★

不一样：前面有Java虚拟机放在常量池，new出来的对象是放在堆内存中（java8的串池在堆内存中）

12.String t = new String("test");在堆中创建了几个对象？★★

分两种情况:
java8之前：
    1.创建对象时，会自动调用intern()方法检测串池中是否有该对象，如果没有便会在堆中创建一个对
    象，在堆中在复制一份，调用intern（）方法存入到串池中，一共创建两次。
   	2.如果常量池中检测出有该对象，只在堆中创建一次，常量池是为了代码的复用
java8或之后：
    1.串池移到了堆中，如果串池中没有该对象，那么在堆中创建的对象，intern（）方法会直接将对象
      放入到串池中
    2.如果串池中有对象，就在堆中创建一次，在java，对象至多创建一次

13.抽象类的注意事项？★★

1.抽象类体现的是模板思想，不能实例化，由子类继承实现，使用abstract关键字创建抽象类
2.可以有抽象方法和普通方法，也可以没有抽象方法，方法不能有方法体，以分号结尾
3.可以有构造器,但不能是静态类，因为静态类在静态域构建了实例，而抽象类不能实例化,
4.子类继承抽象类，必须要重写抽象类中的所有方法，否则子类也是一个抽象类
5.不能使用final关键字，final修饰的类不能被重写
6.不能使用private、static、synchronized、native关键字修饰

14.接口和抽象类有什么区别？★★★★★

1.抽象类体现的是模板思想，使用abstact关键字创建类，方法中不能有方法体，而接口是用来定义规范，使用
   interface创建接口
2.实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
3.构造函数：抽象类可以有构造器和成员变量；接口不能有构造器，不能有普通方法，只能是抽象方法jdk8之后
   接口也可以有static、defalt关键字修饰的方法，变量必须是常量。Java9支持私有方法、私有静态方法。
4.main方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法。
5.实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
6.访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。

15 java 中IO 流分为几种？★★

按功能来分：输入流（input）、输出流（output）。
按类型来分：字节流和字符流。
字节流和字符流的区别是：字节流按 8 位（1个字节）传输以字节为单位输入输出数据，字符流按 16 位
（2个字节）传输以字符为单位输入输出数据。

16.i++和++i的区别？★★★★★

i++：先运算后加1
++i：先加1后运算    

17.Files的常用方法都有哪些？★★★

- Files.exists()：检测文件路径是否存在。
- Files.createnewFile()：创建文件。
- Files.createDirectory()：创建文件夹。
- Files.delete()：删除一个文件或目录。
- Files.copy()：复制文件。
- Files.move()：移动文件。
- Files.size()：查看文件个数。
- Files.read()：读取文件。
- Files.write()：写入文件。
    mkdir():创建一层目录
	mkdirs():创建多层目录
	listFiles():得到指定目录下的所有文件，可以通过fileFilter过滤器进行过滤，
    	里面有accept(File pathname)方法
	isFile():判断是否是一个文件
	isDiretory():判断是否是一个目录
	getName():得到文件的名字
	canExecute():判断文件是否能执行
	getAbsolutePath():得到文件的绝对路径
	getPath():得到文件的相对路径	

18.变量的命名规则 ★★★

1、只能由字母、数字、_ 、$组成
2、不能以数字开头,不能有空格
3、不能以java中的关键字和保留字命名
4、在有效范围内唯一 0-255 （包含该变量的大括号内）
5、可以使用中文命名，但是不提倡使用
6、Java中严格区分大小写，建议使用小驼峰命名法(当变量名由多个单词组成时，第一个单词首字母小写，
  其余单词首字母大写) 

19.垃圾回收器 ★★★★

垃圾：在堆中没有任何引用指向的对象 
垃圾回收器：专门回收没有任何引用指向的对象，伴随着程序执行而执行
    在回收游离态对象之前，垃圾回收器会调用finalize方法提醒该对象被回收
    垃圾回收器是要获得CPU时间片才会扫描回收，可以重写finalize方法来进行查看回收过程
    加快垃圾回收，可以使用System.GC()方法

20.this和super关键字 ★★★★★

this：关键字用于区分成员变量和局部变量
	可以在本类中调用构造器，this(参数)，必须放在构造器的第一行
	调用方法，使用this.方法
super：关键字用于区分父类的成员变量
    也可以使用super(参数)调用构造器，在默认的无参构造器中，默认自动添加了super()
    调用方法super.方法
this关键字和super关键字只能有一个在第一行

21.Override与Overload的区别？★★★★★

方法的重载：重载同方法名可以存在多个
    方法名相同参数不同，和其他没有关系。
方法的重写：子类方法对父类方法的覆盖
    两同:方法名相同，参数相同
    一大:子类的权限修饰符大于等于父类的权限修饰符 父类的一种扩展
    两小:子类的返回值类型可以和父类的返回值类型相同，也可以是父类的子类，子类也必须是void类型，
         子类中抛出的异常类型必须小于等于父类抛出来的异常类型    	

22.static关键字 ★★★★★

static关键字表明一个成员变量或者成员方法是在所属类没有任何实例变量的情况下进行访问
static方法不能被覆盖，重写的方法是运行时绑定的，而static方法是静态绑定，和实例变量无关
修饰的成员变量就是共享数据，类变量
修饰的方法，不能使用非静态的方法，直接调用的方法必须静态方法，可以用类.方法来调用，常用于工具类
修饰代码块，随着类的加载而加载，给静态变量赋初值使用，只会执行一次
修饰静态的内部类，静态类

23.java的特性有哪些？★★★★

java语言是简单的，没有C语言的指针，有垃圾自动回收机制，不必为内存担忧
java语言是面向对象的，都可以封装成类和方法中
java语言是分布式的，使用到java网络编程URL，socket，java中的RMI(远程方法激活)机制也是分布式的重要
	手段
java语言是安全性和健壮性的，java使用了反射机制，安全管理机制
java语言具有可移植性，JVM虚拟机可以在不同的操作系统上运行
java语言是一种动态性语言，在Java语言中，可以简单、直观地查询运行时信息；以将新
代码加入到一个正在运行的程序中去。

24.java初始化顺序？★★★★★

从前到后的顺序：
父类静态块.
子类静态块.
父类成员变量初始化.
父类构造块. 
父类构造函数. 
子类成员变量初始化.
子类构造块.
子类构造函数.

25.面向对象的三个基本特征？★★★★★

面向对象的三个基本特征是：封装、继承和多态。
    继承：继承就是子类继承父类的特征和行为,子类是可以对父类进行扩展（继承所有
         父类的信息，private可以继承不能被子类使用）
	封装：属性私有化，方法公开化，高类聚，低耦合。
         隐藏部分对象的属性和实现细节，对数据的访问只能通过外公开的接口。通过
         这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分
         意外的改变或错误的使用了对象的私有部分，保证java的安全性。
	多态：对于同一个行为，不同的子类对象具有不同的表现形式。多态存在的3个条件
	     ：1）继承；2）重写；3）父类的引用指向子类对象。
        父类型可以装子对象，调用父类的方法，可以调用子类的方法。程序可以更加
        通用，许多设计模式会使用。

26.finally、final、和finalize的区别?★★★★★

final和finally都是java中的关键字，而finalize是一个方法
final:可以修饰类、变量、方法，修饰类不可以被继承，修饰方法不可以被重写，修饰变
	量有是一个常量
finally：一般用在try-cath代码块中，不管代码块是否发生异常，finally中的代码块
	都会执行，一般用于关闭资源，关闭IO流或者在JDBC中使用
finalize():是Object类中的一个方法，在垃圾回收过程中，提示对象垃圾回收，可以重
	写finalize()查看垃圾回收过程，System.gc()加快垃圾回收

27.throw 和 throws的区别？★★★★

throws是用来声明一个方法可能抛出的所有异常信息，将异常往外抛，但是不会处理
throw是抛出一个具体的异常类型对象，必须搭配 thy / catch 或者 throws 一起使用。

28.异常的种类？★★★

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 
异常分类：（父类：Throwable）
	1、不可逆异常：当程序中出现该异常时，程序不能继续执行（不可逆异常父类：Error）
      
	2、可逆异常：当程序中出现该异常时，处理异常之后可以让程序继续执行（可逆异
常父类：Exception）
		1）检查异常：需要处理才能编译成功的异常（checkedException)
    		IOException 输入输出异常
    		SQLException sql异常
    		ClassNotFoundException:类找不到异常
		2）非检查异常：不需要处理也能编译成功的异常
            	RuntimeException   运行时异常
                NullPointerException  空指针异常
                classCastException  强转异常
                ArrayIndexOutOfBundsExcepton  数组下标越界异常

29.try-catch-finally 中哪个部分可以省略？★★

catch和finally可以省略 合法的三种方式1.try-catch 2.try-finally 3.try-catch-finally
	可以省略catch或者finally。catch和finally不可以同时省略
	try处理的是可逆异常中的非检查异常（运行异常），处理检查异常编译不通过
	try-catch处理可逆异常（检查异常和非检查异常） 

30. try-catch-finally 中，如果 catch 中 return了，finally 还会执行吗？★★★

(1)finally的作用就是，无论出现什么状况，finally里的代码一定会被执行。
（2）如果在catch中return了，也会在return之前，先执行finally代码块。
（3）而且如果finally代码块中含有return语句，会覆盖其它方的return。
（4）对于基本数据类型的数据，在finally块中改变return的值对返回值没有影响，而对
引用数据类型的数据会
   有影响。
   finally不会执行的情况：（1）没有进入try代码块；（2）System.exit()强制退出
 	  程序；（3）守护线程被终止；

30.常见的异常类有哪些？★★

(1)NullPointerException 当应用程序试图访问空对象时，则抛出该异常。
(2)SQLException 提供关于数据库访问错误或其他错误信息的异常。
(3)IndexOutOfBoundsException指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。 
(4)NumberFormatException当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格
	式时，抛出该异常。
(5)FileNotFoundException当试图打开指定路径名表示的文件失败时，抛出此异常。
(6)IOException当发生某种I/O异常时，抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类。
(7)ClassCastException当试图将对象强制转换为不是实例的子类时，抛出该异常。
(8)ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常。
(9)IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
(10)ArithmeticException当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，
	抛出此类的一个实例。 
(11)NegativeArraySizeException如果应用程序试图创建大小为负的数组，则抛出该异常。
(12)NoSuchMethodException无法找到某一特定方法时，抛出该异常。
(13)SecurityException由安全管理器抛出的异常，指示存在安全侵犯。
(14)UnsupportedOperationException当不支持请求的操作时，抛出该异常。
(15)RuntimeExceptionRuntimeException 是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

31.什么时候使用字节流和字符流？★★★★★

字节流:音频文件、图片、歌曲
字符流 : 多使用在文本文件，效率高
字节流和字符流的区别是：字节流按 8 位（1个字节）传输以字节为单位输入输出数据，字符流按 16 位
	（2个字节）传输以字符为单位输入输出数据。

32.int和Integer的区别？★★★★★

Integer是int的包装类；int是基本数据类型；
Integer变量实例化后 使用；int变量不需要；
Integer实际是对象的引用，指向此new的Integer对象,存储在堆中；int是直接存储数据值，放在放在方法区；
Integer的默认值是null；int的默认值是0。
  -128到127在非new对象的integer类使用，这个范围的数值装箱后会复用，两个Integer比较返回值是true,
  不在这个这个范围类，返回的是false，因为new了新的对象，地址值不同。
 非new对象和int比较值相同，返回值为true，自动拆箱
 两个new出来的对象比较的是地址值，一定为false

33.访问修饰符public，private，protected，以及不写时的区别？★★★

34.用最有效率的方法计算2乘以8？★★★

2 << 3
    进阶：通常情况下，可以认为位运算是性能最高的。但是，其实编译器现在已经“非常聪明了”，很多指令编
    译器都能自己做优化。所以在实际实用中，我们无需特意去追求实用位运算，这样不仅会导致代码可读性很
    差，而且某些自作聪明的优化反而会误导编译器，使得编译器无法进行更好的优化。

35.String是 Java 基本数据类型吗？可以继承吗？★★★

不是。Java 中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了
	基本类型（primitive type），剩下的都是引用类型（reference type）。
    基本数据类型：数据直接存储在栈上或者堆里
    	（局部变量是存储在栈中，全局变量是存储在堆中，静态变量存储在方法区，方法运行结束，栈帧出
    	栈时销毁，局部变量失效,所以局部变量只能在方法中有效）
	引用数据类型区别：数据存储在堆上，栈上只存储引用地址
    String 类使用 final 修饰，无法被继承。

36.构造器是否可被 重写?★

Constructor<init> 不能被 override（重写），
但是可以 overload（重载），所以你可以看到⼀个类中有多个构造函数的情况。

37.当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？★★★

值传递。Java 中只有值传递，对于对象参数，值的内容是对象的引用。

38.Java 静态变量和成员变量的区别?★★★★★

成员变量存在于堆内存中。静态变量存在于方法区中。
成员变量与对象共存亡，随着对象创建而存在，随着对象被回收而释放。静态变量与类共存亡，随着类的加载而存在，
	随着类的消失而消失。
成员变量所属于对象，所以也称为实例变量。静态变量所属于类，所以也称为类变量。
   成员变量只能被对象所调用 。静态变量可以被对象调用，也可以被类名调用。

39.float n = 1.8有错吗?★★★

java中float类型变量赋值1.8，提示类型不匹配：double型不能自动转成float
float a = 1.8;//会报错。变成float a = 1.8f就没事
float b = 9;//不会报错。不加f也没事

40.break/continue/return的作用?★★★★★

break 结束当前循环 指定了循环的标识符，可以跳出指定循环
continue 只能用在循环中，跳过本次循环,进入下一次循环
return 结束方法，返回值

41.有了基本数据类型为什么还要用包装类？★★★★★

包装类可以进行实例化，体现了java的面向对象
包装类的初始值可以为空

42.说说你对面向对象的理解？★★★★★

将写的程序对象化，模块化，更易维护和修改
使代码更加灵活，可靠
封装：将属性私有化，行为公开化，把实现的细节隐藏起来，体现了Java的高类聚，
	低耦合，使程序安全，这就是封装。
继承：子类对父类的扩展，代码可以重复使用。
多态：父类的引用指向子类的对象，父类型可以装多个子对象，变现出不同的形式，
	使代码更加通用。例如：在计算员工工资时，每个部门的工资都不同，同一件事
	情需要用不同的方式去实现。

43.常见的运行时异常？★★★

ArithmeticException 算数异常
ClassCastException  类转换异常
IllegalArgumentException	非法参数异常
IndexOfBoundsException	下标越界异常
NullPointException 空指针异常
SecutityException    安全异常

44.成员变量和局部变量的区别？★★★★★

1.存储方式：
    成员变量：使用static修饰，属于类，即类变量，存储在方法区（静态域）
    		没用static修饰，属于实例变量，存储在堆区
    局部变量：如果为基本数据类型，存储在栈中，如果为引用类型，栈中存放的是指向堆内存的地址
2.语法形式：
    成员变量：能被所有修饰符修饰，可以使用static关键字
    局部变量：只能被final修饰符修饰，不能使用static关键字修饰，使用final修饰，
在使用之前，必须赋初值
3.生存时间：
    成员变量随着对象的创建而存在，随着垃圾回收而消失，而局部变量随着调用的方法结束而消失（每调用一次
    方法会创建一个栈帧（局部变量存储在栈帧的局部变量表中），方法结束，栈帧出栈，变量失效，这就是为什
    么局部变量只能在方法有效）
4.赋初值：
    成员变量会赋相应的初值，而局部变量必须手动赋初值
注意：数值没超过short的范围（-32768-32767）是和字节码指定存储在一起，而超过这
个范围是存储在常量池中

45.面向对象和面向过程的区别？★★★★

面向过程：着重实现过程，以方法为单位
面向对象：以类为单位，着重于在类的创建上

46.值传递和引用传递的区别？★★★★

值传递：传的基本类型的值
引用传递：传的是引用地址
值传递修改值的内容与原参数没有关系
引用传递修改内容与原参数有关系    

47.类和对象在内存是如何存储的？★★★★

类：类对象只有一个，存储在方法区
对象：存储在堆中    

48.字符串相关面试题★★★★★

package www.git.java;

public class Demo1 {
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a" + "b";
        String s4 = s1 + s2;
        String s5 = "ab";
        String s6 = s4.intern();
        String s7 = new String("a") + new String("b");
        String s8 = s7.intern();
        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//true
        System.out.println(s3 == s6);//true
        System.out.println(s4 == s6);//false
        System.out.println(s4 == s7);//false
        System.out.println(s6 == s8);//true

        String x2 = new String("c") + new String("d");
//        String x1 = "cd";
//        x2.intern();
//        System.out.println(x1 == x2);//false
        x2.intern();
        String x1 ="cd";
        System.out.println(x1 == x2);//true
        //如果调换了位置，如果是1.6呢
        //如果常量池中没有，则会在堆中复制一份到常量池中
    }
}

49.while 和 do while有啥区别?★★

一、跳出循环不同
1、do-while：do-while不可以通过break在循环过程中跳出。
2、while：while可以通过break在循环过程中跳出。
二、执行次数不同
1、do-while：do-while至少会执行一次循环体。
while：while可能会出现一次都不执行循环体的情况。   
三、优先操作不同
1、do-while：do-while优先执行循环体，再判断执行条件是否符合要求。
2、while：while优先判断执行条件是否符合要求，再执行循环体。    

50.普通类和抽象类有什么区别？★★★

1、和普通类比较起来，抽象类它不可以被实例化
2、除了以上的一点之外，抽象类它能够有构造函数，被继承的时候，子类就一定要继承父类的一个构造方法，但是，抽象方法不可以
    被声明成静态。
3、在抽象类当中，可以允许普通方法有主体，抽象方法没有方法体。
4、含有抽象方法的类，必须要申明为抽象类。
5、抽象的子类必须要实现抽象类当中的所有抽象方法，否则的话，这个子类也是抽象类。
6、抽象类它一定要有abstract关键词修饰
7、抽象类的访问权限
#jdk1.8之前，访问权限限制于public和protected,假如不写由或者是是private，那么就不能够被子类继承
#jdk1.8-11将访问的权限变成了public 、protected以及default

51.为什么重写equals()方法的时候重写hashCode()方法？★★★★★

判断两个对象相同，先判断hashCode值，再调用equals判断
    1.如果只重写了equals方法，而不重写hashcode的方法，会造成hashcode的值不同，而equals()方法判断
   		出来的结果为true。
    2.Object中hashcode是根据对象的存储地址转换而形成的一个哈希值。这时候就有可能因为没有重写
   	 	hashcode方法，造成相同的对象散列到不同的位置而造成对象的不能覆盖的问题。

52.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？short s1=1,s2=1;short s3=s1+s2;有错吗？★★★★

Java的基本数据类型转换规则，大的数据类型转换为小的数据类型需要强制转换，反之可以自动转换。
1.第一题：short s1 = 1; s1 = s1 + 1;
	错！ s1 + 1，s1是short类型，1是int型，s1会自动转换为int型的1，与1相加后，得到int型的2，要向左侧的short类型的
        s1看齐，即需要通过强制类型转换。正确写法：s1 = (short) (s1 + 1);
2.第二题：short s1 = 1; s1 += 1;
	正确！ 执行s1+=1;其实执行的是s1 = (short) (s1 + 1); 其中会有一个强制转换的过程。
3.第三题：short s1=1,s2=1;short s3=s1+s2;
	错误！这里是编译器从数据安全方面考虑，如果s1和s2都是较大的short类型数，可能会导致溢出，所以会要求强制转换到int。
        正确写法：short s3 = (int)s1 + s2;

53.RuntimeException与Exception有什么区别？★★★★★

1.RuntimeException是Exception的子类
2.RuntimeException:运行时异常/非检查异常，不需要处理，也能编译成功
  Exception:检查异常/非运行时异常，需要处理，不处理编译不成功        

54.char类型是否可以存储一个汉字？★★★

char类型是两个字节，可以存储一个中文汉字
GBK中的一个中文占3个字节，UTF8中的一个中文占2个字节

55.存储价格使用什么数据类型？★★★★★

在java中使用bigDecimal类型
float:单精度浮点型
double：双精度类型
bigDecimal:巨大的容量实数
float和double是用二进制浮点型进行运算，计算的数据不能完全准确，多用于科学计算和工程计算
bigDecimal:用于商业计算，结果相当精确，计算巨大的整数时，会使用bigInteger

56.String、StringBuffer和StringBuilder的区别？★★★★★

String 和 StringBuffer 、 StringBuilder 的区别：
   1.String是不可变的字符串，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象
   2.而 StringBuffer 、 StringBuilder 可以在原来的字符串上进行操作，所以在经常改变字符串内容的
   情况下最好不要使用 String 。
StringBuffer 和 StringBuilder 最大的区别在于：
	1.StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的。
	2.单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。
	3.StringBuilder 的性能却高于 StringBuffer。

57.Java 中的注释有哪些写法？★★★

单行注释
	单行注释： Java 中最简单的注释方法， 使用两个反斜杠 // 就可以了。注释的内容从 // 开始。
多行注释
	多行注释：Java 中使用以 /* 开始， 以 */ 结束的注释方式。
文档注释
    使用文档注释的方式 以 /** 开头  */ 结尾。包含在这之内的内容就是文档注释的内容。 而且针对文档注释有一系列的标记。
    该注释一般会放在 类、方法、变量、常量上。

58.简单讲一下Java的跨平台原理？★★★★★

1.java虚拟机是一个可以执行java字节码的虚拟机进程
2.将java源代码编译成字节码（class)文件，通过类加载，将字节码文件中的数据加载到运行时数据区，
  执行引擎根据指定的JVM指令将字节码翻译成机器码，再通过CUP去执行，本地类库接口调用其他语言。
3.java虚拟机可以在不同的操作系统上运行，一次编译，多次运行  

59.switch case 支持哪几种数据类型?★★★

基本数据类型：byte,short,char,int
还可以作用于枚举类型和string类型以及包装类型： Byte， Short，Character和 Integer;

60.java中基本数据类型有哪些？什么是装箱和拆箱？★★★★★

Java 中的基本数据类型只有8个：
    byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type），
    剩下的都是引用类型（reference type）。
自动装箱和自动拆箱就是基本数据类型和包装类的互相转换
    自动装箱：int转化为Integer  valueOf()方法
    自动拆箱：Integer转化为int	xxxValue()方法

61. switch 是否能用在 long 上？★★★

交换机在JAVA中不能使用long的根本原因是长时间转换为int将失去精度,导致数据不准确,因此JAVA交换机具有不允许长的逻辑规则。
switch语句中的变量类型可以是:byte,short,int或char和这几个对应的包装类，枚举类型，String类型

高级部分

1.Math.round(-1.5)等于多少？★★★

结果：-1
    ceil（）：向上取整
    floor():向下取整
    round():朝正无穷方向取整

2. BIO、NIO、AIO有什么区别？★★★★★

- BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能
-	 力低。
- NIO：New IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了
-  	 多路复用。
- AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件
-	 和回调机制。

3.java语言和javaScript语言的区别？★★★★

同为类c语言
区别：
    1.java是强类型语言，JavaScript是弱类型语言
    2.java是基于面向对象的语言，javaScript是基于对象和事件驱动的脚本语言
    3.java是编译型语言，JavaScript是解释性语言
    4.java是运行在服务端的静态类型语言，javaScript是运行在浏览器上的动态类型语言

4.java语言和php语言的区别？★★★★

同为类c语言
区别：
    1.java是半编译语言，PHP是脚本语言
    2.java是基于面向对象，以类为单位，PHP基于面向过程，以方法为单位
    3.java的内存自动分配回收，PHP是一次创建一次销毁
java:
 	j2SE:多用于桌面软件开发
    j2EE:多用于企业级开发
	j2ME:多用于嵌入式系统开发        
PHP的优势：
    可以用PHP动态创建图像，程序开发快，运行快，跨平台性强，web方向的编程

5.java中有哪些新特性？★★★★★

接口:增加了default和static修饰的方法
Lambda表达式：Lambda 表达式本质上是一段匿名内部类，类中只有一个方法，也可以是一段可以传递的代码
Stream API：链式操作，操作流可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等
操作
日期时间API：Java 8 对时间分量的操作更加简洁。

`

6.什么是工厂方法？工厂方法有哪些分类？★★★

工厂方法：创建对象的方法
分类：动态工厂和静态工厂    

7.finaly相关面试题 ★★

finally出现了return

public class Demo1 {
    public static void main(String[] args) {
        int result=test();
        System.out.println(result);
    }

    private static int test() {
        try{
            return 10;
        } finally {
            return 20;
        }
    }
}
结果为20

finally对返回值影响

public class Demo1 {
    public static void main(String[] args) {
        int result=test();
        System.out.println(result);
    }

    private static int test() {
        int i = 10;
        try{
            return i;
        } finally {
            i = 20;
        }
    }
}
结果为10

8.数组有没有length()方法？String有没有length(）方法？★

数组是没有length（）这个方法的，有length这个属性，可以计算数组的长度
String是有length（）这个方法的，用来计算字符串的长度。

9.一个”.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？★

Java中可以包含多个类 ，但public修饰的类只有一个，且类名必须与文件名一致

10.泛型和泛型擦除？★★★

泛型：
	泛型在编译时检查类型，泛型的实质是参数化类型
	类型通配符一般是使用？
	<? extends T>:表示该通配符所代表的类型是T类型的子类
	<? super T>:表示该通配符所代表的的类型是T类型的父类
泛型擦除：
	在java的字节码文件中不包含泛型中的类型信息，在使用泛型的时候加上这些参数，会在编译的时候被去掉，
		这个过程就叫做泛型擦除
	这个过程，会找一个具体类型来代替类型参数，这个具体类型通常是object，如果指定了上界，则使用这个
		上界类型

11.main 方法可以被重写和重载吗，可以被调用吗？★★★

main()方法也是普通方法，可以重载
不能被重写，静态方法能被继承，但是不能被重写
可以被调用

12.Java 中相关关键字？★★★

asser:断言,增加 jvm 参数 -ea，默认是关闭的
    assert [boolean 表达式]
    如果[boolean表达式]为true，则程序继续执行。
	如果为false，则程序抛出AssertionError，并终止执行。
instanceof: 是 Java 的保留关键字。
    它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。    
transient:
	Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，
    我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在
    这个域前加上关键字transient。 
native
    用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的     
synchronized
    表明一段代码需要同步执行        
volatile
    表明两个或者多个变量必须同步地发生变化

13.什么时候会发生空指针异常？★★★

1.所谓的指针，就是java中的对象的引用。比如String s;这个s就是指针。
2.所谓的空指针，就是指针的内容为空，比如上面的s,如果令它指向null,就是空指针。
3.所谓的空指针异常，就是一个指针是空指针，你还要去操作它，既然它指向的是空对象，它就不能使用这个对象的方法。
    比如上面的s假如为null,你还要用s的方法，比如s.equals( String x);那么就会产生空指针异常。如果一个
    数组为null，试图访问或修改其中某个元素时。

14.避免空指针异常的办法？★★★★★

1.使用Optional
    Optional 是 JDK 8 新增的新特性，再也不用 != null 来判断了，这个在一个对象里面的多个子对象连续判断的时候非常有用。
2.字符串比较，常量放在前面会出现空指针异常，一种避免的方法就是将常量放在后面，如下：
        if("success".equals(status)){
    }
3.使用null安全的方法库
    比如StringUtils.isBlank()，isNumeric()，isWhiteSpace()。
4.初始化默认值
	返回空集合
	在返回集合的时候如果是null，统一默认返回一个空集合
        public List getUserList(){
        List list = userMapper.gerUserList();
        return list == null ? new ArrayList() : list;
    }
5.断言
	断言是用来检查程序的安全性的，在使用之前进行检查条件，如果不符合条件就报异常，符合就继续。
    assert name == null : "名称不能为空";

15.内部类有哪些？有什么区别？★★★

内部类分为四类：成员内部类、局部类部类、静态内部类、匿名内部类
    静态内部类：内部定义的静态类
    	1.可以访问外部的所有静态方法和变量，即使是private类型
    	2.可以定义静态变量、方法、构造方法等，不能使用非静态的成员，非静态方法也不能访问
    	3.其他类使用内部类的方式通过：“外部类.静态内部类”
    	4.hashMap中就有一个Entry的静态内部类
    	5.随着类的加载而加载，只会执行一次
    成员内部类：定义在内部的非静态类
    	1.成员内部类不能定义静态方法和变量（final修饰的除外）
    	2.因为成员内部类非静态的，类初始化的时候会先初始化静态成员，如果成员内部类定义静态变量，
    	那么成员内部类的静态变量初始化顺序是有歧义的
   		3. 当外部类的成员与内部类的成员重名时，使用外部名.this.成员
    局部内部类：定义在方法中的类
   		1. 当内部类时非static的情况下，在内部类中不能定义static内容
    匿名内部类：没有使用class定义的类
    	1.必须要继承一个父类或者实现一个接口
    	2.匿名内部类是直接使用new来生成一个对象的引用
        3.不能有构造方法
	   	4.不能有静态变量
	  	5.不能有静态方法
   		6. 用法：确认某个类的子类在程序执行过程中，只创建一次对象，则使用匿名内部类

16.Object 类有哪些常用的方法？★★★

Object类方法,是所有类的父类，任何类都默认继承Object。
（1）clone方法
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
（2）getClass方法
final方法，获得运行时类型。
（3）toString方法
该方法用得比较多，一般子类都有覆盖。
（4）finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
（5）equals方法
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
（6）hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定
    就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
（7）wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，
    直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
    （1）其他线程调用了该对象的notify方法。
    （2）其他线程调用了该对象的notifyAll方法。
    （3）其他线程调用了interrupt中断该线程。
    （4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
（8）notify方法
该方法唤醒在该对象上等待的某个线程。
（9）notifyAll方法
该方法唤醒在该对象上等待的所有线程。

17.什么是正则表达式？String类中用到正则的方法有哪些？★★★★★

一套字符串的匹配规则： 
正则表达式：就是一种字符串的匹配规则
[xyz]:等于其中之一
[0-9]：等于0-9其中之一
[a-z]：小写字母等于其中之一
[A-Z]：大写字母等于其中之一
\d：等价于[0-9]
\D：不等价于[0-9]（非数字类）
\w：等价于[0-9a-zA-Z_]
\W：不等价于[0-9a-zA-Z_]（非字符）
\s：空白（回车、换行、制表符）
\S：非空白
()：分组
{}：范围
+：[1-无穷)
*：[0-无穷)
{n}：有n个		\d{n}:有n个0-9的数字
{m,n}：有m到n个		\d{6,10}:有6-10个0-9的数字
{m,}：至少有m个
(xyz|abc)：分组xyz或者abc（(xyz&&abc):）
?：可有可无(+86|+0086)?\d{11} +8613888888888或者13888888888()
|：或者
^,&：分界符，java中会自动添加分界符
^：开始
&：结束
\：转义字符
.：任意一个字符
身份证：'fenString reg="^[1-9]\\d{5}[12]\\d{3}[01]\\d[0123]\\d\\d{3}(\\d|X}）$"

18.Java常用元注解?★

@Target：描述了注解修饰的对象范围常用的包括：
    method：用于描述方法
    pacage：用于描述包
    parameter：用于描述方法变量
    type：用于描述类、接口或enum类型
@Retention: 表示注解保留时间长短
    RetentionPolicy.SOURCE -------------注解将被编译器丢弃
	RetentionPolicy.CLASS -------------注解在class文件中可用，但会被VM丢弃
	RetentionPolicy.RUNTIME ---------VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
@Documented   
    描述在使用 javadoc 工具为类生成帮助文档时是否要保留其注解信息。
@Inherited
	Inherited注解的作用是：使被它修饰的注解具有继承性（如果某个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解）。    

19.Java 泛型中的 T、K、V、E 、N分别指什么？★

E – Element (在集合中使用，因为集合中存放的是元素)
T – Type（Java 类）
K – Key（键）
V – Value（值）
N – Number（数值类型）
? – 表示不确定的java类型（无限制通配符类型）
S、U、V – 2nd、3rd、4th types

20.String拼接字符串底层原理?★★★

jdk1.8之后字符串拼接底层就是创建了一个StringBuilder，然后调用append方法，最后调用toString
转化成String
1、在循环和多个表达式中不能 +，频繁创建 SB 性能影响；
2、在单个表达式中可以用 +，编译器直接做了优化；    

21.为什么成员变量命名不建议用 isXXX？★★★

POJO类中布尔类型的变量，都不要加is,否则部分框架解析会引起序列化错误。
	例如：定义一个变量 boolean isSuccess;的属性，它的方法也是isSuccess(),RPC框架在
    反向解析的时候，以为对应的属性名称是success,导致属性获取不到，进而抛出异常。

22.StringJoiner有什么用？★

StringJoiner是一种收集器，尽管它没有实现Collector接口。 它只是这样表现。 除了可以传递定界符，
前缀和后缀之外，还可以使用StringJoiner调用Collectors.joining(CharSequence)从Stream创建格式化
的输出。

当使用并行流时，这特别有用，因为在某些时候，将需要并行处理的批处理，这就是StringJoiner发生的
地方。StringJoiner是一种收集器，尽管它没有实现Collector接口。 它只是这样表现。 除了可以传递
定界符，前缀和后缀之外，还可以使用StringJoiner调用Collectors.joining(CharSequence)从
Stream创建格式化的输出。

当使用并行流时，这特别有用，因为在某些时候，将需要并行处理的批处理，这就是StringJoiner发生的
地方。

23.怎么查看一个 Java 类的字节码？★★

1、使用 javap 命令查看字节码
 命令格式如下：javap -c xxx.class
2、Intellij IDEA 中查看字节码
 需要安装ByteCode Viewer插件,点击view→Show Bytecode

24.Java 语法糖是什么意思？★

	语法糖指的是计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员
	使用。因为 Java 代码需要运行在 JVM 中，JVM 是并不支持语法糖的，语法糖在程序编译阶段就会被
	还原成简单的基础语法结构，这个过程就是解语法糖
	1.泛型是一种语法糖。在 JDK1.5 中，引入了泛型机制，但是泛型机制的本身是通过类型擦除 来实
		 现的，在 JVM 中没有泛型，只有普通类型和普通方法，泛型类的类型参数，在编译时都会被擦除
    2.泛型是一种语法糖。在 JDK1.5 中，引入了泛型机制，但是泛型机制的本身是通过类型擦除 来实
   		 现的，在 JVM 中没有泛型，只有普通类型和普通方法，泛型类的类型参数，在编译时都会被擦除
    3.枚举只是一个语法糖，在编译完成后就会被编译成一个普通的类，也是用 Class 修饰。这个类
   		 继承于 java.lang.Enum，并被 final 关键字修饰。
    4.方法变长参数（JDK 1.5）
    5.接口Iterable支持的foreach语法（JDK 1.5）
    6.switch支持枚举、字符串        

关注博主，获得更多面试题和干货！