（2/100）

学习思路如下：

一、JavaSE部分—题目

2、关键字
1、介绍一下Syncronized锁，如果用这个关键字修饰一个静态方法，锁住了什么？如果修饰成员方法，锁住了什么？
2、介绍一下volatile？
3、锁有了解嘛，说一下Synchronized和lock
4、讲一讲Java里面的final关键字怎么用的？

3、面向对象
1、wait方法底层原理
2、Java有哪些特性，举个多态的例子。
3、String为啥不可变？
4、类和对象的区别
5、请列举你所知道的Object类的方法。
6、重载和重写的区别？相同参数不同返回值能重载吗？
7、”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？
8、String能继承吗？
9、StringBuffer和StringBuilder有什么区别，底层实现上呢？
10、类加载机制，双亲委派模型，好处是什么？
11、静态变量存在哪?
12、讲讲什么是泛型？
13、解释extends 和super 泛型限定符-上界不存下界不取
14、是否可以在static环境中访问非static变量？
15、谈谈如何通过反射创建对象？
16、Java支持多继承么？
17、接口和抽象类的区别是什么？
18、Comparable和Comparator接口是干什么的？列出它们的区别。
19、面向对象的特征有哪些方面
20、final, finally, finalize的区别。
21、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
22、abstract class和interface有什么区别?
23、Static Nested Class 和 Inner Class的不同
24、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
25、Java的接口和C++的虚类的相同和不同处。
26、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
27、内部类可以引用他包含类的成员吗？有没有什么限制？
28、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code说法是否正确？
29、重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？
30、如何通过反射获取和设置对象私有字段的值？
31、谈一下面向对象的"六原则一法则"。
32、请问Query接口的list方法和iterate方法有什么区别？
33、Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？
34、Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？
35、hashCode()和equals()方法有什么联系？

答案部分：2）关键字

1、介绍一下Syncronized锁，如果用这个关键字修饰一个静态方法，锁住了什么？如果修饰成员方法，锁住了什么？

答：在synchronized里面，包含有三种常见的锁状态：
1. 同步一个代码块： 锁是指Synchonized括号里配置的对象，如果调用两个对象上的同步代码块，不会进行同步。
2. 同步一个方法： 它和同步代码块一样，作用于同一个对象。锁是当前的对象
3. 同步一个类： 作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
4. 同步一个静态方法： 作用于整个类。锁是指引用当前类的class对象

2、介绍一下volatile？

答：volatile作为java中的关键词之一，用以声明变量的值可能随时会别的线程修改。
1） 使用volatile修饰的变量会强制将修改的值立即写入主存，主存中值的更新会使缓存中的值失效
(非volatile变量不具备这样的特性，非volatile变量的值会被缓存，线程A更新了这个值，线程B读取这个变量的值时可能读到的并不是是线程A更新后的值)。
2） volatile会禁止指令重排
3） volatile具有可见性、有序性，不具备原子性。
注意： volatile不具备原子性，这是volatile与java中的synchronized、java.util.concurrent.locks.Lock最大的功能差异。

__3、锁有了解嘛，说一下Synchronized和lock __

答：S和ReentrantLock都属于可重入锁。

这道题应该是看你对于这俩者的区别和优缺点还有使用场景上的注意。
1） lock是接口，synchronized是关键字
2） lock是显式锁（即加锁和解锁的过程可见并且需要我们自己控制）S是隐式锁。
3） S可以用来修饰方法代码块。Lock的话需要它的一些实现类来做到加锁和解锁，比如我们很长用的ReentrantLock或者分布式领域会用到的ReentrantReadWriteLock。
4） 用法上的话，一般我们S的话不怎么需要关注他的锁释放，因为代码块执行完毕或者报错都会释放锁，而lock的话我们通常需要使用try/catch/finally这种形式在finally中去unlock释放锁。
5） S在读写锁方面没有Lock灵活，设想一下ABC三个线程，俩个读文件一个写文件，如果是S的你只能依次来加锁解锁，而Lock可以让读共享。
另外： S在1.6之前的话是重量级锁，性能远不如ReentrantLock，在1.6以后做了大幅的优化，引入了偏向锁，轻量级锁，自旋锁，自适应自旋，锁粗化，锁消除等机制，具体想看优化详细的话可以参考书籍周志明老师的深入理解java虚拟机的最后一章。

4、讲一讲Java里面的final关键字怎么用的？

答：它的主要用法有以下四种：
1）用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；
2）用来修饰方法参数，表示在变量的生存期中它的值不能被改变；
3）修饰方法，表示该方法无法被重写；
4）修饰类，表示该类无法被继承。
总结：
1.final修饰的类不能继承。
2.final修饰的方法不能重写。
3.final修饰的变量为常量，值不能改变

答案部分：3）面向对象

__1、wait方法底层原理 __

答：object中的wait方法，可以暂停线程，期间会释放对象锁，不像sleep方法，线程休眠期依然持有锁，wait方法的线程，必须调用notify或notifyAll方法唤醒线程！

wait方法会将当前线程放入wait set，等待被唤醒，并放弃lock对象上的所有同步声明。
1、将当前线程封装成ObjectWaiter对象node；
2、通过ObjectMonitor::AddWaiter方法将node添加到_WaitSet列表中；
3、通过ObjectMonitor::exit方法释放当前的ObjectMonitor对象，这样其它竞争线程就可以获取该ObjectMonitor对象。
4、最终底层的park方法会挂起线程；
（最后与之对应的notify方法）会随机唤醒_WaitSet中随机一个线程

2、Java有哪些特性，举个多态的例子。

答：链接：https://www.cnblogs.com/gaopeng527/p/5286223.html
继承、封装、多态。多态的主要特征就是父类引用指向子类对象，生活中的例子：Animal animal = new Dog();
Java面向对象的四大基本特性：抽象、封装、继承、多态。
多态的实现方式：重载、继承、接口

3、String为啥不可变？

答：string是final修饰，不可变，同时string底层是字符串数组也是final修饰，这样做首先是安全，比如hashset中用string做为键，不会出现string变化，导致违反唯一键，另外节约内存。

4、类和对象的区别

答：
1） 类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。
就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2） 对象是类的一个具体。它是一个实实在在存在的东西。
3） 类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
4） 对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

5、请列举你所知道的Object类的方法

答：
clone()： 创建并返回此对象的一个副本。
equals(Object obj)： 指示其他某个对象是否与此对象“相等”。
getClass()： 返回此 Object 的运行时类。
hashCode()： 返回该对象的哈希码值。
notify()： 唤醒在此对象监视器上等待的单个线程
notifyAll()： 唤醒在此对象监视器上等待的所有线程。
toString()： 返回该对象的字符串表示。
wait()： 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，使当前线程处于等待状态。

6、重载和重写的区别？相同参数不同返回值能重载吗？

答：重写是针对父类和子类的概念，重载是针对一个类中的概念；
相同参数不同返回值不可以重载，因为重载必须改变参数列表（否则，虚拟机怎么知道该调用哪一个方法）

相同点： 方法的重载和重写都是实现多态的方式
不同点：
1，重写必须继承，重载不用，
2，重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。
3，重写的方法修饰符大于等于父类的方法，重载和修饰符无关。
4，重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常。

7、”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？

答：
1） static是表示静态的意思，它可用来修饰成员变量和成员函数，被静态修饰的成员函数只能访问静态成员，不能访问非静态成员。静态是随着类的加载而加载，因此可以直接用类进行访问。

2） 覆盖又称为重写，重写就是子类中的方法和子类继承的父类中的方法一样（函数名、参数类型、参数、返回值类型），但子类的访问权限不要低于父类的访问权限。重写的前提是必须要继承，private修饰不支持继承，因此被私有的方法不能重写。静态的方法形式上是可以被重写的，即子类中可以重写父类中的静态方法，但实际上在内存的角度上静态方法是不可以被重写的。

8、String能继承吗？

答：Sting的定义：public final class String extends Object，里边有final关键字，所以不能被继承。

什么样的类不能被继承？
　一，在Java中，只要是被定义为final的类，也可以说是被final修饰的类，就是不能被继承的。
　二，final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。
　三，假如说整个类都是final，就表明自己不希望从这个类继承，或者不答应其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，不希望其子类化（子类处理）。

9、StringBuffer和StringBuilder有什么区别，底层实现上呢？

答：
1） StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，
2） 只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。
3） 在单线程程序下，StringBuilder效率更快，因为它不需要加锁，不具备多线程安全，而StringBuffer则每次都需要判断锁，效率相对更低

总结： StringBuffer线程安全，StringBuilder线程不安全，底层实现上的话，StringBuffer其实就是比StringBuilder多了Synchronized修饰符。

10、类加载机制，双亲委派模型，好处是什么？

答：
虚拟机类加载机制： 虚拟机把描述类的数据从class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。
类从被加载到JVM中，到卸载为止，整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载七个阶段。
类加载机制： 其中类加载过程包括加载、验证、准备、解析和初始化五个阶段。

双亲委派模型：
定义： 某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

好处： 使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类，程序将混乱。因此，如果开发者尝试编写一个与rt.jar类库中重名的Java类，可以正常编译，但是永远无法被加载运行。

11、静态变量存在哪?

答：内存到底分几个区？
1） 栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。
2） 堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由os回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
3） 全局区（静态区）（static）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放。
4） 文字常量区 — 常量字符串就是放在这里的。 程序结束后由系统释放。
5） 程序代码区 — 存放函数体的二进制代码。

12、讲讲什么是泛型？

答：详细链接：https://www.jianshu.com/p/b5a8eef4aa38
泛型：就是一种不确定的数据类型。
// 比如：ArrayList<'E> E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
// 泛型可以省略，如果省略，默认泛型是Object类型。
// 泛型的好处：
// 1. 省略了强转的代码。
// 2. 可以把运行时的问题提前到编译时期。

13、解释extends 和super 泛型限定符-上界不存下界不取

答：总结—在使用泛型时，存取元素时用super,获取元素时，用extends
1） extends也成为上界通配符，就是指定上边界。即泛型中的类必须为当前类的子类或当前类。
2） super也称为下届通配符，就是指定下边界。即泛型中的类必须为当前类或者其父类。

14、是否可以在static环境中访问非static变量？

答：不可以，因为static变量是属于类的，在类加载的时候就被初始化了，这时候非静态变量并没有加载，故静态变量不能访问。

1） 这个要从java的内存机制去分析，首先当你New 一个对象的时候，并不是先在堆中为对象开辟内存空间，而是先将类中的静态方法（带有static修饰的静态函数）的代码加载到一个叫做方法区的地方，然后再在堆内存中创建对象。所以说静态方法会随着类的加载而被加载。当你new一个对象时，该对象存在于对内存中，this关键字一般指该对象，但是如果没有new对象，而是通过类名调用该类的静态方法也可以。

2） 程序最终都是在内存中执行，变量只有在内存中占有一席之地时才会被访问，类的静态成员（变态和方法）属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问，非静态成员（变量和方法）属于类的对象，所以只有在类的对象禅师（创建实例）的时候才会分配内存，然后通过类的对象去访问。

3） 在一个类的静态成员中去访问非静态成员之所以会出错是因为在类的非静态成员不存在的时候静态成员就已经存在了，访问一个内存中不存在的东西当然会出错。

4） 那类是什么时候被加载呢？在需要调用的时候被加载

15、谈谈如何通过反射创建对象？

答：反射的定义，java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意方法和属性。目前反射机制也是java语言独有的，如图所示

16、Java支持多继承么？

答：java不支持多继承，只支持单继承（即一个类只能有一个父类）。
但是java接口支持多继承，即一个子接口可以有多个父接口。（接口的作用是用来扩展对象的功能，一个子接口继承多个父接口，说明子接口扩展了多个功能，当类实现接口时，类就扩展了相应的功能）

17、接口和抽象类的区别是什么？

答：详细链接—https://www.cnblogs.com/jmyyyy/p/10960271.html

18、Comparable和Comparator接口是干什么的？列出它们的区别。

答：详细链接—https://blog.csdn.net/lsqingfeng/article/details/80342620

区别：Comparable和Comparator接口是用来对自定义的class比较大小的，但：

1）Comparator定义在Person的外部：
Comparator是定义在Person的外部的，此时Person类的结构不需要有任何变化，如public class Person{ String name; int age }，然后另外定义一个比较器：public PersonComparator implements Comparator() {…比较Person的大小…}，在PersonComparator里面实现了怎么比较两个Person的大小. 所以用这种方法，要对一个 personList进行排序的时候除了要传递personList过去，还需要把PersonComparator传递过去，因为怎么比较Person的大小是在PersonComparator里面实现的，如Collections.sort( personList , new PersonComparator() )。

2）Comparable定义在Person的内部：
public class Persion implements Comparable {…比较Person的大小…}，因为已经实现了比较器，那么Person现在是一个可以比较大小的对象了，它的比较功能和String完全一样，可以随时随地的拿来比较大小，因为Person现在自身就是有大小之分的。Collections.sort(personList)可以得到正确的结果。

19、面向对象的特征有哪些方面？

答：面向对象的编程语言有封装、继承 、抽象、多态等4个主要的特征。
详细链接：https://www.cnblogs.com/guweiwei/p/6599289.html

20、final, finally, finalize的区别

答：详细链接—https://www.cnblogs.com/ktao/p/8586966.html

1）final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

2）finally是异常处理语句结构的一部分，表示总是执行。

3）finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。

21、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

答：方法的重写Override和重载Overload是Java多态性的不同表现。

重写Override是父类与子类之间多态性的一种表现；重载Overload是一个类中多态性的一种表现。

1）关于重写，如果在子类中定义某方法与其父类有相同的名称和参数，那么我们说该方法被重写了。子类的对象使用这个方法时，将调用子类中的定义。对子类而言，父类中的定义如同被“屏蔽”了一样。

2）关于重载，如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，也就是参数签名不同，这种情况出现方法的重载。重载的方法是可以改变返回值的类型。

3）区分重载方法： 一个类中要是有多个相同名字的方法，Java如何才能知道你指的是哪一个呢？
其实规则很简单，每个重载的方法都必须有一个独一无二的参数类型列表。甚至参数顺序的不同也足以区分两个方法。但是一般情况下别这么做，因为这会使代码难以维护。

22、abstract class和interface有什么区别?

答：详细链接—https://baijiahao.baidu.com/s?id=1619705880454658260&wfr=spider&for=pc

23、Static Nested Class 和 Inner Class的不同

答：详细链接—https://www.cnblogs.com/heartstage/p/3365688.html

24、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

答：是值传递。Java编程语言只有值传递参数。详细链接—https://yq.aliyun.com/articles/607572
当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象，对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。

25、Java的接口和C++的虚类的相同和不同处。

答：C++虚类相当于java中的抽象类，与接口的不同处是：
　　1.一个子类只能继承一个抽象类（虚类），但能实现多个接口
　　2.一个抽象类可以有构造方法，接口没有构造方法
　　3.一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有方法声明
　　4.一个抽象类可以是public、private、protected、default，接口只有public
　　5.一个抽象类中的方法可以是public、private、protected、default，接口中的方法只能是public和default修饰，实际上都是public的abstract方法
相同之处是： 都不能实例化。
补充： 接口是一类特殊的抽象类，是更抽象的抽象类，你可以这样理解。抽象类是一个不完整的类，接口只定义了一些功能。

26、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

答：详细链接—https://www.cnblogs.com/guweiwei/p/6612052.html
throws是获取异常；throw是抛出异常；try是将会发生异常的语句括起来，从而进行异常的处理；catch是如果有异常就会执行他里面的语句；finally不论是否有异常都会进行执行的语句；可以

27、内部类可以引用他包含类的成员吗？有没有什么限制？

答：详细链接—https://www.cnblogs.com/wanglingling/p/7675918.html

28、两个对象值相同(x.equals(y) == true)，却可有不同的hashcode说法是否正确？

答：详细链接—https://www.cnblogs.com/jxxblogs/p/10827664.html
看情况，如果该对象重写了equals方法，那么可能会出现equals相同，但hashcode不同的情况，但假如没有重写equals方法，那么它默认继承是Object的equals方法，根据源码可知，此时equals相同，hashcode一定相同。

29、如何通过反射获取和设置对象私有字段的值？

答：详细链接—https://blog.csdn.net/oMrLai1/article/details/78086419
可以通过类对象的getDeclaredField()方法字段（Field）对象，然后再通过字段对象的setAccessible(true)将其设置为可以访问，接下来就可以通过get/set方法来获取/设置字段的值了。

30、谈一下面向对象的"六原则一法则"

答：详细链接—https://blog.csdn.net/weixin_34293911/article/details/89660250

31、请问Query接口的list方法和iterate方法有什么区别？

答：
1） 返回的类型不一样，list返回List，iterate返回iterator
2） 查询策略不同。获取数据的方式不一样，list会直接查询数据库，iterate会先到数据库中把id取出来，然后真正要遍历某个对象的时候先到缓存中找，如果找不到，以id为条件再发一条sql到数据库，这样如果缓存中没有数据，则查询数据库的次数为n+1
3） iterate会查询2级缓存，list只会缓存，但不会使用缓存（除非结合查询缓存）
4） list中返回的list中每个对象都是原本的对象，iterate中返回的对象是代理对象

32、Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？

答：详细链接—https://www.cnblogs.com/fanvfan/p/7563307.html

33、Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？

答：
1） 当新对象被创建的时候，会调用构造函数，每一个类都有构造函数。
2） 在程序员没有给类提供构造函数的情况下，java编译器会为这个类创建一个默认的构造函数。
3） 构造函数的重载和方法重载相似，可以为一个类创建多个构造函数，每个构造函数都必须有他唯一的参数列表。
4） java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不是自己写的构造函数的情况下，java不会创建默认的复制构造函数。

34、hashCode()和equals()方法有什么联系？

答：详细链接—https://www.cnblogs.com/jesonjason/p/5492208.html

第2天(1/1)。