面试题:已看1

集合篇

• 在迭代一个集合的时候，如何避免ConcurrentModificationException? 
  在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。
• Iterater和ListIterator之间有什么区别？ 
  （1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。 
  （2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。 
  （3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。
• HashSet和TreeSet有什么区别？ 
  HashSet是由一个哈希表来实现的，元素无，add()，remove()，contains()方法的时间复杂度是O(1)。 
  另一方面，TreeSet是由一个树形结构（平衡二叉排序树）来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。
• Enumeration接口和Iterator接口的区别有哪些？ 
  Enumeration速度是Iterator的2倍，同时占用更少的内存。 
  但是，Iterator远远比Enumeration安全，因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时，Iterator允许调用者删除底层集合里面的元素，这对Enumeration来说是不可能的。
• ArrayList和LinkedList有什么区别？ 
  两者都实现了List接口，他们有以下不同点： 
  数据结构上： 
  ArrayList是基于索引的数组形式，可随机访问元素， 时间复杂度O(1)； 
  LinkedList是元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。 
  操作上： 
  ArrayList添加，删除操作比较慢，重新计算大小或者是更新索引。 
  LinkedList的插入，添加，删除操作速度更快，不需要更新索引。 
  内存上： 
  LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素。
• Collection 和 Collections的区别： 
  Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。 
  Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

• Map接口 
  |–Hashtable：底层是哈希散列表数据结构，线程同步。不可以存储null键，null值。不可序列化，使用bucket结构体表示单个元素，使用双重散列法（闭散列法）解决冲突（二度哈希，size>length时要进行模运算）。

  |–HashMap：底层是哈希表数据结构（链地址法解决冲突），线程不同步。可存一个null键和多个null值。替代了Hashtable. 但可通过Map m = Collections.synchronizeMap(hashMap)实现同步； 
  |–LinkedHashMap，采用双向链表数据结构连接起来所有的entry，保证了存入和取出顺序一致，即链表有序；线程不同步。

  |–TreeMap：底层是二叉树结构（平衡二叉排序树），可以对map集合中的键进行指定顺序的排序

• TreeSet集合排序有两种方式，Comparable和Comparator区别： 
  1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。 
  2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。第二种方式较为灵活。
• 因为Comparable.compareTo(Object o)方法实现只能基于一个字段进行排序，我们不能根据对象排序的需要选择字段。Comparator接口的compare(Object o1, Object o2)方法的实现需要传递两个对象参数，若第一个参数比第二个小，返回负整数；若第一个等于第二个，返回0；若第一个比第二个大，返回正整数。
• ArrayList，LinkedList，Vector的区别 
  List：有序(元素存入集合的顺序和取出的顺序一致)元素都有索引。元素可以重复。（有序可重复） 
  |–ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。默认大小10，1.5倍长度扩容。 
  |–LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。 
  |–Vector：底层的数据结构就是数组，线程同步，Vector无论查询和增删都巨慢。默认大 小10，2倍长度扩容
• 集合和数组的区别： 
  1：数组是固定长度的；集合可变长度的。 
  2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。 
  3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
• ArrayList 和 LinkedList 有什么区别。 
  ArrayList和LinkedList都实现了List接口，有以下的不同点： 
  1、ArrayList是基于索引的数据接口，它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应，LinkedList是以元素列表的形式存储它的数据，每一个元素都和它的前一个和后一个元素链接在一起，在这种情况下，查找某个元素的时间复杂度是O(n)。 
  2、相对于ArrayList，LinkedList的插入，添加，删除操作速度更快，因为当元素被添加到集合任意位置的时候，不需要像数组那样重新计算大小或者是更新索引。 
  3、LinkedList比ArrayList更占内存，因为LinkedList为每一个节点存储了两个引用，一个指向前一个元素，一个指向下一个元素

多线程篇

• 透彻理解 Java synchronized 对象锁和类锁的区别

Hibernate

• 1、什么是Hibernate的并发机制？怎么去处理并发问题？ 
  Hibernate并发机制： 
  a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常只使用一次, 然后就丢弃。 
  如果一个Session 实例允许共享的话，那些支持并发运行的,例如Http request,session beans将会导致出现资源争用。 
  如果在Http Session中有hibernate的Session的话,就可能会出现同步访问Http Session。只要用户足够快的点击浏览器的“刷新”, 就会导致两个并发运行的线程使用同一个Session。 
  1 
  2 
  3 
  4 
  b、多个事务并发访问同一块资源,可能会引发第一类丢失更新，脏读，幻读，不可重复读，第二类丢失更新一系列的问题。 
  解决方案：设置事务隔离级别。 
  Serializable：串行化。隔离级别最高 
  Repeatable Read：可重复读 
  Read Committed：已提交数据读 
  Read Uncommitted：未提交数据读。隔离级别最差 
  设置锁：乐观锁和悲观锁。 
  乐观锁：使用版本号或时间戳来检测更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本或者时间戳属性映射的情况下实现 版本检查，此时Hibernate将比较一行记录的每个字段的状态 行级悲观锁：Hibernate总是使用数据库的锁定机制，从不在内存中锁定对象！只要为JDBC连接指定一下隔 离级别，然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别：LockMode.UPGRADE,LockMode.UPGRADE_NOWAIT,LockMode.READ;

• 2、update和saveOrUpdate的区别？ 
  update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。 
  update()方法操作的对象必须是持久化了的对象。也就是说，如果此对象在数据库中不存在的话，就不能使用update()方法。 
  saveOrUpdate()方法操作的对象既可以使持久化了的，也可以使没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会 更新数据库中的对象；如果是未持久化的对象使用此方法,则save到数据库中。

• 3、hibernate的三种状态之间如何转换 
  当对象由瞬时状态(Transient)一save()时，就变成了持久化状态； 
  当我们在Session里存储对象的时候，实际是在Session的Map里存了一份， 也就是它的缓存里放了一份，然后，又到数据库里存了一份，在缓存里这一份叫持久对象(Persistent)。 Session 一 Close()了,它的缓存也都关闭了,整个Session也就失效了,这个时候，这个对象变成了游离状态(Detached)，但数据库中还是存在的。 
  当游离状态(Detached)update()时，又变为了持久状态(Persistent)。 
  当持久状态(Persistent)delete()时，又变为了瞬时状态(Transient), 此时，数据库中没有与之对应的记录。

• 4、比较hibernate的三种检索策略优缺点 
  1立即检索； 
  优点： 对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便的从一个对象导航到与它关联的对象； 
  缺点： 1.select语句太多；2.可能会加载应用程序不需要访问的对象白白浪费许多内存空间； 
  2延迟检索： 
  优点： 由应用程序决定需要加载哪些对象，可以避免可执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并且能节省内存空间； 
  缺点： 应用程序如果希望访问游离状态代理类实例，必须保证他在持久化状态时已经被初始化；

• 3 迫切左外连接检索 
  优点： 1对应用程序完全透明，不管对象处于持久化状态，还是游离状态，应用程序都可以方便地冲一个对象导航到与它关联的对象。2使用了外连接，select语句数目少； 
  缺点： 1 可能会加载应用程序不需要访问的对象，白白浪费许多内存空间；2复杂的数据库表连接也会影响检索性能；

• 5、如何在控制台看到hibernate生成并执行的sql 
  在定义数据库和数据库属性的文件applicationConfig.xml里面，把hibernate.show_sql 设置为true 
  这样生成的SQL就会在控制台出现了 
  注意：这样做会加重系统的负担，不利于性能调优

• 6、hibernate都支持哪些缓存策略 
  Read-only: 这种策略适用于那些频繁读取却不会更新的数据，这是目前为止最简单和最有效的缓存策略

• Read/write:这种策略适用于需要被更新的数据，比read-only更耗费资源，在非JTA环境下，每个事务需要在session.close和session.disconnect()被调用
• Nonstrict read/write: 这种策略不保障两个同时进行的事务会修改同一块数据，这种策略适用于那些经常读取但是极少更新的数据

• Transactional: 这种策略是完全事务化得缓存策略，可以用在JTA环境下

• 7、hibernate里面的sorted collection 和ordered collection有什么区别 
  sorted collection是在内存中通过Java比较器进行排序的 
  ordered collection是在数据库中通过order by进行排序的

• 8、Hibernate工作原理及为什么要用？ 
  1.读取并解析配置文件 
  2.读取并解析映射信息，创建SessionFactory 
  3.打开Sesssion 
  4.创建事务Transation 
  5.持久化操作 
  6.提交事务 
  7.关闭Session 
  8.关闭SesstionFactory 
  为什么要用： 
  对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 
  Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 
  hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 
  hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

• 10、Hibernate是如何延迟加载? 
  当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

• 11、Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)  
  类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

• 12、说下Hibernate的缓存机制 
  内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

二级缓存： 
a) 应用及缓存 
b) 分布式缓存 
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 
c) 第三方缓存的实现

• 13、Hibernate的查询方式 
  Sql、Criteria,objectcomposition 
  Hql： 
  1、 属性查询 
  2、 参数查询、命名参数查询 
  3、 关联查询 
  4、 分页查询 
  5、 统计函数

• 14、如何优化Hibernate？ 
  1.使用双向一对多关联，不使用单向一对多 
  2.灵活使用单向一对多关联 
  3.不用一对一，用多对一取代 
  4.配置对象缓存，不使用集合缓存 
  5.一对多集合使用Bag,多对多集合使用Set

  1. 继承类使用显式多态
  2. 表字段要少，表关联不要怕多，有二级缓存撑腰

• 15、Hibernate有哪几种查询数据的方式 
  3种：hql、条件查询QBC(QueryBy Criteria)、原生sql （通过createSQLQuery建立）

• 16、谈谈Hibernate中inverse的作用 
  inverse属性默认是false,就是说关系的两端都来维护关系。 
  比如Student和Teacher是多对多关系，用一个中间表TeacherStudent维护。Gp)i 
  如果Student这边inverse=”true”, 那么关系由另一端Teacher维护，就是说当插入Student时，不会操作TeacherStudent表（中间表）。只有Teacher插入或删除时才会触发对中间表的操作。所以两边都inverse=”true”是不对的，会导致任何操作都不触发对中间表的影响；当两边都inverse=”false”或默认时，会导致在中间表中插入两次关系。

• 17、Detached Object（游离对象）有什么好处 
  Detached Object（游离对象）可以传递到任何层直到表现层而不是用任何DTO(DataTransfer Objects). 然后你还可以重新把游离对象赋给另外一个Session.

• 18、JDBC hibernate 和 ibatis 的区别 
  jdbc:手动 
  手动写sql 
  delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。 
  select:返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。 
  ibatis的特点:半自动化 
  sql要手动写 
  delete、insert、update:直接传入一个对象 
  select:直接返回一个对象 
  hibernate:全自动 
  不写sql,自动封装 
  delete、insert、update:直接传入一个对象 
  select:直接返回一个对象

• 19、在数据库中条件查询速度很慢的时候,如何优化? 
  1.建索引 
  2.减少表之间的关联 
  3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面 
  4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

• 20、什么是SessionFactory,她是线程安全么？ 
  SessionFactory 是Hibrenate单例数据存储和线程安全的，以至于可以多线程同时访问。一个SessionFactory 在启动的时候只能建立一次。SessionFactory应该包装各种单例以至于它能很简单的在一个应用代码中储存.

• 21、Hibernate的五个核心接口 
  Configuration 接口：配置Hibernate，根据其启动hibernate，创建 
  SessionFactory 对象； 
  SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建 
  session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应 
  用的多个线程共享，是重量级、二级缓存； 
  Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的， 
  避免多个线程共享同一个session，是轻量级、一级缓存； 
  Transaction 接口：管理事务； 
  Query 和Criteria 接口：执行数据库的查询

• 23.Hibernate中GET和LOAD的区别？ 
  请注意如果没有匹配的数据库记录，load()方法可能抛出无法恢复的异常(unrecoverable exception)。 如果类的映射使用了代理(proxy)，load()方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。 如果为相应类映射关系设置了batch-size， 那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。 如果你不确定是否有匹配的行存在，应该使用 get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。 
  session.get 方法， 查询立即执行 ， 返回Customer类对象 
  session.load 方法，默认采用延迟加载数据方式，不会立即查询，返回 Customer类子类对象 （动态生成代理对象）
• 如果 PO类使用final修饰，load无法创建代理对象，返回目标对象本身 （load效果和 get效果 相同 ）
• 24.说说在 hibernate中使用Integer做映射和使用int做映射之间有什么差别？ 
  Integer code和int code的区别: 
  Integer是对象. code=null; 对象可以为空. 
  int 是普通类型, 不可能=null. 
  根据你的数据库code是可以空的,故应该映射成Integer. 
  你没理由hbm.xml里写 Integer,类里却写int
• .25SQL和HQL有什么区别？ 
  sql 面向数据库表查询 
  hql 面向对象查询 
  hql：from 后面跟的 类名＋类对象 where 后 用 对象的属性做条件 
  sql：from 后面跟的是表名 where 后 用表中字段做条件 
  查询 
  在Hibernate中使用查询时，一般使用Hql查询语句。 
  HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。 
  使用HQL时需要注意以下几点： 
  1.大小写敏感 
  因为HQL是面向对象的，而对象类的名称和属性都是大小写敏感的，所以HQL是大小写敏感的。 
  HQL语句：from Cat as cat where cat.id > 1;与from Cat as cat where cat.ID > 1;是不一样的，这点与SQL不同。 
  2.from子句 
  from Cat，该句返回Cat对象实例，开发人员也可以给其加上别名，eg. from Cat as cat，对于多表查询的情况，可参考如下： 
  from Cat as cat, Dog as dog 
  其它方面都与SQL类似，在此不再赘述。
• .26Hibernate的分页查询 
  例如：从数据库中的第20000条数据开始查后面100条记录 
  Query q = session.createQuery(“from Cat as c”);; 
  q.setMaxResults(100);; 
  List l = q.list();; 
  q.setFirstResult(20000);
• 27.Hibernate中Java对象的状态以及对应的特征有哪些？ 
  持久化对象的三种状态 
  持久化对象PO和OID 
  PO=POJO + hbm映射配置 
  编写规则 
  ①必须提供无参数public构造器 
  ②所有属性private，提供public的getter和setter方法 
  ③必须提供标识属性，与数据表中主键对应，例如Customer类 id属性 
  ④PO类属性应尽量使用基本数据类型的包装类型(区分空值) 例如int—Integer long—Long 
  ⑤不要用final修饰（将无法生成代理对象进行优化） 
  OID 指与数据表中主键对应 PO类中属性，例如 Customer类 id属性 
  Hibernate框架使用OID来区分不同PO对象 
  * 例如内存中有两个PO对象，只要具有相同 OID， Hibernate认为同一个对象 
  
  • Hibernate 不允许缓存同样OID的两个不同对象 
    ①瞬时态(临时态、自由态)：不存在持久化标识OID，尚未与Hibernate Session关联对象，被认为处于瞬时态，失去引用将被JVM回收 
    ②持久态：存在持久化标识OID，与当前session有关联，并且相关联的session没有关闭 ,并且事务未提交 
    ③脱管态(离线态、游离态)：存在持久化标识OID，但没有与当前session关联，脱管状态改变hibernate不能检测到 
    区分三种状态：判断对象是否有OID，判断对象是否与session关联(被一级缓存引用) 
    // 获得Session 
    Session session =HibernateUtils.openSession(); 
    // 开启事务 
    Transaction transaction = session.beginTransaction(); 
    Book book =newBook();// 瞬时态(没有OID，未与Session关联) 
    book.setName(“hibernate精通”); 
    book.setPrice(56d); 
    session.save(book);// 持久态(具有OID，与Session关联) 
    // 提交事务，关闭Session 
    transaction.commit(); 
    session.close(); 
    System.out.println(book.getId());// 脱管态(具有 OID，与Session断开关联) 
    持久化对象状态转换 
    ①瞬时态对象：通过new获得 
    瞬时—–>持久 save、saveOrUpdate(都是session) 
    瞬时—–>脱管 book.setId(1) 为瞬时对象设置OID 
    ②持久态对象：通过get/load 、Query查询获得 
    持久—–>瞬时 delete （被删除持久化对象 不建议再次使用 ） 
    持久—–>脱管 evict(清除一级缓存中某一个对象)、close(关闭Session，清除一级缓存)、clear(清除一级缓存所有对象 ) 
    ③脱管态对象 无法直接获得 
    脱管—–>瞬时 book.setId(null); 删除对象OID 
    脱管—–>持久 update、saveOrUpdate、 lock(过时

Struts

Spring

SQL

数据库建立索引的原则 
1，确定针对该表的操作是大量的查询操作还是大量的增删改操作。

2，尝试建立索引来帮助特定的查询。检查自己的sql语句，为那些频繁在where子句中出现的字段建立索引。

3，尝试建立复合索引来进一步提高系统性能。修改复合索引将消耗更长时间，同时，复合索引也占磁盘空间。

4，对于小型的表，建立索引可能会影响性能

5，应该避免对具有较少值的字段进行索引。

6，避免选择大型数据类型的列作为索引。

索引建立的原则

索引查询是数据库中重要的记录查询方法，要不要进入索引以及在那些字段上建立索引都要和实际数据库系统的查询要求结合来考虑，下面给出实际中的一些通用的原则：

1. 在经常用作过滤器的字段上建立索引；

2. 在SQL语句中经常进行GROUP BY、ORDER BY的字段上建立索引；

3. 在不同值较少的字段上不必要建立索引，如性别字段；

4. 对于经常存取的列避免建立索引；

5. 用于联接的列（主健/外健）上建立索引；

6. 在经常存取的多个列上建立复合索引，但要注意复合索引的建立顺序要按照使用的频度来确定；

7. 缺省情况下建立的是非簇集索引，但在以下情况下最好考虑簇集索引，如：含有有限数目（不是很少）唯一的列；进行大范围的查询；充分的利用索引可以减少表扫描I/0的次数，有效的避免对整表的搜索。当然合理的索引要建立在对各种查询的分析和预测中，也取决于DBA的所设计的数据库结构。

异常

• 请列出 5 个运行时异常。
• 我们比较熟悉的Checked异常有 
  Java.lang.ClassNotFoundException 
  Java.lang.NoSuchMetodException 
  java.io.IOException 
  我们比较熟悉的RumtimeException类的子类有 
  Java.lang.ArithmeticException 
  Java.lang.ArrayStoreExcetpion 
  Java.lang.ClassCastException 
  Java.lang.IndexOutOfBoundsException 
  Java.lang.NullPointerException

反射

基础

• 什么是JDK？什么是JRE? 
  JDK：java development kit：java开发工具包，是开发人员所需要安装的环境 
  JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境
• Java的数据结构有那些 
  线性表（ArrayList） 
  链表（LinkedList） 
  栈（Stack） 
  队列（Queue） 
  图（Map） 
  树（Tree）
• Static关键字有什么作用？ 
  Static可以修饰内部类、方法、变量、代码块 
  Static修饰的类是静态内部类 
  Static修饰的方法是静态方法，表示该方法属于当前类的，而不属于某个对象的，静态方法也不能被重写，可以直接使用类名来调用。在static方法中不能使用this或者super关键字。 
  Static修饰变量是静态变量或者叫类变量，静态变量被所有实例所共享，不会依赖于对象。静态变量在内存中只有一份拷贝，在JVM加载类的时候，只为静态分配一次内存。 
  Static修饰的代码块叫静态代码块，通常用来做程序优化的。静态代码块中的代码在整个类加载的时候只会执行一次。静态代码块可以有多个，如果有多个，按照先后顺序依次执行
• 内部类与静态内部类的区别？ 
  静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。但是可以直接访问静态的变量、调用静态的方法； 
  普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。 
  如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。 
  如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个普通内部类的对象作为一个属性，外同类可以通过该属性调用普通内部类的方法或者访问普通内部类的属性 
  如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。

• String， Stringbuffer， StringBuilder 的区别。 
  String 字符串常量(final修饰，不可被继承)，String是常量，当创建之后即不能更改。(可以通过StringBuffer和StringBuilder创建String对象(常用的两个字符串操作类)。) 
  StringBuffer 字符串变量（线程安全）,其也是final类别的，不允许被继承，其中的绝大多数方法都进行了同步处理，包括常用的Append方法也做了同步处理(synchronized修饰)。其自jdk1.0起就已经出现。其toString方法会进行对象缓存，以减少元素复制开销。 
  public synchronized String toString() { 
  if (toStringCache == null) { 
  toStringCache = Arrays.copyOfRange(value, 0, count); 
  } 
  return new String(toStringCache, true); 
  } 
  StringBuilder 字符串变量（非线程安全）其自jdk1.5起开始出现。与StringBuffer一样都继承和实现了同样的接口和类，方法除了没使用synch修饰以外基本一致，不同之处在于最后toString的时候，会直接返回一个新对象。 
  public String toString() { 
  // Create a copy, don’t share the array 
  return new String(value, 0, count); 
  }

• 抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。 
  1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。 
  2、抽象类要被子类继承，接口要被类实现。 
  3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现 
  4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。 
  5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。 
  6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。 
  7、抽象类里可以没有抽象方法 
  8、如果一个类里有抽象方法，那么这个类只能是抽象类 
  9、抽象方法要被实现，所以不能是静态的，也不能是私有的。 
  10、接口可继承接口，并可多继承接口，但类只能单根继承。

• 继承和聚合的区别在哪。 
  继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性； 
  聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；