Java面试题——JavaSE阶段（1）

1. javac java命令

要知道java是分两部分的：一个是编译，一个是运行。

**javac：**负责的是编译的部分，当执行javac时，会启动java的编译器程序。  
对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。  
也就是class文件，也就是java的运行程序。

**java：**负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.

2. int i=100000000000；会报错吗 为什么？

会报错
整型字面量默认为int类型；     
注意 long i =100000000000也是会编译报错的，因为10000～默认是int类型，但是已经溢出了；
int类型的范围大约在21亿多

3. 整数有哪几种类型？int几个字节？

整型：byte int short long
字节：1	2	4		8

4. float f = 3.14;报错吗 为什么？

会报编译错误，浮点常量默认为double类型

​

5. B（brower）/S(server) 跟C（client）/S（server）架构区别是什么？

	C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。  客户端需要安装专用的客户端软件。
  
	B/S是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，  服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。用户界面完全通过WWW浏览器实现，主要事务逻辑在服务器端实现。浏览器通过Web Server 同数据库进行数据交互。

6. java中有哪些基本数据类型？

java基本数据类型一共8种
整型：	 byte(1)，short(2)，int(4)，long(8)
浮点型：float(4)，double(8)
字符：  char
布尔：  boolean

7. int t = 5 ; int r = ++t + t++ + ++t + ++t ;System.out.println®;

自增，自减
++t 是先自增1，再返回值，相当于
    t = t + 1;
    return t; 
t++ 是先返回值，再自增1，相当于
	return t; 
	t = t + 1;
上述表达式结果应该为：int r = 6 + 6 + 8 + 9;  即29

8. short s = 1 ;s += 1;会报错吗？s = s+1 ;会报错吗？为什么？

前一个不会报错，后一个会报错
byte,short在运算时,会自动提升到int类型再运算
此时赋值号右边的结果类型是一个int类型，而左边的s是定义的short类型，大精度的赋值给小精度的必须强转
后一句不报错，因为s += 1;相当于s = (short)(s + 1);

9. 8*2最快的运算方式是什么？

位运算,左移<<
8<<2

10. System.out.println(5>3?9:3.1);

输出结果为9.0
三目运算符，判断结果为true就返回第一个表达式的值，但是另一个表达式的类型会影响前面的，最后输出的结果类型总是两个表达式中类型大的一个，有一个自动转换的过程

11. switch可以跟哪些数据类型？ 3整2字1枚

3整：byte，short，int
2字：字符char，字符串String
1枚：枚举
扩展：
    在JDK1.5之前,switch循环只支持byte short int char四种数据类型.

    JDK1.5 在switch循环中增加了枚举类与byte short char int的包装类------》对四个包装类的支持是因为java编译器在底层手动进行拆箱,而对枚举类的支持是因为枚举类有一个ordinal方法,该方法实际上是一个int类型的数值.

    JDK1.7在switch循环中增加了String类型-------》但实际上String类型有一个hashCode算法,结果也是int类型.

    而byte short char类型可以在不损失精度的情况下向上转型成int类型.所以总的来说,可以认为switch中只支持int.

12. char c=‘72’ OK吗？

错误
字符类型长度为1，要么直接char c = 72;或者char c = '7';

13. 写出5个异常类

ArrayIndexOutOfBoundsException:数组索引越界，即数组下标超出数组的范围
NullPointerException:空指针异常，一般出现在引用数据类型中值为空，却调用了其方法
ClassCastException: 类型强制转换异常
ArithmeticException:算术运算异常，比如分母为0的情况
StackOverflowError:堆栈溢出错误,比如一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误

14. 冒泡排序

public class BubbleSort {
    public void bubbleSort(Integer[] arr, int n) {
        if (n <= 1) return;       //如果只有一个元素就不用排序了
 
        for (int i = 0; i < n; ++i) {
            // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {        //此处你可能会疑问的j<n-i-1，因为冒泡是把每轮循环中较大的数飘到后面，
                // 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少
                if (arr[j] > arr[j + 1]) {        //即这两个相邻的数是逆序的，交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;//没有数据交换，数组已经有序，退出排序
        }
    }
 
    public static void main(String[] args) {
        Integer arr[] = {2, 4, 7, 6, 8, 5, 9};
        SortUtil.show(arr);
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.bubbleSort(arr, arr.length);
        SortUtil.show(arr);
    }

15. java的3大特性

一、继承：　　　　
    * 继承是从已有类得到继承信息创建新类的过程。
    * 提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。
    * 继承让变化中的软件系统有定的延续性，同时继承也是封装程序中可变因素的重要手段。
二、封装：
    * 通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。
    * 我们在类中编写的方法就是对实现细节的一种封装，编写一个类就是对数据和数据操作的封装。
    * 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。
三、多态：
* 允许不同子类型的对象对同一消息作出不同的响应。　　　
* 多态性分为编译时的多态性和运行时的多态性：
　　　　　　　方法重载（overload）实现的是编译时的多态性（也称为前绑定）　　　　　　　　　　　　　　
　　　　　　　方法重写（override）实现的是运行时的多态性（也称为后绑定）
　　　　　　　　　　1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
　　　　　　　　　　2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）
　　　　　　　　　　
默认是前三种，如果是四种的话，那就是抽象。
*四、抽象
	抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。

16. 重写跟重载的区别

	重载（Overload）是让类以统一的方式处理不同类型数据的一种手段，实质表现就是多个具有不同的参数个数或者类型的同名函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准）同时存在于同一个类中，是一个类中多态性的一种表现（调用方法时通过 <!--传递不同参数个数和参数类型--!> 来决定具体使用哪个方法的多态性）。
	重写（Override）是父类与子类之间的多态性，实质是对父类的函数进行重新定义，如果在子类中定义某方法与其父类有相同的名称和参数则该方法被重写，不过子类函数的访问修饰权限不能小于父类的；若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，如需父类中原有的方法则可使用 super 关键字。

重载规则：必须具有不同的参数列表； 可以有不同的返回类型；可以有不同的访问修饰符；可以抛出不同的异常。

重写规则：参数列表必须完全与被重写的方法相同，否则不能称其为重写；返回类型必须一直与被重写的方法相同，否则不能称其为重写；访问修饰符的限制一定要大于等于被重写方法的访问修饰符；重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常，譬如父类方法声明了一个检查异常 IOException，在重写这个方法时就不能抛出 Exception，只能抛出 IOException 的子类异常，可以抛出非检查异常。

17. this super关键字

this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
	1.普通的直接引用
	2.形参与成员名字重名，用this来区分：
	3.引用构造函数
super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
	1.普通的直接引用
	2.子类中的成员变量或方法与父类中的成员变量或方法同名
	3.引用构造函数

class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("codersai"); 
       cn = new Chinese("codersai", 18); 
    } 
}

18. final的用法

1.修饰数据：
	用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值，常量
2.修饰方法参数：
	在我们编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，我们不会（实际上是不能）改变参数的值
3.修饰方法：用final关键字修饰方法，它表示该方法不能被重写(覆盖)
4.修饰类：	用final修饰的类是无法被继承的。

19. 堆跟栈的区别

	栈内存:栈内存首先是一片内存区域，存储的都是局部变量，凡是定义在方法中的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

	堆内存:存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，Java有垃圾回收机制不定时的收取。
	
	堆与栈的区别很明显：

		1.栈内存存储的是局部变量而堆内存存储的是实体；

		2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；

		3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

20. 请说下访问修饰符

	public	protected	（默认）不写	private
同一个类中（自己）	√	√	√	√
同包不同类（邻居）	√	√	√	—
继承关系（儿子）	√	√	—	—
无关系（陌生人）	√	—	—	—

“自己 > 邻居 > 儿子 > 陌生人”

21. 接口跟抽象类的区别

1.接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现）， 抽象类可以有非抽象的方法 
2.接口中的实例变量默认是 final类型的，而抽象类中则不一定 
3.一个类可以实现多个接口，但最多只能实现一个抽象类 
4.一个类实现接口的话要实现接口的所有方法，而抽象类不一定 
5.接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说， 抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

备注:在 JDK8 中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。 如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错。

22. 父类跟子类的静态代码块、代码块、构造方法执行顺序。

静态，先父后子，先代码块，后构造方法
先后顺序是
父类静态代码块 子类静态方法
父类代码块，父类构造方法
子类代码块 子类构造方法

23. 请列出5个类 5个包。

java.lang包：java的核bai心类库，包含了运行java程序必du不可少的系统类，如基本数据zhi类型、基本数学函数、字符串处理、dao线程、异常处理类等，系统缺省加载这个包

java.io包: java语言的标准输入/输出类库，如基本输入/输出流、文件输入/输出、过滤输入/输出流等等

java.util包: Java的实用工具类库Java.util包

java.sql包: 该包提供了使用Java语言访问并处理存储在数据源（通常是一个关系型数据库）中的数据API。

java.net包: 该包提供实现网络应用与开发的类

String,Date,File,HashMap,Integer

24. final,finally,finalize的区别是什么？

final用于声明属性,方法和类,分别表示属性不可变,方法不可(重写)覆盖,类不可继承
finally是异常处理语句结构的一部分,表示总是执行
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。JVM不保证此方法总被调用

25. == 跟equals的区别？

1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址

2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

26. 创建对象有几种方式？new clone

第一种，也是最常用、一直接触到的方法：通过new 创建对象。这种方法需要用到构造器
　　  Demo demo1=new Demo();
 　　 Demo demo2=new Demo(1，"有参构造器");

第二种，比较常用的的方法：通过反射 newInstance()创建对象。这种方法用到构造器
　　	Demo demo2=(Demo) Class.forName("Demo").newInstance();

第三种，通过Object类的clone方法。需要实现Cloneable接口，重写object类的clone方法。无论何时我们调用一个对象的clone方法，jvm就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。（原型模式）
　　	Demo demo4=(Demo) demo2.clone();

第四种，反序列化。java 中常常进行 JSON 数据跟 Java 对象之间的转换，即序列化和反序列化。
当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象，在反序列化时，JVM创建对象并不会调用任何构造函数。为了反序列化一个对象，我们需要让我们的类实现Serializable接口，虽然该接口没有任何方法。不会调用任何构造函数

27. System.out.println(Math.round(-3.5))

输出结果为-3
Math.round()方法  操作数加0.5然后向下取整

28. String、StringBuffer、StringBuilder的区别

String的长度是不可变的 ,  StringBuffer和StringBuilder的长度是可变的。
StringBuffer 安全 效率低
**StringBuilder 不安全 效率高**		一般使用StringBuilder

详情请看博客

29. 下面的代码将创建几个字符串对象？

String s1 = new String(“Hello”);
String s2 = new String(“Hello”);

3个
s1,s2,"Hello"
所有的字面值都是存放在常量池中的。 特别注意的是"Hello"这个字符串常量也是在常量池中的。  
如果一个程序出现多个"Hello"，那么常量池中也只会有一个。  
另外，也正是因为"Hello"存放在常量池中，使得一些字符串的==比较变的需要琢磨了。

30. 在java中，String s=new String(“xyz”);创建了几个对象？（ ）

A 1个 B 1个或2个 C 2个 D 以上都不对

B
如果常量池中已经存在"xyz"字符串常量，则只会创建1个s指向"xyz";如果没有，会创建两个对象:s和"xyz"

31. 下面的代码输出什么？

String s1 = new String(“abc”);
String s2 = new String(“abc”);
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

false		==比较的是两个对象的地址
true		String类重写了equals方法，比较的是两个字符串中的值是否相等

32. 下面的代码输入什么？

String s1 = “abc”;
String s2 = new String(“abc”);
s2.intern();
System.out.println(s1 ==s2);

false		intern()方法返回字符串对象的规范化表示形式，变成小写。s1的"abc"放在常量池中，后一句new放在堆中，两个字符串的值虽然相同，但s1,s2指向的地址不同，所以不相等

33. 下面的代码输出什么？

String s1= “abc”;
String s2= “abc”;
String s3 = new String(“abc”);
String s4 = new String(“abc”);
System.out.println("s3 == s4 : "+(s3 == s4));
System.out.println("s3.equals(s4) : "+(s3.equals(s4)));
System.out.println("s1 == s3 : "+(s1 == s3));
System.out.println("s1.equals(s3) : "+(s1.equals(s3)));
System.out.println(s1==s2);

false
true
false
true
true