Java —— 基础篇

电玩女神 2022-01-12 13:41 341阅读 0赞

## 1.面向对象和面向过程的区别 ##

**面向对象：**  
优点：易维护、易复用、易扩展，由于面向对象有继承、封装、多态的特性，可开发低耦合的系统。  
缺点：性能比面向过程差。  
**面向过程：**  
优点：性能比面向对象好，原因：类调用的时候需要实例化。  
缺点：不易维护、服用和扩展。

## 2.Java的四个基本特性 ##

**抽象：** 就是把现实生活中的某些东西提取出来，用程序代码表示，一般称之为类或接口。  
**继承：** 对于有共同特性的多类事物，进行再抽象成一个类，这个类作为多类事物的父类。父类的意义在于抽取多类事物的公共特性。  
**封装：** 把客观的事物封装成抽象的类，并且可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行封装隐藏。  
**多态：** 允许同一个类的不同对象，对一个消息进行响应。如：类的覆盖、方法的重载。

## 3.重载和重写的区别 ##

**重载（overload）：** 同一类中，方法名称相同，参数列表不同，与返回值类型无关。  
**重写（override）：** 发生在父子类中，方法名称、参数列表相同，返回值类型小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类。若是父类的方法访问修饰符为private，则不叫重写。

## 4.构造器Constructor能否被override ##

构造器不能被重写，也不能被static修饰，只能用public、private、protected这三个权限修饰符，且不能有返回语句。

## 5.访问控制符public、protected、private及默认的区别 ##

**public：** 在任何地方都能访问。  
**protected：** 同包内的类及包外的子类。  
**private：** 仅在本类中才能访问。  
**默认：** 同包内可以访问。

## 6.是否可以继承String类 ##

不能，因为String类是final类，一切被final修饰过的类都不能被继承。

## 7.String、StringBuffer和StringBuilder的区别 ##

**可变性：**  
**String**类是使用字符数组保存字符串，如：private final char\[\] value，因此string对象是不可变的。  
**StringBuffer**和**StringBuilder**都继承AbstractStringBuilder类，也是使用字符数组保存字符串，如char\[\] value，由此可以看出，这两种对象都是可变的。  
**线程安全性：**  
**String**中的对象不可变，也可以理解为常量，线程安全。  
AbstractStringBuilder是StringBuffer和StringBuilder的公共父类，提供了一些对字符串操作的方法，如insert、append、indexOf等公共方法。**StringBuffer**对方法或对调用的方法加了同步锁，线程安全。**StringBuilder**没有对方法加同步锁，线程不安全。  
**性能：**  
每次对**String**类型改变时，都会产生新的String对象，然后指针指向新的String对象。  
**StringBuffer**每次都会对StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下，StringBuilder相比StringBuffer仅能提升10%~15%左右的性能提升，却要冒着多线程不安全的风险。

## 8.hashCode和equals方法的关系 ##

equals为true，hashCode必为true；  
hashCode为true，equals不一定为true。

## 9.抽象类和接口的区别 ##

1）抽象类可以有构造方法，接口中不能有构造方法；  
2）抽象类可以有普通成员变量，接口没有普通成员变量；  
3）抽象类可包含静态方法，接口中不能有静态方法；  
4）一个类只能继承一个抽象类，但可以实现多个接口；  
5）抽象类只能被单一继承，接口可以被多重实现；  
6）如果抽象类实现接口，则可以把接口中的方法映射到抽象类中作为抽象方法而不必实现，在抽象类的子类中实现接口中的方法。

## 10.自动装箱和拆箱 ##

**装箱：** 将基本类型用它的引用类型包装起来。  
**拆箱：** 将包装类型转换为基本数据类型。  
Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率。两者是由编译器完成的，编译器在编译期间根据语法决定是否进行自动装箱和拆箱动作。

## 11.什么是泛型？为什么要用？泛型擦除是什么？泛型擦除的过程？ ##

**泛型：** 即参数化类型。  
**为什么要用：** 在创建集合时就指定集合元素的类型，该集合就只能保存指定类型的元素，避免使用强制类型转换。  
**泛型擦除：** Java的泛型擦除是在编译器中进行的，编译器首先会产生字节码，Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这就叫泛型擦除。  
**泛型擦除的过程：**  
1）将所有泛型参数用其顶级父类类型替换；  
2）移除所有类型参数。

## 12.Java中的集合类及关系图 ##

![在这里插入图片描述][aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTAxMDcyNi8yMDE3MDYvMTAxMDcyNi0yMDE3MDYyMTAwNDczNDY5NS05ODg1NDI0NDgucG5n]

## 13.Collection和Collections的区别 ##

**java.util.Collection** 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。  
**java.util.Collections** 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

## 14.HashTable实现原理 ##

[http://zhangshixi.iteye.com/blog/672697][http_zhangshixi.iteye.com_blog_672697]  
[http://www.admin10000.com/document/3322.html][http_www.admin10000.com_document_3322.html]

## 15.HashMap实现原理 ##

[http://www.cnblogs.com/skywang12345/p/3310887.html][http_www.cnblogs.com_skywang12345_p_3310887.html]  
[http://blog.csdn.net/chdjj/article/details/38581035][http_blog.csdn.net_chdjj_article_details_38581035]

## 16.HashMap和HashTable的区别 ##

1）**线程安全：** **HashMap**是非线程安全的；**HashTable**的方法前面都有synchronized同步，是线程安全的。  
2）**键值：** **HashMap**可以有null键null值；**HashTable**不允许null键null值。  
3）**遍历：** **HashMap**用Iterator遍历；**HashTable**用Enumeration遍历。  
4）**扩容：** **HashMap**的hash数组默认大小是16，而且一定是2的指数；**HashTable**的hash数组默认大小是11，增加的方式是old\*2+1。  
5）**hashCode的使用：** **HashMap**重新计算hash，而且用于代替求模；**HashTable**直接用对象的hashCode。

## 17.ArrayList和Vector的区别 ##

**相同点：**  
1）两者都是通过数组实现了List接口。  
2）List第一次创建的时候，会有一个初始大小，随着不断向List中增加元素，当List 认为容量不够的时候就会进行扩容。  
**不同点：**  
1）**线程安全：** **ArrayList**是非线程安全；**Vector**是线程安全的。  
2）**增长长度：** **ArrayList**增长原来的50%，**Vector**缺省情况下自动增长原来一倍的数组长度。

## 18.ArrayList和LinkedList的区别及使用场景 ##

**区别：**  
**ArrayList**底层使用数组实现的，可以认为ArrayList是可以改变大小的数组。随着越来越多的元素添加到ArrayList中，其规模是动态增加的。  
**LinkedList**底层是通过双向链表实现的，LinkedList相对于ArrayList，增删速度快，修改、查询速度慢。LinkedList还实现了Queue接口，所以它还提供了offer()、peek()、poll()等方法。  
**使用场景：**  
**ArrayList**适合检索和从末尾进行插入及删除操作。  
**LinkedList**适合从中间插入和删除操作。

## 19.Error和Exception的区别 ##

**Error**类和**Exception**类的父类都是Throwable类，它们的区别是：  
**Error**类一般指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存不足，方法调用栈溢等。对于这类错误导致的应用程序中断，仅靠程序本身无法回复和预防，遇到这样的错误，建议让程序终止。  
**Exception**类表示程序可以处理的异常，可以捕获且可能恢复。遇到这种异常，应尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

## 20.UncheckedException和CheckedException ##

Java的Exception分为两种，CheckedException与UncheckedException  
**UncheckedException：**  
1）指的是程序的瑕疵或逻辑错误，并且在运行时无法恢复。  
2）**UncheckedException**是RuntimeException的子类，典型的有：  
OutOfMemoryError, UndeclaredThrowableException, IllegalArgumentException,  
IllegalMonitorStateException, NullPointerException, IllegalStateException,  
IndexOutOfBoundsException等。  
3）语法上不需要声明抛出异常。  
**CheckedException：**  
1）代表程序不能直接控制的无效外界情况（如用户输入，数据库问题，网络异常，文件丢失等）。  
2）典型的有：  
ClassNotFoundException, NamingException, ServletException, SQLException, IOException等。  
3）需要try catch处理或throws声明抛出异常。

## 21.Java中如何实现代理机制（JDK、CGLIB） ##

**JDK动态代理：** 代理类和目标类实现了共同的接口，用到了InvocationHandler接口。  
**CGLIB动态代理：** 代理类是目标类的子类，用到了MethodInterceptor接口。

## 22.多线程的实现方式 ##

参考：[https://www.cnblogs.com/felixzh/p/6036074.html][https_www.cnblogs.com_felixzh_p_6036074.html]  
1）继承Thread类创建线程。  
2）实现Runnable创建线程。  
3）实现Callable接口通过FutureTask包装器来创建Thread线程。  
4）使用ExecutorService、Callable、Future实现有返回结果的线程。

## 23.线程的状态转换 ##

1）当一个线程执行了start方法后，不代表这个线程就会立即被执行，只代表这个线程处于可运行的状态，最终由OS的线程调度来决定哪个可运行状态下的线程被执行。  
2）一个线程一次被选中执行是有时间限制的，这个时间段叫做CPU的时间片，当时间片用完但线程还没有结束时，这个线程又会变为可运行状态，等待OS的再次调度；在运行的线程里执行Thread.yeild()方法同样可以使当前线程变为可运行状态。  
3）在一个运行中的线程等待用户输入、调用Thread.sleep()、调用了其他线程的join()方法，则当前线程变为阻塞状态。  
4）阻塞状态的线程用户输入完毕、sleep时间到、join的线程结束，则当前线程由阻塞状态变为可运行状态。  
运行中的线程调用wait方法，此线程进入等待队列。  
5）运行中的线程遇到synchronized同时没有拿到对象的锁标记、等待队列的线程wait时间到、等待队列的线程被notify方法唤醒、有其他线程调用notifyAll方法，则线程变成锁池状态。  
6）锁池状态的线程获得对象锁标记，则线程变成可运行状态。  
7）运行中的线程run方法执行完毕或main线程结束，则线程运行结束。

## 24.如何停止一个线程 ##

1）调用stop方法，可以停止线程，但是该线程是戛然而止 —— 城管的暴力执法  
一个方法，里面的动作执行了一半，被终止了，这种方案是不可取的。 具有固有的不安全性。  
2）建议使用标识符的方法  
指定一个变量，想让其停止的时候，将变量重新赋值。

## 25.什么是线程安全 ##

指的是多线程访问同一代码，不会产生不确定的结果。

## 26.如何保证线程安全 ##

1）对非线程安全的代码进行加锁控制；  
2）使用线程安全的类；  
3）多线程并发情况下，把线程共享的变量改为方法级的局部变量。

## 27.synchronized如何使用 ##

**java中共有两种类型的锁：**  
1）类锁：只有synchronized修饰静态方法或者修饰一个类的class对象时，才是类锁。  
2）对象锁：除了类锁，所有其他的上锁方式都认为是对象锁。比如synchronized修饰普通方法或者synchronized（this)给代码块上锁等。  
**synchronized的三种使用方式：**  
1）修饰普通方法  
一个对象中的加锁方法只允许一个线程访问。但要注意这种情况下锁的是访问该方法的实例对象， 如果多个线程不同对象访问该方法，则无法保证同步。  
2）修饰静态方法  
由于静态方法是类方法， 所以这种情况下锁的是包含这个方法的类，也就是类对象；这样如果多个线程不同对象访问该静态方法，也是可以保证同步的。  
3）修饰代码块  
其中普通代码块 如Synchronized（obj） 这里的obj 可以为类中的一个属性、也可以是当前的对象，它的同步效果和修饰普通方法一样；Synchronized方法 （obj.class）静态代码块它的同步效果和修饰静态方法类似。

## 28.synchronized和Lock的区别 ##

**主要相同点：** Lock能完成synchronized所实现的所有功能。  
**主要不同点：**  
1）Lock有比synchronized更精确的线程语义和更好的性能。  
2）Lock的锁定是通过代码实现的，synchronized是在JVM这个层面上实现的。  
3）synchronized会自动释放锁，而Lock一定要求程序员手动释放，并且必须在finally从句中释放。  
4）Lock还有更强大的功能，例如它的try Lock方法可以非阻塞的去拿锁。  
5）Lock锁的范围有限，块范围；而synchronized可以锁住块、对象、类。

## 29.多线程如何进行信息交互 ##

1）void notify() 唤醒在此对象监听器上等待的单个线程。  
2）void notifyAll() 唤醒在此对象监听器上等待的所有线程。  
3）void wait() 导致当前的线程等待，直到其他线程调用这个对象的notify()方法或notifyAll()方法。  
3）void wait(long timeout) 导致当前的线程等待，直到其他线程调用这个对象的notify()方法或notifyAll()方法或超过了指定的时间量。  
4）void wait(long timeout, int nanos)

## 30.sleep()和wait()的区别（考察的是是否会释放对象锁） ##

1）sleep()方法是Thread类中的方法，wait()方法是Object类中的方法。  
2）sleep()方法导致了程序暂停执行指定的时间，让出cpu去其他线程，但是它的监控状态依旧保持着，当指定的时间到了又会自动恢复运行状态，在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会释放对象锁，进入等待此对象的等待锁定池，只有当针对此对象调用notify()方法后本线程才会进入对象锁定池准备。

## 31.多线程与死锁 ##

死锁是指两个或两个以上的线程在执行的过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。  
**产生死锁的原因：**  
1）系统资源不足。  
2）资源分配不当。  
3）进程推进的顺序不合适。

## 32.如何才能产生死锁 ##

**产生死锁的四个必要条件：**  
1）互斥条件：所谓互斥是指进程在某一时间内独占资源。  
2）请求和保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

## 33.如何才能产生死锁 ##

产生死锁的四个必要条件：  
一.互斥条件：所谓互斥就是进程在某一时间内独占资源。  
二.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。  
三.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。  
四.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

## 34.死锁的预防 ##

打破产生死锁的四个必要条件中的一个或几个，保证系统不会进入死锁状态。  
一.打破互斥条件。即允许进程同时访问某些资源。但是，有的资源是不允许被同时访问的，像打印机等等，这是由资源本身的属性所决定的。所以，这种办法并无实用价值。  
二.打破不可抢占条件。即允许进程强行从占有者那里夺取某些资源。就是说，当一个进程已占有了某些资源，它又申请新的资源，但不能立即被满足时，它必须释放所占有的全部资源，以后再重新申请。它所释放的资源可以分配给其它进程。这就相当于该进程占有的资源被隐蔽地强占了。这种预防死锁的方法实现起来困难，会降低系统性能。  
三.打破占有且申请条件。可以实行资源预先分配策略。即进程在运行前一次性地向系统申请它所需要的全部资源。如果某个进程所需的全部资源得不到满足，则不分配任何资源，此进程暂不运行。只有当系统能够满足当前进程的全部资源需求时，才一次性地将所申请的资源全部分配给该进程。由于运行的进程已占有了它所需的全部资源，所以不会发生占有资源又申请资源的现象，因此不会发生死锁。  
四.打破循环等待条件，实行资源有序分配策略。采用这种策略，即把资源事先分类编号，按号分配，使进程在申请，占用资源时不会形成环路。所有进程对资源的请求必须严格按资源序号递增的顺序提出。进程占用了小号资源，才能申请大号资源，就不会产生环路，从而预防了死锁。

## 35.什么叫守护线程，用什么方法实现守护线程 ##

守护线程是为其他线程的运行提供服务的线程。  
setDaemon(boolean on)方法可以方便的设置线程的Daemon模式，true为守护模式，false为用户模式。

## 36.Java线程池技术及原理 ##

参考文章：  
[http://www.importnew.com/19011.html][http_www.importnew.com_19011.html]  
[http://www.cnblogs.com/dolphin0520/p/3932921.html][http_www.cnblogs.com_dolphin0520_p_3932921.html]

## 37.java并发包concurrent及常用的类 ##

这个内容有点多，参考文章：  
并发包诸类概览：[http://www.raychase.net/1912][http_www.raychase.net_1912]  
线程池：[http://www.cnblogs.com/dolphin0520/p/3932921.html][http_www.cnblogs.com_dolphin0520_p_3932921.html]  
锁：[http://www.cnblogs.com/dolphin0520/p/3923167.html][http_www.cnblogs.com_dolphin0520_p_3923167.html]  
集合：[http://www.cnblogs.com/huangfox/archive/2012/08/16/2642666.html][http_www.cnblogs.com_huangfox_archive_2012_08_16_2642666.html]

## 38.volatile关键字 ##

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。  
Java语言中的volatile变量可以被看作是一种“程度较轻的  
synchronized”；与  
synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是synchronized的一部分。锁提供了两种主要特性：互斥（mutual  
exclusion）和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的，如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。Volatile变量具有synchronized的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile  
变量的最新值。  
要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。  
第一个条件的限制使volatile变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而volatile不能提供必须的原子特性。实现正确的操作需要使x 的值在操作期间保持不变，而volatile  
变量无法实现这点。  
每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。  
read and load 从主存复制变量到当前工作内存  
use and assign 执行代码，改变共享变量值  
store and write 用工作内存数据刷新主存相关内容  
其中use and  
assign 可以多次出现，但是这一些操作并不是原子性，也就是在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。

## 39.序列化与反序列化 ##

把对象转换为字节序列的过程称为对象的序列化。  
把字节序列恢复为对象的过程称为对象的反序列化。  
对象的序列化主要有两种用途：  
一.把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；  
二.在网络上传送对象的字节序列。  
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

## 40.常见的序列化协议有哪些 ##

Protobuf, Thrift, Hessian, Kryo

## 41.内存溢出和内存泄漏的区别 ##

内存溢出是指程序在申请内存时，没有足够的内存空间供其使用，出现out of  
memory。  
内存泄漏是指分配出去的内存不再使用，但是无法回收。

## 42.Java内存管理及回收算法 ##

阅读这篇文章：[http://www.cnblogs.com/hnrainll/archive/2013/11/06/3410042.html][http_www.cnblogs.com_hnrainll_archive_2013_11_06_3410042.html]

[aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTAxMDcyNi8yMDE3MDYvMTAxMDcyNi0yMDE3MDYyMTAwNDczNDY5NS05ODg1NDI0NDgucG5n]: /images/20220109/9a2923ca72f24a229103ca96878ab207.png
[http_zhangshixi.iteye.com_blog_672697]: http://zhangshixi.iteye.com/blog/672697
[http_www.admin10000.com_document_3322.html]: http://www.admin10000.com/document/3322.html
[http_www.cnblogs.com_skywang12345_p_3310887.html]: http://www.cnblogs.com/skywang12345/p/3310887.html
[http_blog.csdn.net_chdjj_article_details_38581035]: http://blog.csdn.net/chdjj/article/details/38581035
[https_www.cnblogs.com_felixzh_p_6036074.html]: https://www.cnblogs.com/felixzh/p/6036074.html
[http_www.importnew.com_19011.html]: http://www.importnew.com/19011.html
[http_www.cnblogs.com_dolphin0520_p_3932921.html]: http://www.cnblogs.com/dolphin0520/p/3932921.html
[http_www.raychase.net_1912]: http://www.raychase.net/1912
[http_www.cnblogs.com_dolphin0520_p_3923167.html]: http://www.cnblogs.com/dolphin0520/p/3923167.html
[http_www.cnblogs.com_huangfox_archive_2012_08_16_2642666.html]: http://www.cnblogs.com/huangfox/archive/2012/08/16/2642666.html
[http_www.cnblogs.com_hnrainll_archive_2013_11_06_3410042.html]: http://www.cnblogs.com/hnrainll/archive/2013/11/06/3410042.html