您的位置: 首页  >  文章  >  Java常见笔试及面试考点总结

Java常见笔试及面试考点总结

分类: 文章 • 2025-04-16 12:53:34

1、Java的三大特性及简介

封装（信息隐藏）：属性来描述同一类事物的特征，方法描述操作，将之归到一个类中，称为封装。

好处：①实现了专业的分工。②信息隐藏。

继承：实现了代码的复用。其中的子类与父类是一般化和特殊化的关系。

多态：子类以父类的身份出现需要向上转型（upcast），其中向上转型是由JVM自动实现的。但向下转型（downcast）是不安全的，需要强制转换。

向上转型实例（指向子类对象，但会遗失父类中没有的方法）

[java] view plain copy
  1. public class Person {  
  2.     int age;  
  3.     int height;  
  4.     int sex;  
  5.       
  6.     void doThing(){  
  7.         System.out.println("method is doThing");  
  8.     }  
  9.     void walk(){  
  10.         System.out.println("method is walk");  
  11.     }  
  12.     void say(){  
  13.         System.out.println("method is say");  
  14.     }  
  15. }  
[java] view plain copy
  1. public class Teacher extends Person{  
  2.     void walk(){  
  3.         System.out.println("person is walking");  
  4.     }  
  5.     void teach(){}  
  6. }  

[java] view plain copy
  1. Person p = new Teacher();  
  2. p.walk();  
输出结果为：person is walking

因为p实际上指向的是一个子类对象，此时，Java虚拟机会自动识别出调用哪个具体的方法。不过，由于向上转型，p对象会遗失和父类不同的方法。例如teach()。

备注：

①一个接口可以继承多个接口。

interface C extends A,B{}

②一个类可以实现多个接口

class D implements A,B,C{}

③一个类只能继承一个类，不能继承多个类

class B extends A{}

④在继承类的同时，也可以继承接口

class E extends D implements A,B,C{}

3.synchronized关键字

Java支持多线程，为解决线程并发的问题，引入了synchronized同步块和volatile关键字。

3.1 修饰一个代码块或修饰方法（类似，见4中volatile关键字中实例）

参考：http://blog.****.net/luoweifu/article/details/46613015

一个线程访问一个对象中的synchronized（this）同步代码块时，其他试图访问该对象的线程将被阻塞。

例1：

[java] view plain copy
  1. package sync;  
  2.   
  3. public class SyncThread implements Runnable{  
  4.     private static int count;  
  5.     public SyncThread() {  
  6.         count = 0;  
  7.     }  
  8.     @Override  
  9.     public void run() {  
  10.         synchronized (this) {  
  11.             for(int i=0;i<3;i++){  
  12.                 try{  
  13.                     System.out.println(Thread.currentThread().getName() + ":" + (count++));  
  14.                     Thread.sleep(100);  
  15.                 }catch(InterruptedException e){  
  16.                     e.printStackTrace();  
  17.                 }  
  18.             }  
  19.         }  
  20.     }  
  21.       
  22. }  
[java] view plain copy
  1. package sync;  
  2.   
  3. public class Main_sync {  
  4.   
  5.     public static void main(String[] args) {  
  6.         SyncThread syncThread = new SyncThread();  
  7.         Thread thread1 = new Thread(syncThread, "SyncThread1");  
  8.         Thread thread2 = new Thread(syncThread, "SyncThread2");  
  9.         thread1.start();  
  10.         thread2.start();  
  11.     }  
  12.   
  13. }  
输出为：

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread2:3
SyncThread2:4
SyncThread2:5

两个并发线程（thread1和thread2）访问同一个对象（syncThread）中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块后才能执行该代码块。

3.2 一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

总结如下：

A.无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象是同一把锁。

B.每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的这段代码。

C.实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

参考：http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

例：

100个线程访问一个共享变量，每次加1，访问结束后，变量值为100；

例2：

[java] view plain copy
  1. package thread_sync_demo;  
  2.   
  3. public class Money {  
  4.       
  5.     int i;  
  6.       
  7.     public Money(){}  
  8.     public Money(int i){  
  9.         this.i = i;  
  10.     }  
  11.     public void addMoney(){  
  12.         i++;  
  13.     }  
  14.     public int getMoney(){  
  15.         return i;  
  16.     }  
  17. }  
[java] view plain copy
  1. package thread_sync_demo;  
  2.   
  3. public class MoneyOperator implements Runnable{  
  4.   
  5.     private Money money;  
  6.       
  7.     public MoneyOperator(Money money) {  
  8.         this.money = money;  
  9.     }  
  10.       
  11.     @Override  
  12.     public void run() {  
  13.         // TODO Auto-generated method stub  
  14.         synchronized (money) {  
  15.             try {  
  16.                 Thread.sleep(10);  
  17.             } catch (Exception e) {  
  18.                 // TODO: handle exception  
  19.             }  
  20.             money.addMoney();  
  21.             System.out.println(Thread.currentThread().getName()+":"+money.getMoney());  
  22.         }  
  23.     }  
  24.   
  25. }  
[java] view plain copy
  1. Money money = new Money(0);  
  2. for (int i = 0; i < 100; i++) {  
  3.      new Thread(new MoneyOperator(money),"thread"+i).start();  
  4. }  
最终实例money中变量i变为100.

例3：

[java] view plain copy
  1. public class Counter {  
  2.    
  3.     public volatile static int count = 0;  
  4.    
  5.     public static void inc() {  
  6.    
  7.         //这里延迟1毫秒，使得结果明显  
  8.         try {  
  9.             Thread.sleep(1);  
  10.         } catch (InterruptedException e) {  
  11.         }  
  12.    
  13.         count++;  
  14.     }  
  15.    
  16.     public static void main(String[] args) {  
  17.    
  18.         //同时启动1000个线程，去进行i++计算，看看实际结果  
  19.    
  20.         for (int i = 0; i < 1000; i++) {  
  21.             new Thread(new Runnable() {  
  22.                 @Override  
  23.                 public void run() {  
  24.                     Counter.inc();  
  25.                 }  
  26.             }).start();  
  27.         }  
  28.    
  29.         //这里每次运行的值都有可能不同,可能为1000  
  30.         System.out.println("运行结果:Counter.count=" + Counter.count);  
  31.     }  
  32. }  
运行结果为：Counter.count = 992，可能每次运行结果都会变。

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图描述这写交互

Java常见笔试及面试考点总结

read and load 从主存复制变量到当前工作内存
use and assign  执行代码，改变共享变量值 
store and write 用工作内存数据刷新主存相关内容

其中use and assign 可以多次出现

但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

例4：两个线程的交替执行，也涉及到了对象锁，两个线程的等待与执行均由该对象操作，所以应使用synchronized。

写两个线程，一个线程打印1-52，另一个线程打印A-Z，打印顺序为12A34B56C……5152Z。

注：分别给两个对象构造一个对象O，数字每打印两个或字母每打印一个就执行O.wait();

[java] view plain copy
  1. package thread_sync_demo;  
  2.   
  3. public class NumberThread extends Thread{  
  4.     private Object obj;  
  5.     public NumberThread(Object obj){  
  6.         this.obj = obj;  
  7.     }  
  8.     @Override  
  9.     public void run() {  
  10.         synchronized (obj) {  
  11.             for(int i=1;i<53;i++){  
  12.                 System.out.print(i);  
  13.                 if(i%2==0){  
  14.                     obj.notifyAll();  
  15.                     try {  
  16.                         obj.wait();  
  17.                     } catch (InterruptedException e) {  
  18.                         e.printStackTrace();  
  19.                     }  
  20.                 }  
  21.             }  
  22.         }  
  23.     }  
  24. }  
[java] view plain copy
  1. package thread_sync_demo;  
  2.   
  3. public class LetterThread extends Thread{  
  4.     private Object obj;  
  5.     public LetterThread(Object obj){  
  6.         this.obj = obj;  
  7.     }  
  8.     @Override  
  9.     public void run() {  
  10.         synchronized (obj) {  
  11.             for(int i=0;i<26;i++){  
  12.                 System.out.print((char)('A'+i)+"");  
  13.                 obj.notifyAll();//打印一个字母就会唤醒其他线程，并当前对象处于等待状态  
  14.                 //notifyAll();唤醒在此对象监视器上等待的所有线程。  
  15.                 if(i!=25){  
  16.                     try {  
  17.                         obj.wait();//当前线程等待  
  18.                     } catch (InterruptedException e) {  
  19.                         e.printStackTrace();  
  20.                     }  
  21.                 }  
  22.             }  
  23.         }  
  24.     }  
  25. }  
[java] view plain copy
  1. public static void main(String[] args) {  
  2.     Object obj = new Object();    
  3.     LetterThread letterThread = new LetterThread(lock);  
  4.     NumberThread numberThread = new NumberThread(lock);  
  5.     numberThread.start();  
  6.     letterThread.start();  
  7. }  
补充如下：

[java] view plain copy
  1. public void method(SomeObject so){  
  2.   synchronized(so){  
  3.     //..  
  4.   }  
  5. }  

这时，锁就是so这个对象，每个对象对应一个唯一的锁，所以哪个线程拿到这个对象锁谁就能够运行他控制的那段代码。当有一个明确的对象作为锁时，就能够这样写程式，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的Instance变量来充当锁：

[java] view plain copy
  1. private byte[] lock = new byte[0];   
  2.   
  3.     Public void method(){    
  4.            synchronized(lock)  
  5.            {  
  6.                //  
  7.            }  
  8.     }     
零长度的byte数组对象创建起来将比任何对象都经济--查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

4.关键字volatile

4.1 内存模型的相关概念

大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。
也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个简单的例子，比如下面的这段代码：
[java] view plain copy
  1. i = i+1;  

当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。

　　这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题了。在多核CPU中，每条线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，其实也会出现这种问题，只不过是以线程调度的形式来分别执行的）。本文我们以多核CPU为例。

　　比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？

　　可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。

　　最终结果i的值是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。

　　也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

　　为了解决缓存不一致性问题，通常来说有以下2种解决方法：

　　1）通过在总线加LOCK#锁的方式

　　2）通过缓存一致性协议

　　这2种方式都是硬件层面上提供的方式。

　　在早期的CPU当中，是通过在总线上加LOCK#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK#锁的话，也就是说阻塞了其他CPU对其他部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。比如上面例子中 如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了LCOK#锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。

　　但是上面的方式会有一个问题，由于在锁住总线期间，其他CPU无法访问内存，导致效率低下。

　　所以就出现了缓存一致性协议。最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。如下图所示：

Java常见笔试及面试考点总结

4.2 并发编程中的三个概念

原子性、可见性、有序性
原子性：一个操作或多个操作，要么全部执行并且执行执行的过程不会被任何因素打算，要么就都不执行。经典的银行转账问题。
可见性：多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
例如：
[java] view plain copy
  1. //线程1执行的代码  
  2. int i = 0;  
  3. i = 10;  
  4. //线程2执行的代码  
  5. j = i;  

假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.

这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：
[java] view plain copy
  1. int i = 0;  
  2. boolean flag = false;  
  3. i = 1;//语句1  
  4. flag = true;//语句2  

上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

[java] view plain copy
  1. int a = 10;//语句1  
  2. int r = 2;//语句2  
  3. a = a + 3;//语句3  
  4. r = a*a;//语句4  
这段代码有4个语句，那么可能的一个执行顺序是：
2->1->3->4

那么可不可能是这个执行顺序呢： 语句2   语句1    语句4   语句3

不可能，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

4.3 深入剖析volatile关键字

①volatile关键字的两层语义

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

先看一段代码，假如线程1先执行，线程2后执行：

[java] view plain copy
  1. //线程1  
  2. boolean stop = false;  
  3. while(!stop){  
  4.   doSomething();  
  5. }  
  6. //线程2  
  7. stop = true;  

这段代码是很典型的一段代码，很多人在中断线程时可能都会采用这种标记办法。但是事实上，这段代码会完全运行正确么？即一定会将线程中断么？不一定，也许在大多数时候，这个代码能够把线程中断，但是也有可能会导致无法中断线程（虽然这个可能性很小，但是只要一旦发生这种情况就会造成死循环了）。

下面解释一下这段代码为何有可能导致无法中断线程。在前面已经解释过，每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份放在自己的工作内存当中。

那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

但是用volatile修饰之后就变得不一样了：

　　第一：使用volatile关键字会强制将修改的值立即写入主存；

　　第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

　　第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。

那么线程1读取到的就是最新的正确的值。

②volatile保证原子性吗？

看下面这段代码

[java] view plain copy
  1. public class Test {  
  2.     public volatile int inc = 0;  
  3.        
  4.     public void increase() {  
  5.         inc++;  
  6.     }  
  7.        
  8.     public static void main(String[] args) {  
  9.         final Test test = new Test();  
  10.         for(int i=0;i<10;i++){  
  11.             new Thread(){  
  12.                 public void run() {  
  13.                     for(int j=0;j<1000;j++)  
  14.                         test.increase();  
  15.                 };  
  16.             }.start();  
  17.         }  
  18.            
  19.         while(Thread.activeCount()>1)  //保证前面的线程都执行完  
  20.             Thread.yield();  
  21.         System.out.println(test.inc);  
  22.     }  
  23. }  
大家想一下这段程序的输出结果是多少？也许有些朋友认为是10000。但是事实上运行它会发现每次运行结果都不一致，都是一个小于10000的数字。

　　可能有的朋友就会有疑问，不对啊，上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终inc的值应该是1000*10=10000。

　　这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

　　在前面已经提到过，自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

　　假如某个时刻变量inc的值为10，

　　线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

　　然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

　　然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

　　那么两个线程分别进行了一次自增操作后，inc只增加了1。

　　解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

　　根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

修改如下：

[java] view plain copy
  1. public class Test {  
  2.     public  int inc = 0;  
  3.       
  4.     public synchronized void increase() {  
  5.         inc++;  
  6.     }  
  7.       
  8.     public static void main(String[] args) {  
  9.         final Test test = new Test();  
  10.         for(int i=0;i<10;i++){  
  11.             new Thread(){  
  12.                 public void run() {  
  13.                     for(int j=0;j<1000;j++)  
  14.                         test.increase();  
  15.                 };  
  16.             }.start();  
  17.         }  
  18.           
  19.         while(Thread.activeCount()>1)  //保证前面的线程都执行完  
  20.             Thread.yield();  
  21.         System.out.println(test.inc);  
  22.     }  
  23. }  
为方法添加synchronized关键字，将a++操作原子化即可。

5.关键字final

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但引用值可变。

例1：

[java] view plain copy
  1. String a = "hello2";  
  2. final String b = "hello";  
  3. String d = "hello";  
  4. String c = b + 2;  
  5. String e = d + 2;  
  6. System.out.println((a == c));  
  7. System.out.println((a == e));  
输出结果为：true,false

当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译器常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个变量，不需要在运行时确定。

6.Java中修饰符

private：该类；
default：同包访问，且为默认值；
protected：同包及继承子类可访问；
public：均可访问

7.Java的八种数据类型

Java常见笔试及面试考点总结

类型 占用存储空间
byte 1字节
short 2字节
int 4字节
long 8字节
float 4字节
double 8字节
注：String不属于八种的一种，String是一个对象。

例：

[java] view plain copy
  1. String str1 = null;  
  2. String str2 = "hello";  
  3. System.out.println(str1+str2);  
输出结果为：nullhello

7.1 字符串比较，使用“==”还是equals()？

简单来说, "==" 判断两个引用的是不是同一个内存地址(同一个物理对象).而 equals 判断两个字符串的值是否相等.除非你想判断两个string引用是否同一个对象,否则应该总是使用 equals()方法.

7.2 如何通过空白字符拆分字符串？

String 的 split()方法接收的字符串会被当做正则表达式解析，"\s"代表空白字符,如空格" ",tab制表符"\t", 换行"\n",回车"\r"，而编译器在对源代码解析时,也会进行一次字面量转码,所以需要"\\s".代码如下：

[java] view plain copy
  1. String sArray[] = s.split("\\s+");  

7.3 String VS StringBuilder VS StringBuffer

String是不可变对象，一旦创建，那么整个对象就不可改变，设计之初将其定义为final类型，主要从效率和安全性两方面考虑？即使新手觉得String引用变了，实际上只是（指针）引用指向了另一个（新的）对象。

StringBuilder 是可变的,因此可以在创建以后修改内部的值.

StringBuffer 是同步的,因此是线程安全的,但效率相对更低.

7.4 String与new String的区别（注意对象与对象引用的区别）

实例分析

[java] view plain copy
  1. String hello = "hello";  
  2. String hello1 = "he" + new String("llo");  
  3. String str1="abx";  
  4. String str2="abx";  
  5. String str3=new String("abx");  
  6. String str4=new String("abx");  
  7. System.out.println(str1==str2);  
  8. System.out.println(str2==str3);  
  9. System.out.println(str3==str4);  
  10. System.out.println(hello == hello1);  
输出结果为：true,false,false,false

当String str1="abx" ，"abx"是一个对象，String str2="abx"明显是又声明了一个到“abx”的一个引用str2，所以测试str1==str2时打印true
但String str3=new String("abx");这是显式的创建了一个String对象。判断==时，显然两个对象不是同一个对象。所以判断字符相等的时候我们都用equals方法。也是这个道理。


8.Java异常

8.1 Java的异常结构图

Java常见笔试及面试考点总结
Throwable是所有异常的根，Error是错误，Exception是异常。
运行异常由运行时系统自动抛出，不需要使用throw语句。

Exception

一般分为checked异常和Runtime异常。
①java认为checked异常都是可以被处理的异常。我们比较熟悉的Checked异常有：文件、类、方法未找到，IO异常

Java.lang.ClassNotFoundException
Java.lang.NoSuchMetodException
java.io.IOException

②RuntimeException

Runtime如除数是0和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。我们比较熟悉的RumtimeException类的子类有：算术、数组越界、空指针等

Java.lang.ArithmeticException
Java.lang.ArrayStoreExcetpion
Java.lang.ClassCastException
Java.lang.IndexOutOfBoundsException
Java.lang.NullPointerException

8.2 处理异常的机制

抛出异常和捕获异常；总是先抛出，后捕获。
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

try/catch/finally

①基本语法
[java] view plain copy
  1.  try {    
  2.     // 可能会发生异常的程序代码    
  3. } catch (Type1 id1) {    
  4.     // 捕获并处理try抛出的异常类型Type1    
  5. } catch (Type2 id2) {    
  6.     // 捕获并处理try抛出的异常类型Type2    
  7. } finally {    
  8.     // <span style="color:#ff0000;">无论是否发生异常，都将执行的语句块</span>    
  9. }    

例1：
[java] view plain copy
  1. public static void main(String[] args) {  
  2.         try {  
  3.             System.out.println("in the try block");  
  4.             return;  
  5.         } catch (Exception e) {  
  6.             e.printStackTrace();  
  7.         }  
  8.         finally {  
  9.             System.out.println("in the finally block");  
  10.         }  
  11.     }  
输出结果：
in the try block
in the finally block
解释：在try中的return真正返回之前会执行finally中的语句。
②catch中捕获异常时，异常类型应自底层写起。例如：发生数组越界，第一个catch中应写ArrayIndexOutOfBoundsException，最后的catch写RuntimeException。否则，会出现屏蔽。

小结：

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。

throws抛出异常的规则：

1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

例：
[java] view plain copy
  1. void method1() throws IOException{}  //合法      
  2.      
  3. //编译错误，必须捕获或声明抛出IOException      
  4. void method2(){      
  5.   method1();      
  6. }      
  7.      
  8. //合法，声明抛出IOException      
  9. void method3()throws IOException {      
  10.   method1();      
  11. }      
  12.      
  13. //合法，声明抛出Exception，IOException是Exception的子类      
  14. void method4()throws Exception {      
  15.   method1();      
  16. }      
  17.      
  18. //合法，捕获IOException      
  19. void method5(){      
  20.  try{      
  21.     method1();      
  22.  }catch(IOException e){…}      
  23. }      
  24.      
  25. //编译错误，必须捕获或声明抛出Exception      
  26. void method6(){      
  27.   try{      
  28.     method1();      
  29.   }catch(IOException e){throw new Exception();}      
  30. }      
  31.      
  32. //合法，声明抛出Exception      
  33. void method7()throws Exception{      
  34.  try{      
  35.   method1();      
  36.  }catch(IOException e){throw new Exception();}      
  37. }     
 判断一个方法可能会出现异常的依据如下：
     1）方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
     2）调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。 
throw与throws的区别
①throw：针对对象的做法
②throws：针对方法的做法
例：
[java] view plain copy
  1. public class Test3 {  
  2.     public static void main(String[] args) {  
  3.         System.out.println("main..." + getValue());  
  4.     }  
  5.     public static int getValue() {  
  6.         try {  
  7.             System.out.println("try...");  
  8.             return 0;  
  9.         } finally {  
  10.             System.out.println("finally...");  
  11.             return 1;  
  12.         }  
  13.     }  
  14. }  
输出结果：
try...
finally...
main...1
解释：此处finally中返回1，所以不再执行try中的return 0;
例：
[java] view plain copy
  1. public class Test3 {  
  2.     public static void main(String[] args) {  
  3.         System.out.println("main..." + getValue());  
  4.     }  
  5.     public static int getValue() {  
  6.         int i = 0;  
  7.         try {  
  8.             System.out.println("try...");  
  9.             return i;  
  10.         } finally {  
  11.             System.out.println("finally...");  
  12.             i++;  
  13.         }  
  14.     }  
  15. }  
输出结果：
try...
finally...
main...0
解释：
        这个很多人都不知道为什么了，按道理说，在try的return执行之前，在finally之中已经更改了i的值，为什么return的值任然是0而不是1呢？
　　实际上，Java 虚拟机会把 finally 语句块作为 subroutine。直接插入到 try 语句块或者 catch 语句块的控制转移语句之前。但是，还有另外一个不可忽视的因素，那就是在执行 subroutine（也就是 finally 语句块）之前，try 或者 catch 语句块会保留其返回值到本地变量表（Local Variable Table）中。待 subroutine 执行完毕之后，再恢复保留的返回值到操作数栈中，然后通过 return 或者 throw 语句将其返回给该方法的调用者（invoker）。 
　　所以，上例中try中返回的不是finally中的i，而是在执行finally之前放在本地变量表中的i。所以返回的仍然是0。
例：
[java] view plain copy
  1. public class Test3 {  
  2.     public static void main(String[] args) {  
  3.         System.out.println("main..." + getValue());  
  4.     }  
  5.     public static int getValue() {  
  6.         int i = 0;  
  7.         try {  
  8.             System.out.println("try...");  
  9.         } finally {  
  10.             System.out.println("finally...");  
  11.             i++;  
  12.             return i;  
  13.         }  
  14.     }  
  15. }  
输出结果：
try...
finally...
main...1
由于try中没有返回语句，所以不会将try中的i放到本地变量表，执行完finally之后也不会再返回try，而是使用finally中的i直接返回。
例：
[java] view plain copy
  1. public class Test3 {  
  2.     public static void main(String[] args) {  
  3.         System.out.println("main..." + getValue());  
  4.     }  
  5.     public static int getValue() {  
  6.         int i = 0;  
  7.         try {  
  8.             System.out.println("try...");  
  9.             return test();  
  10.         } finally {  
  11.             System.out.println("finally...");  
  12.             i++;  
  13.         }  
  14.     }  
  15.     public static int test() {  
  16.         System.out.println("test...");  
  17.         return 10;  
  18.     }  
  19. }  
输出结果：
<code class="hljs lasso has-numbering">try<span class="hljs-attribute">...</span>
test<span class="hljs-attribute">...</span>
finally<span class="hljs-attribute">...</span>
main<span class="hljs-attribute">...</span><span class="hljs-number">10</span></code>
此处try中的return test()就等同于int r = test();return r;，另外，catch和finally的关系和上面是一样的，这里省略了。
最佳实践：
1）不要在catch和finally块中有return语句；
2）建议在finally中只进行资源的清理操作；
补充：Java栈
所谓Java栈，描述的是一种Java中方法执行的内存模型，Java栈为线程私有，线程中每一次的方法调用（或执行），JVM都会为该方法分配栈内存，即：栈帧（stack frame），分配的栈帧用于存放该方法的局部变量表、操作栈、方法编译后的字节码指令信息和异常处理信息等，JVM制定了一个线程可以请求的栈深度的最大值，如果线程请求的栈深度超过这个最大值，JVM将会抛出stackoverflowerror，
Java常见笔试及面试考点总结
由图可知：在一个JVM实例中（即我们运行的一个Java程序）可以同时运行多个线程，而每个线程都拥有自己的Java栈，此栈为线程私有，随着线程内方法的不断调用，线程内的栈深度不断增加，直到溢出。而当一个方法执行完毕（return或throw），该方法所对应的线程内的栈帧被JVM回收，线程内的栈深度会相应的变小，直到线程的终结。

9.switch语句

Java常见笔试及面试考点总结

该方法返回值为10；因为每个case中均无break;所以当输入2后，会从case 2一直执行下去。

switch标准语句格式如下：

switch(整型或字符型变量)

{

  case 变量可能值1:

            分支一;

            break;

  case 变量可能值2:

            分支二;

            break;

  ……

  default:

           最后分支;

}

10.java8的接口新特性：可以有方法体的接口

11.重载（overloading）和重写（overriding）

重载：函数名同，参数个数/类型不同，返回值可以相同也可以不同。重载是一个类中多态性的一种表现。

重写：又叫方法覆盖，父类与子类间的多态性

注：super关键字必须位于子类方法中的第一句。

12.GC是否为守护线程？

是，线程分为守护线程和非守护线程（即用户线程）。只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。守护线程最典型的应用就是GC（垃圾回收器）。

13.字符和ASC码的转换

字符->ASC码：(int)'a'

ASC码->字符：(char)97

例1：统计字符串中不同字符的个数

[java] view plain copy
  1. package exercise;  
  2.   
  3. public class Main {  
  4.     public static void main(String[] args) {  
  5.         String s = "123asdASD123";  
  6.         int j = 0,p = 0;  
  7.         byte []bytes = s.getBytes();  
  8.         for(int i=0;i<bytes.length;++i){  
  9.             if(bytes[i]>=0&&bytes[i]<=127){  
  10.                 p = 0;  
  11.                 for(int k=0;k<i;k++){  
  12.                     if(bytes[i]==bytes[k]){  
  13.                         p = 1;  
  14.                         break;  
  15.                     }  
  16.                 }  
  17.                 if(p==0)  
  18.                     j++;  
  19.             }  
  20.         }  
  21.         System.out.println(j);  
  22.     }  
  23. }  
例2：统计字符串中不同字符的个数

[java] view plain copy
  1. package exercise;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5. import java.util.Scanner;  
  6.   
  7. public class Main_exer {  
  8.     public static void main(String[] args) {  
  9.         Scanner sc = new Scanner(System.in);  
  10.         String s = sc.nextLine();  
  11.         int nums = 0;  
  12.         byte []bytes = s.getBytes();  
  13.         Map<Integer,String> map = new HashMap<Integer,String>();  
  14.         for(int i=0;i<bytes.length;++i){  
  15.             boolean flag = map.containsValue((char)bytes[i]+"");  
  16.             if(flag==false){  
  17.                 System.out.println((char)bytes[i]);  
  18.                 map.put((int)bytes[i], (char)bytes[i]+"");  
  19.                 nums++;  
  20.             }  
  21.         }  
  22.         System.out.println("不同的字符数是：" + nums);  
  23.     }  
  24. }  

14.HashMap

特点：collection、key-value、

如何实现快速存储数据？

①hashmap数据结构：链表散列

Java常见笔试及面试考点总结

②主要在于：链的产生、扩容问题。

转载：https://blog.****.net/hellorichen/article/details/52816183

相关推荐