Java基础-关键字-面对对象

❤1、Java基础

1、为什么重写equals还要重写hashcode

• 简单的说就是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。
• 为了提高程序的效率才实现了hashcode方法，先进行hashcode的比较，如果不同，那没就不必在进行equals的比较了，这样就大大减少了equals比较的次数，

2、说一下map的分类和常见的情况

• HashMap结构是数组+链表（节点超过八个自动转成红黑树）
• Hashtable的每一个方法都加上了synchronized，因此是线程安全的
• 一般不使用Hashtable，使用Collections.synchronizedMap(Map
  map);将非线程安全的map转换成线程安全的map。或者使用java.util.concurrent.ConcurrentHashMap
• ConcurrentHashMap1.8之前是使用segment分段锁实现，1.8之后直接采用一个大数组使用cas和synchronized（针对首节点进行加锁）
• TreeMap是利用红黑树构造的有序map
• LinkedHashMap底层是双向链表，使用了LRU

3、Object若不重写hashCode()的话，hashCode()如何计算出来的？

Object 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法直接返回对象的 内存地址。

5、若对一个类不重写，它的equals()方法是如何比较的？

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

6、java8新特性

• Lambda 表达式 − Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中。
• 方法引用−
  方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
• 默认方法− 默认方法就是一个在接口里面有了一个实现的方法。 新工具− 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。
• Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。
  Date Time API − 加强对日期与时间的处理。
• Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
• Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn
  javascript引擎，它允许我们在JVM上运行特定的javascript应用。*

7、说说Lamda表达式的优缺点。

• 优点：1. 简洁。2. 非常容易并行计算。3. 可能代表未来的编程趋势。
• 缺点：1. 若不用并行计算，很多时候计算速度没有比传统的 for 循环快。（并行计算有时需要预热才显示出效率优势）2. 不容易调试。3.
  若其他程序员没有学过 lambda 表达式，代码不容易让其他语言的程序员看懂。

8、一个十进制的数在内存中是怎么存的？

补码的形式存储的

9、为啥有时会出现4.0-3.6=0.40000001这种现象？

在二进制系统中无法精确地表示分数1/10，这就好像十进制无法精确地表示分数1/3一样。如果在数值计算中不允许有任何舍入误差 ，就应该使用BigDecimal类。

10、Java支持的数据类型有哪些？什么是自动拆装箱？
基本数据类型：

整数值型：byte,short,int,long,

字符型：char

浮点类型：float,double

布尔型：boolean

整数默认int型，小数默认是double型。Float和long类型的必须加后缀。

首先知道String是引用类型不是基本类型，引用类型声明的变量是指该变量在内存中实际存储的是一个引用地址，实体在堆中。引用类型包括类、接口、数组等。String类还是final修饰的。
而包装类就属于引用类型，自动装箱和拆箱就是基本类型和引用类型之间的转换，至于为什么要转换，因为基本类型转换为引用类型后，就可以new对象，从而调用包装类中封装好的方法进行基本类型之间的转换或者toString（当然用类名直接调用也可以，便于一眼看出该方法是静态的），还有就是如果集合中想存放基本类型，泛型的限定类型只能是对应的包装类型。

11、什么是值传递和引用传递？

public void add(int a) { int b = a; } 这个可以看作是值传递，a是基本数据类型，他把他的值传给了b public void add(Object obj) { Object objTest = obj; } 这个可以看作是址传递，obj是引用数据类型，是把他栈中指向堆中的对象的地址值赋值给了objTest. 这时候就同时有两个引用指向了堆中的某个Object对象 其实这样看来，java应该只有值传递的。如果是基本数据类型，传递的就是实际的值. 如果是引用数据类型，传递的就是该引用的地址值.

12、数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array而不是ArrayList？

ArrayList可以算是Array的加强版，（对array有所取舍的加强）。

存储内容比较：
Array数组可以包含基本类型和对象类型，
ArrayList却只能包含对象类型。
但是需要注意的是：Array数组在存放的时候一定是同种类型的元素。ArrayList就不一定了，因为ArrayList可以存储Object。

空间大小比较：
它的空间大小是固定的，空间不够时也不能再次申请，所以需要事前确定合适的空间大小。
ArrayList的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大一倍的新数组，然后将所有元素复制到新数组中，接着抛弃旧数组。而且，每次添加新的元素的时候都会检查内部数组的空间是否足够。（比较麻烦的地方）。

方法上的比较：
ArrayList作为Array的增强版，当然是在方法上比Array更多样化，比如添加全部addAll()、删除全部removeAll()、返回迭代器iterator()等。

适用场景：
如果想要保存一些在整个程序运行期间都会存在而且不变的数据，我们可以将它们放进一个全局数组里，但是如果我们单纯只是想要以数组的形式保存数据，而不对数据进行增加等操作，只是方便我们进行查找的话，那么，我们就选择ArrayList。而且还有一个地方是必须知道的，就是如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用ArrayList就真的不是一个好的选择，因为它的效率很低，使用数组进行这样的动作就很麻烦，那么，我们可以考虑选择LinkedList。

13、你了解大O符号(big-O notation)么？你能给出不同数据结构的例子么？

大O符号表示一个程序运行时所需要的渐进时间复杂度上界。
其函数表示是：
对于函数f(n),g(n),如果存在一个常数c，使得f(n)<=c*g(n),则f(n)=O(g(n));
大O描述当数据结构中的元素增加时，算法的规模和性能在最坏情景下有多好。
大O还可以描述其它行为，比如内存消耗。因为集合类实际上是数据结构，因此我们一般使用大O符号基于时间，内存，性能选择最好的实现。大O符号可以对大量数据性能给予一个很好的说明。

14、String是最基本的数据类型吗?
15、int 和 Integer 有什么区别

int是基本数据类型， Integer是包装类 。int的速度快，Integer的速度慢。int放在栈中，Integer放在堆中。int初始值为0，Integer初始值为null。

16、String 和StringBuffer的区别

String是final类，意味着一旦赋值，不可改变。而StringBuffer是可以改变的，通常谈到这俩者还有引入StringBuffer，三者联系起来来比较看他们的使用。StringBuffer是线程安全的，因为它内部使用了synchronized修饰，所以效率比builder要弱15%。三者builder最快其次buffer最后是String。

17、我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串？

Public String translate (String str) {
String tempStr = “”;
try {
tempStr = new String(str.getBytes(“ISO-8859-1″), “GBK”);
tempStr = tempStr.trim();
}
catch (Exception e) {
System.err.println(e.getMessage());
}
return tempStr;
}

19、&和&&的区别？
逻辑与
&和&&两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
另外&&具有短路的功能，若左边表达式为false，则不验证后边。

20、在Java中，如何跳出当前的多重嵌套循环？

跳出一层break，结束return，跳出当前这一次continue，或者添加一个标记，break 标记；接跳到标记那

21、你能比较一下Java和JavaSciprt吗？

java:面向对象;需要编译，再进行运行;强类型.javascript:基于对象和事件驱动;解释型语言;弱类型！

23、Java中是如何支持正则表达式操作的？

Java中的String类提供了支持正则表达式操作的方法，包括：matches()、replaceAll()、replaceFirst()、split()。此外，Java中可以用Pattern类表示正则表达式对象，它提供了丰富的API进行各种正则表达式操作，如：

 `import java.util.regex.Matcher; 
 import java.util.regex.Pattern; 
 class RegExpTest {   
 	  public static void main(String[] args) {         
 	  	String str = "成都市(成华区)(武侯区)(高新区)";       
 	  	  Pattern p = Pattern.compile(".*?(?=\\()");       
 	  	    Matcher m = p.matcher(str);         if(m.find()) {             
 	  	    System.out.println(m.group());         }     } }`

**❤2、关键字

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

在synchronized里面，包含有三种常见的锁状态：

对于普通的同步方法：
锁是当前的对象
对于静态函数的同步方法：
锁是指引用当前类的class对象
对于同步方法块的内容：
锁是指Synchonized括号里配置的对象

2、介绍一下volatile？

• volatile主要作用是告诉程序，所有线程读取该变量的时候需要从主线程中读取，而不是从各个线程的本地拷贝中读取。而且每个被volatile修饰的变量在发生变化之后，都需要重新刷入主内存当中。Java中的volatile关键字只是用于一个单独的变量，和synchronized不一样的是，synchronized是用于修饰代码块和函数体的，由于synchronized需要同步线程和主内存之间所有变量的值，并且锁定和释放监视器，因此synchronized比volatile的性能开销会更大一些。

• 想要深入了解volatile关键字，需要知道两个概念，一个是内存可见性，一个叫指令重排序。内存可见性需要知道相应的内存模型（JMM），也就是以下这张图：

  jmm内存模型的大致意思就是，每个线程从主存中读取数据的时候，都会在本地线程中做一份拷贝，然后每个线程都会有自己的独立拷贝，这些拷贝不会受到其他线程的影响。
  
  volatile关键字的原理实现

<<Java并发编程的艺术>>: java语言规范第三版中对volatile的定义如下：java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排它锁单独获得这个变量。java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明或volatile，java线程内存模型确保所有线程看到这个变量值是一致的。

那么Volatile是如何来保证可见性的呢？在x86处理器下通过工具获取JIT编译器生成的汇编指令来看看对Volatile进行写操作CPU会做什么事情。

Java代码：

instance = new Singleton();//instance是volatile变量

汇编代码：

0x01a3de1d: movb $0x0,0x1104800(%esi);

0x01a3de24: lock addl $0x0,(%esp);

有volatile变量修饰的共享变量进行写操作的时候会多第二行汇编代码，通过查IA-32架构软件开发者手册可知，lock前缀的指令在多核处理器下会引发了两件事情。

    1. 将当前处理器缓存行的数据会写回到系统内存。

    2. 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效。

什么是内存屏障？

内存屏障（memory barrier）是一个CPU指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。

内存屏障和volatile的关系？

上面的虚拟机指令里面有提到，如果你的字段是volatile，Java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作，你必须知道：1、一旦你完成写入，任何访问这个字段的线程将会得到最新的值。2、在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。

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

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

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

简单而言。被final修饰的类不能继承。被final修饰的方法不能重写。被final修饰的变量为常量，值不能改变。

**❤3、面向对象
1、wait方法底层原理

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

2.多态的实现原理

• 多态通常有两种实现方法： 1、子类继承父类（extends） 2、类实现接口（implements）

• 无论是哪种方法，其核心之处就在于对父类方法的改写或对接口方法的实现，以取得在运行时不同的执行效果。

• 在调用方法时，实际上必须首先完成实例方法的符号引用解析，结果是该符号引用被解析为方法表的偏移量。虚拟机通过对象引用得到方法区中类型信息的入口，查询类的方法表，当将子类对象声明为父类类型时，形式上调用的是父类方法，此时虚拟机会从实际类的方法表（虽然声明的是父类，但是实际上这里的类型信息中存放的是子类的信息）中查找该方法名对应的指针（这里用“查找”实际上是不合适的，前面提到过，方法的偏移量是固定的，所以只需根据偏移量就能获得指针），进而就能指向实际类的方法了。

• 我们的故事还没有结束，事实上上面的过程仅仅是利用继承实现多态的内部机制，多态的另外一种实现方式：实现接口相比而言就更加复杂，原因在于，Java的单继承保证了类的线性关系，而接口可以同时实现多个，这样光凭偏移量就很难准确获得方法的指针。所以在JVM中，多态的实例方法调用实际上有两种指令：

  invokevirtual指令用于调用声明为类的方法；

  invokeinterface指令用于调用声明为接口的方法。

  当使用invokeinterface指令调用方法时，就不能采用固定偏移量的办法，只能老老实实挨个找了（当然实际实现并不一定如此，JVM规范并没有规定究竟如何实现这种查找，不同的JVM实现可以有不同的优化算法来提高搜索效率）。我们不难看出，在性能上，调用接口引用的方法通常总是比调用类的引用的方法要慢。这也告诉我们，在类和接口之间优先选择接口作为设计并不总是正确的，当然设计问题不在本文探讨的范围之内，但显然具体问题具体分析仍然不失为更好的选择

  要使用多态，在声明对象时就应该遵循一条法则：声明的总是父类类型或接口类型，创建的是实际类型。

3、String为啥不可变？

String类源码中是一个value的字符数组，被private final修饰，被final修饰所以就不能变了

4、类和对象的区别

类是抽象的结果，也是一种数据结构，类里面有属性 方法 代码块 构造器 这些是类的基本元素。如果想使用类 ，那么你需要创建一个具体的对象，才能够正常使用类里面的属性和方法， 同时 ，也有专门属于类的属性和方法， 属于类的东西， 可以没有对象也可以使。用 由此可见 对象是从类创建而来。

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

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

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

重写：一个类是继承一个父类时，从父类那儿继承来的方法，进行重新写过。
重载：多个同名方法，名称相同，但是参数不同，可以通过参数来识别调用的是哪一个方法。
相同参数不同返回值不可以重载。

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

“static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。
Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
java中也不可以覆盖private的方法，因为private修饰的变量和方法只能在当前类中使用，如果是其他的类继承当前类是不能访问到private变量或方法的，当然也不能覆盖。

8、String能继承吗？
9、StringBuffer和StringBuilder有什么区别，底层实现上呢？

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

• 类加载，JVM第一次使用到这个类时需要对，这个类的信息进行加载。一个类只会加载一次，之后这个类的信息放在堆空间，静态属性放在方法区。JVM类加载器从上到下一共分为三类
  1.启动类加载器(Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib 目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（按文件名识别，如rt.jar）的类。 2.
  扩展类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext
  目录中的，或通过java.ext.dirs系统变量指定路径中的类库。 3. 应用程序类加载器(Application
  ClassLoader)：负责加载用户路径（classpath）上的类库。
  JVM通过双亲委派模型进行类的加载启动类加载器(Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib
  目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（按文件名识别，如rt.jar）的类。
  扩展类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext
  目录中的，或通过java.ext.dirs系统变量指定路径中的类库。 应用程序类加载器(Application
  ClassLoader)：负责加载用户路径（classpath）上的类库。
  JVM通过双亲委派模型进行类的加载，当然我们也可以通过继承java.lang.ClassLoader实现自定义的类加载器。采用双亲委派的一个好处是比如加载位于rt.jar包中的类java.lang.Object，不管是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载器最终得到的都是同样一个Object对象。
• 双亲委派模型是每次收到类加载请求时，先将请求委派给父类加载器完成，如果父类加载器无法完成加载，那么子类尝试自己加载
• 加载的类是同一个，保证内库更安全，缺点效率低

11、静态变量存在哪?

方法区，静态变量是共享内容，栈是不共享的，堆存放new关键字创建的对象，方法区是共享的区域

12、讲讲什么是泛型？

泛型是一种参数化类型 ，它的<>里面可以放任何类型 而且不要强转 它是多态的一种体现

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

extends 指定上界限，只能传入本类和子类
super 指定下界限，只能传入本类和父类

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

因为静态的成员属于类，随着类的加载而加载到静态方法区内存，当类加载时，此时不一定有实例创建，没有实例，就不可以访问非静态的成员。

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

16、Java支持多继承么？

java中是单继承，一个类只能继承一个类，可以实现多个接口，一个接口可以继承多个接口

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

• 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范
• 1.接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法
  2.接口中的实例变量默认是final类型的，而抽象类中则不一定
  3.一个类可以实现多个接口，但最多只能实现一个抽象类
  4.一个类实现接口的话要实现接口的所有方法，而抽象类不一定
  5.接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象

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

Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说，它返回负数，0，正数来表明已经存在的对象小于，等于，大于输入对象。
Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序，返回负数，0，正数表明第一个参数是小于，等于，大于第二个参数。equals()方法需要一个对象作为参数，它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候，这个方法才返回true。

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

• 三大特征是：封装、继承和多态。
• 封装是指将某事物的属性和行为包装到对象中，这个对象只对外公布需要公开的属性和行为，而这个公布也是可以有选择性的公布给其它对象。如使用private、protected、public三种修饰符或不用（即默认defalut）对外部对象访问该对象的属性和行为进行限制。
• 继承是子对象可以继承父对象的属性和行为，亦即父对象拥有的属性和行为，其子对象也就拥有了这些属性和行为。
• 多态性是指允许不同类的对象对同一消息作出响应。比如同样的加法，把两个时间加在一起和把两个整数加在一起肯定完全不同

20、final, finally, finalize的区别。

• final修饰符添加到类上，则此类为不可变类，添加到成员变量上，则此变量不可修改；
• finalize是Object类中的方法，当对象被标记且回收时执行，有可能使对象不再是垃圾，如果再次被标记准备回收时发现finalize已经被执行过，则直接回收；
• finally是用作配合try catch块使用，无论是否捕获异常，finally块中代码一定在最后执行

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

重写是子类的方法覆盖父类的方法，要求方法名、参数个数和类型、返回值都相同。
重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，函数的参数列表不同(包括参数个数和参数类型)，至于返回类型可同可不同。

所以说，Overloaded 的方法可以改变返回值的类型。
两者区别：Overload没有覆盖，Override必有覆盖

23、Static Nested Class 和 Inner Class的不同

1、Inner Class（内部类）定义在类中的类。 (一般是JAVA的说法)。它的创建依赖一个外部类对象作为宿主，内部类必须寄生在外部类对象中才能创建实例。
2、静态：用来修饰类的内部成员（静态方法、静态成员变量、静态常量）唯一的作用是，跟随类的加载而产生，就可以用 “类 名+静态成员名”获得。
3、静态内部类（嵌套类）：这个类没有必要单独存放一个文件，它一般只被外部类使用，可以直接用 “外部类名+内部类名” 获得
**要创建嵌套类Static Nested Class的对象，并不需要其外围类的对象。

**在静态嵌套类Static Nested Class内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。

若想访问外部类的变量, 必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。

  注意：外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类实例来访问，
  这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，
  内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化均是错误的。

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

传递的是值，只不过这个值是引用的地址值，地址值指向对象，所以改变的对象的内容，地址并没有改变。

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

Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象 来表示的，该对象中包含有异常的信息。而throws\throw\try、catch、finally就是Java中用 来对异常进行处理的几个关键字，在Java编程中规容Java编译器强制普通异常必须try…catch 处理或用throws声明继续抛给上层调用方法处理，一般异常必须要求被捕获和处理，而系统异常可 以处理也可以不处理，所以编译器不强制用try…catch处理或用throws、throw声明异常。而 finally一般与try或try\catch一起使用做为异常的最后

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

内部类分为两种：
1.非静态内部类
非静态方法
可以访问包含类的成员变量
静态成员变量，包括public，protected，private
非静态成员变量，包括public，protected，private
静态方法（非静态内部类不能有静态方法）
必须依附外部类，也就是只有实例化了包含类了后，再用特殊语法才能实例化内部类
2.静态内部类
非静态方法
包含类非静态成员：不能访问
包含类的静态成员：可以访问
静态方法
包含类的非静态成员：不能访问
包含类的静态成员：可以访问

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

有可能，你重写了equals方法就但没重写hashcode方法，就会出现这样的问题。

30、如何通过反射获取和设置对象私有字段的值？
getDeclaredField方法，并且要设置访问权限为true
setAccessible(true)

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

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

对于Query接口的list()方法与iterate()方法来说，都可以实现获取查询的对象，但是list()方法返回的每个对象都是完整的（对象中的每个属性都被表中的字段填充上了），而iterator()方法所返回的对象中仅包含了主键值（标识符），只有当你对iterator中的对象进行操作时，Hibernate才会向数据库再次发送SQL语句来获取该对象的属性值。

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

Java中的构造函数是为了初始化对象的，构造函数的函数名和类名一致，默认的构造函数没有参数，没有返回值，构造函数的函数体内，没有内容。 构造函数的重载是函数名与类名相同，参数类型不同，参数不同。同样的作用也是为了初始化对象的。 Java中没有拷贝构造函数的概念！

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

前提： 谈到hashCode就不得不说equals方法，二者均是Object类里的方法。由于Object类是所有类的基类，所以一切类里都可以重写这两个方法。

原则 1 ： 如果 x.equals(y) 返回 “true”，那么 x 和 y 的 hashCode() 必须相等 ；
原则 2 ： 如果 x.equals(y) 返回 “false”，那么 x 和 y 的 hashCode() 有可能相等，也有可能不等 ；
原则 3 ： 如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ；
原则 4 ： 一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ；
原则 5 ： 当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的equals()和hashCode()设计，而且要遵守前面所说的几个原则。