java基础面试题题库五（传智专修学院2017级Java4班）

-------------------------------------------------------------

本面试题由传智专修学院2017级java4班所有同学合作完成

-------------------------------------------------------------

1.编写多线程程序的几种实现方式（换个问法：创建多线程的方式）

（1）通过继承 Thread 类

（2）通过实现 Runnable 接口（推荐使用，因为 Java 中是单继承，一个类只有一个父类，若继承了 Thread 类，就无法在继承其它类，显然实现 Runnable 接口更为灵活）

（3）通过实现 Callable 接口（Java 5 之后）

2.请说出同步线程及线程调度相关的方法？

1）wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；

2）sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException 异常；

3）notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且与优先级无关；

4）notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

注意：java 5 通过 Lock 接口提供了显示的锁机制，Lock 接口中定义了加锁（lock（）方法）和解锁（unLock（）方法），增强了多线程编程的灵活性及对线程的协调

3.启动一个线程是调用 run) ()方法还是 start()方法？

启动一个线程是调用 start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由 JVM 调度并执行，这并不意味着线程就会立即运行。

run()方法是线程启动后要进行回调（callback）的方法。

4.什么是线程池，有哪些常用线程池？

就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程

不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开

销。

常用线程池：

（1）newSingleThreadExecutor：创建一个单线程的线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

（2）newFixedThreadPool：创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。

（3）newCachedThreadPool：创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说 JVM）能够创建的最大线程大小。

（4）newScheduledThreadPool：创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。

（5）newSingleThreadExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

5.什么是死锁？

两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程都陷入了无限的等待中。

6.如何确保 N N 个线程可以访问 N N 个资源同时又不导致死锁？

使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

7.获得一个类的类对象有哪些方式？

1）：类型.class，例如：String.class

2）：对象.getClass()，例如：”hello”.getClass()

3）：Class.forName()，例如：Class.forName(“java.lang.String”)

8.简述下你了解的设计模式？

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

9.单例模式

单例设计模式

单例模式的好处：

某些类的创建比较频繁，对于一些大型的对象，这是一笔很大的开销。
省去了new的操作，节省了内存的开销，减轻了GC的压力。
有些情况只能用单例的设计模式，例如，一些交易核心，只能用一个对象，不然就会乱套了。

饿汉式：（线程安全的）

public class Singleton {

// 私有的构造方法

private Singleton(){

}

// 指向自己实例的私有静态引用

private static Singleton singleton = new Singleton();

// 以自己实例为返回值的静态的公有的方法

public static Singleton getInstance() {

return singleton;

}

懒汉式（线程不安全）

public class Singleton {

// 私有的构造方法

private Singleton() {

}

// 不建立对象

private static Singleton singleton = null;

// 以自己实例为返回值的静态的公有的方法

public static Singleton getInstance() {

if (singleton == null) {// 先判断是否为空

singleton = new Singleton();// 如果为空建立对象

}

return singleton;

}

注：可以通过枚举实现单例模式的绝对单例

10.工厂模式

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行

11.适配器模式

意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要解决：主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

何时使用：

1、系统需要使用现有的类，而此类的接口不符合系统的需要。

2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。

3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

如何解决：继承或依赖（推荐）。

关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

12. 长度为9的数组进行冒泡排序最少需要比较多少？（李佳琳）

36次

冒泡排序算法原理：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

int tempNums[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};int count = 0;for (int i = 0; i < 9; i++) {for (int j = 0; j < 9 - i - 1; ++j) {count++;if (tempNums[j] > tempNums[j + 1]) {int temp = tempNums[j];tempNums[j] = tempNums[j + 1];tempNums[j + 1] = temp;}}}System.out.println(count);

13. 类内存泄露（彭俊辉）：

内存泄露：是指程序在申请内存后，无法释放已申请的内存空间。

常发性内存泄漏：发生内存泄漏的代码被多次执行到，每次执行都会导致一块内存泄漏。

偶发性内存泄漏：发生内存泄漏的代码只在某些特定环境或操作下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。

一次性内存泄漏：发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块且只有一块内存发生泄漏。

隐式内存泄漏：程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。

一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光，最终导致内存溢出。

14.java多态的实现原理（张中毅）

Java实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

15.内部类和外部类的调用（张中毅）

内部类：在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

外部类：这是一个相对内部类的概念，如果一个类中嵌套了另外一个类，我们就把这个类叫做外部类。

外部类访问内部类：必须建立内部类的对象

内部类访问外部类：内部类可以直接访问外部类的成员包括私有成员，因为外部类持有内部类的引用

2019.1.7