java之面试宝典

一.java基础

Java 集合部分都有哪些接口，主要体现了哪些设计模式？

答：Java 集合部分主要有Collection、List、Set、Map、Comparator、Iterator 等，主要体现的设计模式是策略模式和迭代模式
策略模式主要体现在每个接口有不同的实现，可以完成互换，如List 接口下有ArrayList 和LinkedList,在不同的场景下可以互换。
迭代模式主要体现在Iterator 的实现，为不同的数据存储方式(数组、链表、散列表等)提供了统一的访问方式。
Comparator 体现的设计模式是什么？ -- 策略模式，即不改变对象自身，而使用一个策略对象去改变它的行为。
注：策略模式的优缺点是什么：
优点：（1）将具体算法逻辑与客户类分离，（2）避免了大量的if else 判断
缺点：（1）每个算法一个类，产生了太多的类，（2）客户端要知道所有的策略类，以便决定使用哪一个。

Java中MVC详解以及优缺点总结

MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务数据、逻辑、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。
最典型的MVC就是Jsp + Servlet + JavaBean的模式

优点：分层，结构清晰，耦合性低，大型项目代码的复用性得到极大的提高，开发人员分工明确，提高了开发的效率，维护方便，降低了维护成本。
缺点：简单的小型项目，使用MVC设计反而会降低开发效率，层和层虽然相互分离，但是之间关联性太强，没有做到独立的重用。

【集合相关面试题】

1.说一下数据结构中的什么是数组？什么是链表？
所谓数组，是相同数据类型的元素按一定顺序排列的集合

数组：存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难，因为数组中间插入，后面的元素需要进行位移。

链表:链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易，按序号进行寻址需要向前或者前后遍历节点。

2.说一下ArrayList底层实现方式？
①ArrayList通过数组实现，一旦我们实例化ArrayList无参数构造函数默认为数组初始化长度为10
②add方法底层实现如果增加的元素个数超过了10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。当新数组无法容纳增加的元素时，重复该过程。是一旦数组超出长度，就开始扩容数组。扩容数组调用的方法 Arrays.copyOf(objArr, objArr.length + 1);

5.ArrayList LinkedList vector 区别
答：1. 对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。
2. 在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。
3. LinkedList不支持高效的随机元素访问。
4. ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
这两个类都实现了 List 接口(List 接口继承了Collection 接口),他们都是有序集合,即存储在这两个集合中的元素的位置都是有顺序的,相当于一种动态的数组,我们以后可以按位置索引号取出某个元素,并且其中的数据是允许重复的。

ArrayList 与 Vector 的区别,这主要包括两个方面:
(1)同步性:
Vector 是线程安全的,也就是说是它的方法之间是线程同步的,而 ArrayList 是线程序不安全的,它的方法之间是线程不同步的。如果只有一个线程会访问到集合,那最好是使用 ArrayList,因为它不考虑线程安全,效率会高些;如果有多个线程会访问到集合,那最好是使用 Vector,因为不需要我们自己再去考虑和编写线程安全的代码。
(2)数据增长:
ArrayList 与 Vector 都有一个初始的容量大小,当存储进它们里面的元素的个数超过了容量时,就需要加 ArrayList 与 Vector 的存储空间,每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元,每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector 默认增长为原来两倍,而 ArrayList 的增长策略在文档中没有明确规定(从源代码看到的是增长为原来的1.5倍)。

ArrayList 与 Vector 都可以设置初始的空间大小,Vector 还可以设置增长的空间大小,而 ArrayList 没有提供设置增长空间的方法。

Java中的集合包括三大类，它们是Set、List和Map，他们都是接口，它们有各自的实现类。Set的实现类主要有HashSet和TreeSet，List的实现类主要有ArrayList，Map的实现类主要有HashMap和TreeMap。
Set中的对象不按特定方式排序，并且没有重复对象。但它的有些实现类能对集合中的对象按特定方式排序，例如TreeSet类，它可以按照默认排序，也可以通过实现接口来自定义排序方式。

List中的对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象，如通过list.get(i)方式来获得List集合中的元素。
Map中的每一个元素包含一个键对象和值对象，它们成对出现。键对象不能重复，值对象可以重复。

8.List****、****Map****、****Set ****三个接口****,存取元素时****,各有什么特点
list：存储：有序的可重复的
访问：可以[for循环]，foreach循环，iterator迭代器迭代。

set：存储：无序的不重复的
访问：可以foreach循环，iterator迭代器迭代

map：存储：存储的是一对一对的映射 ”key=value“，key值是无序，不重复的。value值可重复
访问：可以map中key值转为为set存储，然后迭代这个set，用map.get(key)获取value
也可以转换为entry对象用迭代器迭代

9.****说出****ArrayList,Vector, LinkedList ****的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（[线程安全]），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

10.****去掉一个****Vector ****集合中重复的元素
通过Vector.contains（）方法判断是否包含该元素，如果没有包含就添加到新的集合当中，适用于数据较小的情况下。

11.Collection ****和****Collections ****的区别。
Collection是集合类的上级接口，继承于它的接口主要有Set和List。 Collections是针对集合类的一个帮助类，它提供了一系列静态方法实现了对各种集合的排序，搜索和线程安全等操作。

12.Set 里的元素是不能重复的,那么用什么方法来区分重复与否呢?是用==还是equals()?它们有何区别
set里的元素是不能重复的，用iterator()方法来区分重复与否。
equals 方法（是[String类]从它的超类Object中继承的）被用来检测两个对象是否相等，即两个对象的内容是否相等。
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true

15.请说下Iterator的作用
迭代器可以实现Collection接口的方法，可以一个一个地获取集合中的元素
在遍历集合时可判断是否有下一个元素

18.HashSet和TreeSet有什么区别，什么时候用它们
区别:HashSet中的元素不能重复,没有顺序
TreeSet中的元素不能重复,但有顺序
当集合中的元素需要排序时,用TreeSet
一般情况下用HashSet,因为不需要排序,速度比TreeSet快

21.比较下集合和数组的优缺点
集合是多个对象的容器,可以将不同数据类型的多个对象组织在一起
数组类型是有相同数据类型的数据集合,数组是很多语言都支持的底层数据结构,性能上是最高的

23.在List里面怎么去掉重复的数？
通过把List里面的数据放入HashSet可以去除重复

25.ArrayList集合加入1万条数据，应该怎么提高效率
因为ArrayList的底层是数组实现,并且数组的默认值是10,如果插入10000条要不断的扩容,耗费时间,所以我们调用ArrayList的指定容量的构造器方法ArrayList(int size) 就可以实现不扩容,就提高了性能

HashMap实现原理
//HashMap继承AbstractMap抽象类并实现Map接口方法
public class HashMap<K,V> extends AbstractMap<K,V>  implements Map<K,V>, Cloneable, Serializable {
}
public class Hashtable<K,V>  extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {
}
public abstract class Dictionary<K,V> {
}
//AbstractMap抽象类实现Map接口
public abstract class yu<K,V> implements Map<K,V> {
}
//Map是一个接口
public interface Map<K,V> {
}
HashMap可以接受null键值和值，而HashTable则不能；HashMap是非synchronized;HashMap很快
HashMap 包含如下几个构造器：
HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。
HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。

HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。
initialCapacity：HashMap的最大容量，即为底层数组的长度。
loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。

默认情况下，数组大小为16，那么当HashMap中元素个数超过16x0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作
我们知道java.util.HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。
具体原理参考文章：
http://zhangshixi.iteye.com/blog/672697
http://www.admin10000.com/document/3322.html
HashTable实现原理
具体原理参考文章：
http://www.cnblogs.com/skywang12345/p/3310887.html
http://blog.csdn.net/chdjj/article/details/38581035

HashMap和HashTable区别
1）.HashTable的方法前面都有synchronized来同步，是线程安全的；HashMap未经同步，是非线程安全的。
2）.HashTable不允许null值(key和value都不可以) ；HashMap允许null值(key和value都可以)。
3）.HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。
4）.HashTable使用Enumeration进行遍历；HashMap使用Iterator进行遍历。
5）.HashTable中hash数组默认大小是11，增加的方式是old*2+1；HashMap中hash数组的默认大小是16，而且一定是2的指数。
6）.哈希值的使用不同，HashTable直接使用对象的hashCode； HashMap重新计算hash值，而且用与代替求模。

ArrayList和LinkedList区别及使用场景
public class ArrayList<E> extends AbstractList<E> implements List<E>
}
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
}
public abstract class AbstractCollection<E> implements Collection<E> {
}
public interface Collection<E> extends Iterable<E> {
}
public interface Iterable<T> {
}
public class LinkedList<E> extends AbstractSequentialList<E> implements List{
}
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
}
public class Vector<E> extends AbstractList<E> implements List<E>
}
Concurrenthashmap实现原理
具体原理参考文章：
http://www.cnblogs.com/ITtangtang/p/3948786.html
http://ifeve.com/concurrenthashmap/

List和Set比较，各自的子类比较

对比一：Arraylist与LinkedList的比较
1、ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。
2、因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。
3、LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。
4、因为LinkedList要移动指针,所以查询操作性能比较低。适用场景分析：当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

对比二：ArrayList与Vector的比较
1、Vector的方法都是同步的，是线程安全的，而ArrayList的方法不是，由于线程的同步必然要影响性能。因此，ArrayList的性能比Vector好。
2、当Vector或ArrayList中的元素超过它的初始大小时，Vector会将它的容量翻倍，而ArrayList只增加50%的大小，这样。ArrayList就有利于节约内存空间。
3、大多数情况不使用Vector，因为性能不好，但是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性。
4、Vector可以设置增长因子，而ArrayList不可以。

适用场景分析：
1、Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

对比三：HashSet与TreeSet的比较
1.TreeSet 是二叉树实现的，Treeset中的数据是自动排好序的，不允许放入null值。
2.HashSet 是哈希表实现的，HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。
3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例。
适用场景分析：
HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

8.Map、Set、List、Queue、Stack的特点与用法
Map是键值对，键Key是唯一不能重复的，一个键对应一个值，值可以重复。
TreeMap可以保证顺序。
HashMap不保证顺序，即为无序的。
Map中可以将Key和Value单独抽取出来，其中KeySet()方法可以将所有的keys抽取成一个Set。
而Values()方法可以将map中所有的values抽取成一个集合。
Set不包含重复元素的集合，set中最多包含一个null元素。
只能用Lterator实现单项遍历，Set中没有同步方法。
List
有序的可重复集合。
可以在任意位置增加删除元素。
用Iterator实现单向遍历，也可用ListIterator实现双向遍历。
Queue遵从先进先出原则。
使用时尽量避免add()和remove()方法,而是使用offer()来添加元素，使用poll()来移除元素，
它的优点是可以通过返回值来判断是否成功。
LinkedList实现了Queue接口。Queue通常不允许插入null元素。

Stack遵从后进先出原则。
Stack继承自Vector。
它通过五个操作对类Vector进行扩展，允许将向量视为堆栈，它提供了通常的push和pop操作，
以及取堆栈顶点的peek()方法、测试堆栈是否为空的empty方法等。

用法：
如果涉及堆栈，队列等操作，建议使用List。
对于快速插入和删除元素的，建议使用LinkedList。
如果需要快速随机访问元素的，建议使用ArrayList。
HashTable 和 HashMap 是 Map 的实现类。
HashTable 是线程安全的，不能存储 null 值。
HashMap 不是线程安全的，可以存储 null 值。
Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。
Queue接口：提供了几个基本方法，offer、poll、peek等。已知实现类有LinkedList、PriorityQueue等。

BIO、NIO和AIO的区别

Java BIO ：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。

Java NIO ：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。

Java AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。NIO比BIO的改善之处是把一些无效的连接挡在了启动线程之前，减少了这部分资源的浪费（因为我们都知道每创建一个线程，就要为这个线程分配一定的内存空间）AIO比NIO的进一步改善之处是将一些暂时可能无效的请求挡在了启动线程之前，比如在NIO的处理方式中，当一个请求来的话，开启线程进行处理，但这个请求所需要的资源还没有就绪，此时必须等待后端的应用资源，这时线程就被阻塞了。

适用场景分析：
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解，如之前在Apache中使用。
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持，如在 Nginx，Netty中使用。
AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持，在成长中，Netty曾经使用过，后来放弃。

Java中的NIO，BIO，AIO分别是什么

BIO:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
NIO:同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
AIO:异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

IO和NIO区别

一.IO是面向流的，NIO是面向缓冲区的。
二.IO的各种流是阻塞的，NIO是非阻塞模式。
三.Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

序列化与反序列化

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

【java虚拟机】

1.JDK、JRE、JVM关系是什么？

JDK（Java Development Kit）即为Java开发工具包，包含编写Java程序所必须的编译、运行等开发工具以及JRE。开发工具如：用于编译java程序的javac命令、用于启动JVM运行java程序的java命令、用于生成文档的javadoc命令以及用于打包的jar命令等等。
JRE（Java Runtime Environment）即为Java运行环境，提供了运行Java应用程序所必须的软件环境，包含有Java虚拟机（JVM）和丰富的系统类库。系统类库即为java提前封装好的功能类，只需拿来直接使用即可，可以大大的提高开发效率。
JVM（Java Virtual Machines）即为Java虚拟机，提供了字节码文件（.class）的运行环境支持。简单说，就是JDK包含JRE包含JVM。

2.解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。

通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间；而通过new关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为Eden、Survivor（又可分为From Survivor和To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据；程序中的字面量（literal）如直接书写的100、”hello”和常量都是放在常量池中，常量池是方法区的一部分，。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过JVM的启动参数来进行调整，栈空间用光了会引发StackOverflowError，而堆和常量池空间不足则会引发OutOfMemoryError。

4. 强引用，软引用和弱引用区别？
1、强引用
最普遍的一种引用方式，如String s = "abc"，变量s就是“abc”的强引用，只要强引用存在，则垃圾回收器就不会回收这个对象。
2、软引用（SoftReference）
用于描述还有用但非必须的对象。如果内存足够，不回收，如果内存不足，则回收。
一般用于实现内存敏感的高速缓存，软引用可以和引用队列ReferenceQueue联合使用，如果软引用的对象被垃圾回收，JVM就会把这个软引用加入到与之关联的引用队列中。
3、弱引用（WeakReference）
和软引用大致相同。弱引用与软引用区别：弱引用对象有更短生命周期。在垃圾回收器线程扫描它管辖的内存区域过程中，一旦发现有弱引用对象，不管当前内存空间足够与否，都会回收它的内存。
短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。
弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。
4、虚引用（PhantomReference）
就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。
虚引用与软引用和弱引用的一个区别在于：
虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

Java类加载器及如何加载类(双亲委派)

阅读文章：
https://www.ibm.com/developerworks/cn/java/j-lo-classloader/（推荐）
http://blog.csdn.net/zhoudaxia/article/details/35824249

下面继续
https://blog.csdn.net/qq_41701956/article/details/80045532

JVM调优

Java内存结构
内存空间分为：方法区、java堆、java栈、本地方法栈
方法区：又称永久区，使用static关键字修饰，存储常量，当class文件加载时创建（初始化），所有线程都会共享，注意线程安全问题。
Java堆：创建对象，new对象、数组存放在堆内存，堆内的所有对象会被共享。根据垃圾回收机制的不同，Java堆有可能拥有不同的结构，最为常见的就是将整个Java堆分为新生代和老年代。其中新生带存放新生的对象或者年龄不大的对象，老年代则存放老年对象。）新生代分为eden区、s0区、s1区，s0和s1也被称为from和to区域，他们是两块大小相等并且可以互相角色的空间。绝大多数情况下，对象首先分配在eden区，在新生代回收后，如果对象还存活，则进入s0或s1区，之后每经过一次新生代回收，如果对象存活则它的年龄就加1，对象达到一定的年龄后，则进入老年代。
③．Java栈：Java栈是一块线程私有的空间，一个栈，一般由三部分组成:局部变量表、操作数据栈和帧数据区
1）局部变量表：用于报错函数的参数及局部变量
2）操作数栈：主要保存计算过程的中间结果，同时作为计算过程中的变量临时的存储空间。
3）帧数据区:除了局部变量表和操作数据栈以外，栈还需要一些数据来支持常量池的解析，这里帧数据区保存着访问常量池的指针，方便计程序访问常量池，另外当函数返回或出现异常时卖虚拟机子必须有一个异常处理表，方便发送异常的时候找到异常的代码，因此异常处理表也是帧数据区的一部分。

JVM参数调优总结
在JVM启动参数中，可以设置跟内存、垃圾回收相关的一些参数设置，默认情况不做任何设置JVM会工作的很好，但对一些配置很好的Server和具体的应用必须仔细调优才能获得最佳性能。通过设置我们希望达到一些目标：
GC的时间足够的小
GC的次数足够的少
发生Full GC的周期足够的长
前两个目前是相悖的，要想GC时间小必须要一个更小的堆，要保证GC次数足够少，必须保证一个更大的堆，我们只能取其平衡。
（1）针对JVM堆的设置，一般可以通过-Xms -Xmx限定其最小、最大值，为了防止垃圾收集器在最小、最大之间收缩堆而产生额外的时间，我们通常把最大、最小设置为相同的值（2）年轻代和年老代将根据默认的比例（1：2）分配堆内存，可以通过调整二者之间的比率NewRadio来调整二者之间的大小，也可以针对回收代，比如年轻代，通过 -XX:newSize -XX:MaxNewSize来设置其绝对大小。同样，为了防止年轻代的堆收缩，我们通常会把-XX:newSize -XX:MaxNewSize设置为同样大小
（3）年轻代和年老代设置多大才算合理？这个我问题毫无疑问是没有答案的，否则也就不会有调优。我们观察一下二者大小变化有哪些影响
更大的年轻代必然导致更小的年老代，大的年轻代会延长普通GC的周期，但会增加每次GC的时间；小的年老代会导致更频繁的Full GC
更小的年轻代必然导致更大年老代，小的年轻代会导致普通GC很频繁，但每次的GC时间会更短；大的年老代会减少Full GC的频率
如何选择应该依赖应用程序对象生命周期的分布情况：如果应用存在大量的临时对象，应该选择更大的年轻代；如果存在相对较多的持久对象，年老代应该适当增大。但很多应用都没有这样明显的特性，在抉择时应该根据以下两点：（A）本着Full GC尽量少的原则，让年老代尽量缓存常用对象，JVM的默认比例1：2也是这个道理（B）通过观察应用一段时间，看其他在峰值时年老代会占多少内存，在不影响Full GC的前提下，根据实际情况加大年轻代，比如可以把比例控制在1：1。但应该给年老代至少预留1/3的增长空间

JVM的内存结构

根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。

1、Java虚拟机栈：线程私有；每个方法在执行的时候会创建一个栈帧，存储了局部变量表，操作数栈，动态连接，方法返回地址等；每个方法从调用到执行完毕，对应一个栈帧在虚拟机栈中的入栈和出栈。
2、堆：线程共享；被所有线程共享的一块内存区域，在虚拟机启动时创建，用于存放对象实例。
3、方法区：线程共享；被所有线程共享的一块内存区域；用于存储已被虚拟机加载的类信息，常量，静态变量等。
4、程序计数器：线程私有；是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。
5、本地方法栈：线程私有；主要为虚拟机使用到的Native方法服务。

【垃圾回收机制】

定义
垃圾回收机制就是不定时去java堆内存清理不可达对象（未被引用对象）
2.算法
算法分为：引用计数法、标记清除、标记压缩、复制算法、分代算法。
引用计数法
定义：每个对象在堆内存会有一个标记，默认是15次，gc回收时，对象不可达减1，可达加1，当次数为0时会被回收
优点：引用计数收集器可以很快的执行，交织在程序中运行，对程序需要不被长时间打断的实时环境有利。
缺点：无法检测到循环引用，并且每次加减非常浪费内存。
复制算法
定义：s0和s1将可用内存按容量分为大小相同的两块，每次只使用一块，当这块内存使用完了，就将还存活的复制到另一块内存上去，然后把使用过的内存一次性清理。这样使得每次对一块内存进行回收，内存分配时不用考虑内存碎片等复杂情况，只需要移动堆指针，按顺序分配内存即可，实现简单，运行高效
缺点：耗费内存，可使用内存降为原来的一半。
标记清除
定义：为每个对象做一个标记（0.可达 1.不可达），对象没有经常使用，将对象标记为1.不可达，直接清除，不具有连续性。
标记压缩：连续性、无碎片，标记清除的升级
❉标记清除和标记压缩用于老年代。
❉应尽量减少垃圾回收机制的执行次数，因为垃圾回收机制执行时会产生卡顿。

内存溢出和内存泄漏的区别

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

Java内存模型及各个区域的OOM，如何重现OOM

这部分内容很重要，详细阅读《深入理解Java虚拟机》，也可以详细阅读这篇文章http://hllvm.group.iteye.com/group/wiki/2857-JVM

Java内存管理及回收算法

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

用什么工具可以查出内存泄漏

一. Memory
Analyzer－是一款开源的JAVA内存分析软件，查找内存泄漏，能容易找到大块内存并验证谁在一直占用它，它是基于Eclipse
RCP(Rich Client Platform)，可以下载RCP的独立版本或者Eclipse的插件。
二. JProbe－分析Java的内存泄漏。
三.JProfiler－一个全功能的Java剖析工具，专用于分析J2SE和J2EE应用程序。它把CPU、执行绪和内存的剖析组合在一个强大的应用中，GUI可以找到效能瓶颈、抓出内存泄漏、并解决执行绪的问题。
四. JRockit－用来诊断Java内存泄漏并指出根本原因，专门针对Intel平台并得到优化，能在Intel硬件上获得最高的性能。
五. YourKit-.NET & Java Profiling业界领先的Java和.NET程序性能分析工具。
六.AutomatedQA －AutomatedQA的获奖产品performance profiling和memory debugging工具集的下一代替换产品，支持Microsoft,Borland, Intel, Compaq 和 GNU编译器。可以为.NET和Windows程序生成全面细致的报告，从而帮助您轻松隔离并排除代码中含有的性能问题和内存/资源泄露问题。支持.Net 1.0,1.1,2.0,3.0和Windows 32/64位应用程序。
七.Compuware DevPartner Java Edition－包含Java内存检测,代码覆盖率测试,代码性能测试,线程死锁,分布式应用等几大功能模块

Java线程池技术及原理

参考文章：
http://www.importnew.com/19011.html
http://www.cnblogs.com/dolphin0520/p/3932921.html

java并发包concurrent及常用的类

参考文章：
并发包诸类概览：http://www.raychase.net/1912
线程池：http://www.cnblogs.com/dolphin0520/p/3932921.html
锁：http://www.cnblogs.com/dolphin0520/p/3923167.html
集合：http://www.cnblogs.com/huangfox/archive/2012/08/16/2642666.html

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变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。

【数据库部分】

慢查询
①.通过命令临时开启慢查询日志
-- 查询是否开启了慢查询
show variables like '%slow%';
-- 开启慢查询日志
set global slow_query_log='ON';
-- 查看慢查询的时间限制(mysql默认的慢查询时间是10秒)
show variables like 'long_query_time';
-- 设置慢查询时间限制(设置慢查询时间限制为1秒)
set long_query_time=1;
-- 慢查询语句(查询超过1秒，日志文件都将记录)
select * from emp where empno=112033
-- 显示慢查询次数
show status like 'slow_queries';

②.通过修改MySql配置文件my.ini
1）.datadir="D:/MySQL5.6/MySQL Server 5.6/data"
log-output=FILE（这个一定要改成FILE，否则慢查询日志不会输出到日志文件）
slow-query-log=on（on表示启用，0表示关闭）
slow_query_log_file="mysql-slow.log"（慢查询日志文件，在上面的datadir目录之下）
long_query_time=1（定义超过1秒的查询就是慢查询，测试时候用，生产环境应该根据实际需要调整在1到10之间的数）
2）.重新启动mysql服务
不过开启慢查询日志记录，将消耗资源，因此，生产环境下，应当按需开启，不应一直开启！！！

2.SQL优化
使用索引
a.使用组合索引时，第一个可以不用和第二个一起作为条件，也会使用组合索引；
b.使用第二个条件不使用第一个条件时，不会使用组合索引；
C.使用第一个和第二个一起查询时会使用组合索引。
②.使用模糊查询like时，在条件前面加%，索引会失效
③.如果条件中有or,即使其中有条件带索引也不会使用。换言之，就是要求使用的所有字段都必须建立索引，建议大家尽量避免使用or关键字
④.如果列类型是字符串，那一定要在条件中将数据用引号包起来，否则不使用索引
⑤．如果mysql估计使用全表扫描要比索引快，则不使用索引
⑥.判断是否为NULL，使用 is NULL,不要使用 =NULL
⑦.group by 分组时不会使用索引，会全表扫描
⑧.group by 分组时，默认会使用升序进行排列，要使分组效率提高，就禁止使用排序（order by NUll）
⑨.in和not in也要慎用，否则会全表扫描，可以使用exits和 not exits代替；对于连续的数值，可以使用between and代替
⑩.应尽量避免在where字句中使用！=或<>,否则会全表扫描
⑪.查询时，避免使用 ，用具体的字段列表代替“”，不要返回用不到的任何字段。

3.添加索引的条件
①．肯定在where条件经常使用
②.该字段的值不是唯一几个值
③．字段内容不是频繁变化

13.数据库索引
索引就像书的目录，通过书的目录就准确的定位到了书籍具体的内容

在了解数据库索引之前，首先了解一下数据库索引的数据结构基础，B+tree
B＋tree 是一个n叉树，每个节点有多个叶子节点，一颗B+树包含根节点，内部节点，叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上叶子节点的节点。

数据库索引是用于提高数据库表的数据访问速度的。
数据库索引的特点：

a）避免进行数据库全表的扫描，大多数情况，只需要扫描较少的索引页和数据页，而不是查询所有数据页。而且对于非聚集索引，有时不需要访问数据页即可得到数据。
b）聚集索引可以避免数据插入操作，集中于表的最后一个数据页面。
c）在某些情况下，索引可以避免排序操作。

想要理解索引原理必须清楚一种数据结构「平衡树」(非二叉)，也就是b tree或者 b+ tree，重要的事情说三遍：“平衡树，平衡树，平衡树”。当然，有的数据库也使用哈希桶作用索引的数据结构，然而，主流的RDBMS都是把平衡树当做数据表默认的索引数据结构的。
索引能让数据库查询数据的速度上升，而使写入数据的速度下降，原因很简单的，因为平衡树这个结构必须一直维持在一个正确的状态，增删改数据都会改变平衡树各节点中的索引数据内容，破坏树结构，因此，在每次数据改变时， DBMS必须去重新梳理树（索引）的结构以确保它的正确，这会带来不小的性能开销，也就是为什么索引会给查询以外的操作带来副作用的原因。
每次给字段建一个新索引，字段中的数据就会被复制一份出来，用于生成索引。因此，给表添加索引，会增加表的体积，占用磁盘存储空间。

二.java基础问题

Switch能否用string做参数
jdk1.7并没有新的指令来处理switch string，
而是通过调用switch中string.hashCode,将string转换为int从而进行判断。
public class TestString {
    static String string = "123";
    public static void main(String[] args) {
        switch (string) {
        case "123":
            System.out.println("123");
            break;
        case "abc":
            System.out.println("abc");
            break;
        default:
            System.out.println("defauls");
            break;
        }
    }
}

 
12.Spring AOP
通知(Adivce)
通知有5种类型
Before  在方法被调用之前调用
After  在方法完成后调用通知，无论方法是否执行成功
After-returning  在方法成功执行之后调用通知
After-throwing  在方法抛出异常后调用通知
Around  通知了、包含了被通知的方法，在被通知的方法调用之前后调用之后执行自定义的行为
切点（Pointcut）
切点在Spring AOP中确实是对应系统中的方法。
但是这个方法是定义在切面中的方法，一般和通知一起使用，一起组成了切面。
连接点（Join point）
连接点就是你准备在系统中执行切点和切入通知的地方（一般是一个方法，一个字段）
切面（Aspect）
切面是切点和通知的集合，一般单独作为一个类。
通知和切点共同定义了关于切面的全部内容，它是什么时候，在何时和何处完成功能。
引入（Introduction）
引用允许我们向现有的类添加新的方法或者属性
织入（Weaving）
组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。
Spring和其他纯Java AOP框架一样，在运行时完成织入。
定义主题接口，这些接口的方法可以成为我们的连接点
public interface Subject {
    public void login();
    public void download();
}
定义实现类,这是代理模式中真正的被代理人（如果你有参与代购，这个就像你在代购中的角色）
public class SubjectImpl implements Subject {
    public void login() {
        System.err.println("借书中...");
    }
    public void download() {
        System.err.println("下载中...");
    }
}
定义切面（切面中有切点和通知）
public class PermissionVerification {
    public void canLogin() {
        //做一些登陆校验
        System.err.println("我正在校验啦！！！！");
    }
    /**
     * 校验之后做一些处理（无论是否成功都做处理）
     * @param args 权限校验参数
     */
    public void saveMessage() {
        //做一些后置处理
        System.err.println("我正在处理啦！！！！");
    }
}

再来看看我们的SpringAOP.xml文件
<aop:config>
 <!-- 这是定义一个切面，切面是切点和通知的集合-->
 <aop:aspect id="do" ref="PermissionVerification">
  <!-- 定义切点 ，后面是expression语言，表示包括该接口中定义的所有方法都会被执行-->
   <aop:pointcut id="point" expression="execution(* wokao666.club.aop.spring01.Subject.*(..))" />
        <!-- 定义通知 -->
        <aop:before method="canLogin" pointcut-ref="point" />
        <aop:after method="saveMessage" pointcut-ref="point" />
       </aop:aspect>
</aop:config>

2.请写出下面几个表达式的结果，答案可以用10进制或16进制书写

1). 0xaa | 0x55
2). 15 & 240
3). 10 ^ 12
4). -2 >> 1
5). -2 >>> 1
1). 分析：十六进制数用0x⋯⋯来表示，后面一个十六进制位是四位，两个十六进制位为一个字节，最多后面可以有8个十六进制位，32个字节,如：0xFFFFFFFF。或（“ | ”）运算，全0为0，其他为1。
所以：0xaa 用二进制表示为 10101010 ,0x55 用二进制表示为 01010101 ,按位或之后为 11111111 ，十进制数为255，十六进制数为 0xFF 。

2). 分析：10进制转换成2进制，用该数字除以2，记录商和余数，利用商再次除以2，记录商和余数⋯⋯直到上为0或余数为0停止，余数逆序组成二进制的从低到高位（最后的余数为二进制最低位）。与（“ & ”）运算，全1为1，其他为0 。
所以： 15 等于1111 ，240等于 11110000，15前面用0补齐为00001111 ，按位与之后为 00000000 ，即结果为0

3). 分析：亦或（“ ^ ”）运算，相同取0，不同取1 。
所以：1010 ^ 1100 =0110 , 十进制表示为6，十六进制表示为 0x06 。

4). 分析：带符号右移（“ >> ”），即有符号位时，负数符号位补1，正数符号位补0， -2 的二进制求法是正数取反加1，因此 2 的二进制表示为0000 0010 ，取反加一为1111 1110 ，即 -2 的二进制表示。
注： >> , << , >>> , 运算符只针对int型和long型，byte ,short ,char型需要转换成Int型在进行操作。
所以：带符号右移之后为 1111 1111 ，除符号位之外，减一取反，得到带符号十进制数为 -1 。

5). 分析：无符号右移 (“ >>> ”) ，即无论正负数，右移之后符号位均补 0 。
所以： -2 的二进制无符号右移一位之后为 0111 1111 1111 1111 1111 1111 1111 1111，即 2^31 - 1,二的三十一次方减一。
注：右移和无符号右移主要区别就在于左面最高位补 0 还是补 1 的问题，无符号右移任何时候最高位都补 0 ，有符号右移则是正数补 0 ，负数补 1 。（没有无符号左移！）。

1.八种基本数据类型的大小，以及他们的封装类

八种基本数据类型：int、short、float、double、long、boolean、byte、char。
封装类分别是：Integer、Short、Float、Double、Long、Boolean、Byte、Character。

public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 将3自动装箱成Integer类型
        int c = 3;
        System.out.println(a == b);     // false，比较的是引用两个引用没有引用同一对象
        System.out.println(Objects.equals(a, b)); // true，比较的是值
        System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
}
float f=3.4;是否正确？
答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型，会造成精度损失，
因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;

java 中有几种类型的流？
字节流，字符流。字节流继承于 InputStream OutputStream，
字符流继承于InputStreamReader OutputStreamWriter。在 java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

一.面向对象模块

"=="和 equals 方法究竟有什么区别？
==如果判断”值类型”的话，判断内容是否相同。如果判断”引用类型”则是判断内存地址是否相同。
Equals判断值内容是否相等

使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

final, finally, finalize 的区别？
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成 final 类型
finally是异常处理语句结构的一部分，表示总是执行。
finalize 是 Object 类的一个方法，在垃圾收集器执行时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 JVM 不保证此方法总被调用

3.重载和重写的区别？
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；
如果父类方法修饰符private则子类中就不是重写。
重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。

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

访问控制符public,protected,private,以及默认的区别？
默认不写，在同包内能访问。
private只有在本类中才能访问；
public在任何地方都能访问；
protected在同包内的类及包外的子类能访问；

2.接口和抽象类的区别是什么？
从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
它们的实现有共同点，不同点在于：
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
接口中所有方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类可以不实现抽象类的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。

接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类
类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

设计层次：
抽象层次不同，抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。
跨域不同：
抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"关系，即父类和派生类在概念本质上应该是相同的。
对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的，仅仅是实现了接口定义的契约而已，"like-a"的关系。

1. 面向对象
面向对象是一种思想，万物都可以看做一个对象，面向对象编程（OOP），Java是一个支持并发、基于类和面向对象的计算机编程语言，面向对象软件开发的优点：代码开发模块化，更易维护和修改；代码复用性强；增强代码的可靠性和灵活性；增加代码的可读性。

Java的四个基本特性（抽象、封装、继承，多态）
抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常叫做类或者接口。
抽象包括两个方面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。
封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行封装隐藏。封装分为属性的封装和方法的封装。
继承：是对有着共同特性的多类事物，进行再抽象成一个类即是多类事物的父类。父类的意义在于抽取多类事物的共性。
多态：是一个类创建出的各种形态的对象。允许不同类的对象对同一消息做出响应。方法的重载、类的覆盖正体现了多态。

面向对象的四大基本特性：
抽象：提取现实世界中某事物的关键特性，为该事物构建模型的过程。对同一事物在不同的需求下，需要提取的特性可能不一样。得到的抽象模型中一般包含：属性（数据）和操作（行为）。这个抽象模型我们称之为类。对类进行实例化得到对象。
封装：封装可以使类具有独立性和隔离性；保证类的高内聚。只暴露给类外部或者子类必须的属性和操作。类封装的实现依赖类的修饰符（public、protected和private等）
继承：对现有类的一种复用机制。一个类如果继承现有的类，则这个类将拥有被继承类的所有非私有特性（属性和操作）。这里指的继承包含：类的继承和接口的实现。
多态：多态是在继承的基础上实现的。多态的三个要素：继承、重写和父类引用指向子类对象。父类引用指向不同的子类对象时，调用相同的方法，呈现出不同的行为；就是类多态特性。多态可以分成编译时多态和运行时多态。
抽象、封装、继承和多态是面向对象的基础。在面向对象四大基础特性之上，我们在做面向对象编程设计时还需要遵循有一些基本的设计原则。

面向对象的特征有哪些方面？
抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
封装：
通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。
多态性：
多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。
多态性分为编译时的多态性和运行时的多态性。
如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。

方法重载（overload）实现是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。
运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：
1). 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
2). 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

posted on 2020-03-25 21:24 左手指月阅读(249) 评论(0) 编辑收藏举报