Java初学基础篇——面试题及小知识点总结（持续更新）

面试题

1. 在DOM界面运行java文件
   答案：javac Test.java 使java文件翻译成字节码文件.class然后输入java Test 运行java显示结果。
2. int i = 10000000000；会报错吗？为什么？
   答案：会报错。应为数太大，超过了int类型的范围。
3. 整数有哪几种类型？各占字节？
   答案：btye（1字节）、short（2字节）、int（4字节）、long（8字节）
4. float f = 3.14；会报错吗？为什么？
   答案：会报错。正确的写法为float f = 3.14f；
   eg：long a = 1000000000000000L；
5. B（brower）/S（server）和C（client）/S（server）架构区别是什么？
   答案：B/S是浏览器和服务器 C/S是客户端和服务器
6. java中有哪些基本数据类型？
   答案：
   基本数据类型：
   整型：byte、short、int、long
   浮点型：float、double
   字符型：char
   布尔型：blooean
   引用数据类型：
   字符串：string

详解图：

7. int t = 5
int r = ++t + t++ + ++t + ++t；
答案：从左到右依次按照运算符优先级进行计算
eg:++t 自增也带值 t++ 自增不带值
int t = 6
int r = 6 + t++ + ++t + ++t；
int t = 7
int r = 6 + 6 + ++t + ++t；
int t = 7
int r = 12 + ++t + ++t；
int t = 8
int r = 12 + 8 + ++t；
int t = 8
int r = 20 + ++t；
int t = 9
int r = 20 + 9；
int t = 9
int r = 29；
输出 t = 9 r = 29
8. short s = 1；s +=1；会报错吗？s = s +1；会报错吗？为什么？
答案：s +=1不会报错。s = s +1会报错，应为等号后面的s是short类型，1是int类型，计算的时候btye、short类型自动转换为int类型，而等号左边的s是short类型。类型不统一，不等赋值。
9. 8*2的最快的运算方式是什么？
答案：位运算。左移一位
eg：对于正整数而言，左移一位相当于放大2倍，右移一位相当于缩小2倍。
10.System.out.print(5>3?9:3.1)；输出值为？
答案：输出为：9.0
11. switch可以跟那些数据类型？
答案：3整2字1枚举
eg：byte、short、int、char、String、enmu
12. char = ‘72’ 会报错吗？
答案：char后面只能跟单引号引起来的占位为1的字符。
eg：char = ‘7’就可以。
13. 写出五种常见异常

数组越界。 IndexOutOfBoundsException
类转换异常。IndexOutOfBoundsException
输入输出异常。IOException
空指针异常。NullPointerException
安全权限异常。IllegalAccessException

14.冒泡排序

package trainday004;

public class TextMaoPao {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
       int [] num = {12,3,23,34,22,67,4,87,92,47,9,28};
       for(int j = 0;j<num.length;j++){
    	   for(int i=0;i<num.length-1;i++){
        	   if(num[i]>num[i+1]){
        		   int c;
        		   c=num[i+1];
        		   num[i+1]=num[i];
        		   num[i]=c;
        	   }
           }
       }
    	for(int i = 0 ;i<num.length;i++){
    		System.out.print(num[i]+" ");
    	}
	}

}

15.java的三大特性
封装 ，继承，多态

16.重写和重载的区别
都用于继承中，重写时方法名不变，参数也不变，只要方法体改变，覆盖父类方法；
重载是指构造方法同名不同参，

17.this super
this 调用本来中构造方法的参数
super 调用父类中构造方法的参数

18.final的用法
一个类如果你没有定义它的父类，则默认继承Object final:修饰属性表示内容不能更改，而且必须初始化
fianl属性初始化：
1.定义属性直接赋值
2.在构造器中初始化（为了抱在这个对象在创建完的时候这个final属性必须有初始值）
final:修饰方法表示这个方法不能被重写
final:修饰类表示这个类不能被继承

19.栈和堆的区别
一、堆栈空间分配区别：
　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值 等。其操作方式类似于数据结构中的栈；
　　2、堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。
二、堆栈缓存方式区别：
　　1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；
　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
三、堆栈数据结构区别：
　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；
　　栈（数据结构）：一种先进后出的数据结构。

20.访问修饰符
在这里插入图片描述

21.抽象类和接口的区别
接口的所有方法都是抽象的，默认系统加上public abstract关键字，抽象类里面的方法是可以抽象的也可以具体的

接口和抽象类都不能实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承然后实例化子类

抽象类只能单继承，接口可以单继承/多继承接口，接口还可以多实现

接口中的属性是static final类型的，抽象类中的属性跟普通类中的属性没有区别

接口中的方法默认就是抽象的(public abstract)，不需要加abstract，抽象类中的抽象方法需要加abstract关键字

22.父类跟子类的静态代码块，普通代码块，构造方法的执行顺序
父类静态代码块-- 子类静态代码块-- 父类匿名代码块-- 父类构造器-- 子类匿名代码块-- 子类构造器

其中静态代码块在初始化时会被调用，但是匿名代码块与构造器只有在创建对象时才会调用。

23.请列出五个类，五个包
java.long —java.Math----java.util

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

final
修饰变量：必须在声明时给定初值，而在以后的引用中只能读取，不可修改
修饰方法：只能使用，不能重载
修饰类：不能派生子类，即不能作为父类被继承

finally
再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块(如果有的话)

finalize
Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

25. == 跟equals的区别？
    = =用在基本数据类型中是来比较两个数值是否相等，而用在引用数据类型中，
    指向的对象在内存中的存储地址，并不是“值”本身，所以不能用来比较值的大小

euqals 用来比较指向的字符串对象所存储的字符串是否相等,不能用在基本上数据类型上面

总结来说：
1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

26，创建对象有几种方式？new clone
27, System.out.println(Math.round(-3.5))
28,String StringBuffer StringBuilder区别？
29, 浅谈一下String, StringBuffer，StringBuilder的区别？
30、下面的代码将创建几个字符串对象？
String s1 = new String(“Hello”);
String s2 = new String(“Hello”);

31、在java中，String s=new String("xyz");创建了几个对象？（ ）
A   1个    B 1个或2个      C  2个     D 以上都不对

32、下面的代码输出什么？
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));   


33、下面的代码输入什么？
String s1 = "abc";
String s2 = new String("abc");
s2.intern();
System.out.println(s1 ==s2);

34、下面的代码输出什么？
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); 


35、下面的代码输出什么？
String str1 = "ab" + "cd"; 
String str11 = "abcd";   
System.out.println("str1 = str11 : "+ (str1 == str11)); 

36、下面的代码输出什么？
String str2 = "ab"; 
String str3 = "cd";
String str4 = str2+str3;  
String str5 = "abcd"; 
System.out.println("str4 = str5 : " + (str4==str5));

37、下面的代码输出什么？
final String str2 = "ab"; 
final String str3 = "cd";
String str4 = str2+str3;  
String str5 = "abcd"; 
System.out.println("str4 = str5 : " + (str4==str5));

38、下面的代码输入什么？
String str6 = "b";  
String str7 = "a" + str6;  
String str67 = "ab";  
System.out.println("str7 = str67 : "+ (str7 == str67));  

39、下面的代码输入什么？
 final String str8 = "b";  
String str9 = "a" + str8;  
String str89 = "ab";  
System.out.println("str9 = str89 : "+ (str9 == str89));  

40、String s1=”Hello”; String s2=”hello”; String s3=s1.toLowerCase(); String s4=s2.toLowerCase();
下面选项结果为true的是：
A.S1==s3	
B.S2==s3
C.S2==s4	
D.S3==s4


41。Math.round(5.5)、Math.round(-5.5)分别输出多少？
42。
	Integer i1 = 1 ;
	Integer i2 = 1 ;
	Integer i3 = 128 ;
	Integer i4 = 128 ;		
	System.out.println(i1 == i2);   
	System.out.println(i3 == i4);   
	
43，ArrayList元素用循环全部删除。
44，说下java中的集合？
45，ArrayList跟Vector的区别？
46，List Set  Map的区别？
47，说下HashTable  HashMap的区别？
48，HashMap（HashSet）用来装学生，人数在37-43人左右，请问如何初始化HashMap数量达到性能最优？
49，重写equals是否需要重写hashcode？ 重写hashcode是否需要重写equals？	 
50，说下数组跟链表的区别？
51，throw跟throws区别？

答案

1. javac 把代码编译为字节码文件(.class) java运行.class文件

2. 会报错，int数值范围正负21亿左右

3. byte(1字节) short(2字节) int(4字节) long(8字节) int有4个字节

4. 会报错，3.14后面应该加上f(float f = 3.14f)

5. B/S是浏览器和服务器 C/S是客户端和服务器

6. byte short int long float double char boolean

7. 29

8. s +=1不会报错。s = s +1会报错，应为等号后面的s是short类型，1是int类型，计算的时候btye、short类型自动转换为int类型，而等号左边的s是short类型。类型不统一，不能赋值。

9. 位运算。左移一位

10. 输出为：9.0

11. 3整2字1枚举 eg：byte、short、int、char、String、enmu

12. char后面只能跟单引号引起来的占位为1的字符。

13. 数组越界。IndexOutOfBoundsException
    类转换异常。IndexOutOfBoundsException
    输入输出异常。IOException
    空指针异常。NullPointerException
    安全权限异常。IllegalAccessException

14. 两层循环比较相邻两数大小交换大的到右边，最大的到数组最后，相当于吐了一个泡。

15. 封装、继承、多态

16. 都用于继承中。重写是方法名相同、参数列表相同、只有方法体改变，覆盖父类方法。重载是方法名相同，参数列表不同，方法体不同。

17. this表示调用本类构造方法中的参数 super表示调用父类构造方法中的参数

18. final修饰属性的时候表示常量，该属性不可更改，而且必须被初始化。final修饰方法的时候表示该方法不能被重写。final修饰类的时候表示该类不能被继承。

19. 栈空间的内存是由系统自动分配，一般存放局部变量，比如对象的地址等值，不需要程序员对这块内存进行管理。先进后出。
    堆空间的内存是动态分配的，一般存放对象，并且需要手动释放内存。先进先出。

20. 访问修饰符 public > protected > (default)不写 > private
    同一个类 是 是 是 是
    同包 是 是 是 是
    继承关系 是 是 否 否
    没有关系 是 否 否 否

21. 接口的所有方法都是抽象的。抽象类里即可以做方法的声明也可做方法的实现
    接口和抽象类都不能实例化，接口需要类来实现后实例化实现类，抽象类需要类来继承然后实例化子类
    抽象类只能单继承，接口可以单继承/多继承接口，接口还可以多实现
    接口里面的变量都是公用的静态的，抽象类里面的都是普通变量

22. 父类>子类 静态>非静态 代码块>构造方法

23. 类：Date、Class、System、List、HashMap、Arrays
    包：java.util java.sql java.io java.Math java.lang

24. final是常量修饰符。finally是在异常处理机制中的，无论有无异常被抛出、捕获，finally都会被执行。finalize是方法名，被定义在Object类中，在垃圾回收时对内存中的资源进行整理的方法

25. ==用在基本数据类型的比较中，比较对象是两个对象时比较的事地址值
    equals是用于引用数据类型的比较，不能用在基本数据类型中去。

26. 目前学习的有常用的new方法来创建对象，clone方法穿件对象，需要实现Cloneable接口，重写clone方法。

27. -3

28. String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象，
    而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作，StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的，
    但 StringBuilder 的性能却高于 StringBuffer

29. 只要new一个字符串就有会在常量池里创建一个字符串对象，堆里也有一个

30. for (int i = list.size() - 1; i >= 0; i–) {
    list.remove(i);
    }
    or
    for (int i = 0;i<list.size()😉 {
    list.remove(i);
    }

31. B

32. false true

33. false

34. false true false true true

35. true

36. false

37. true

38. false

39. true

40. C

41. 6 -5

42. true false

43. for (int i = list.size() - 1; i >= 0; i–) {
    list.remove(i);
    }

44. ArrayList Vector
    HashMap HashTable TreeMap
    HashSet Treeset
    LinkedMap

45. Vector 线程安全 ArrayList 线程不安全
    ArrayList 在性能方面要优于 Vector。
    ArrayList 和 Vector 都会根据实际的需要动态的调整容量，
    只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。

46. List表示有先后顺序的集合，Set里面不允许有重复的元素，

47. 存储： HashMAP允许key和value为null，而Hashtable不允许
    线程安全： HashMAP是非线程安全的 Hashtable是线程安全的

48. 64 2的幂次方

49. 需要

50. （1）数组的元素个数是固定的,而组成链表的结点个数可按需要增减;

    （2）数组元素的存诸单元在数组定义时分配，链表结点的存储单元在程序执行时动态向系统申请:

    （3）数组中的元素顺序关系由元素在数组中的位置(即下标)确定,链表中的结点顺序关系由结点所包含的指针来体现。

    （4）对于不是固定长度的列表,用可能最大长度的数组来描述，会浪费许多内存空间。

    （5）对于元素的插人、删除操作非常频繁的列表处理场合,用数组表示列表也是不适宜的。若用链表实现，会使程序结构清晰，处理的方法也较为简便。
    与数组的区别 从增删改查操作的效率上来谈
    增删 链表的效率更高 改查 数组的效率更高

51. throw 是在方法体中主动抛出一个异常
    throws 把异常往上抛 谁调用谁处理